不同编译器中的指针大小

Question

Let's say we're targetting one particular hardware architecture, one particular operating system (if applicable) and one particular "bitness" (32 vs. 64 etc). In such case, is it safe to assume that different compilers will use the same sizeof(T*) for the same T ? Does the standard rule on this one way or another?

Even if it's not guaranteed by the standard, would/does this hold for "most normal compilers intended for normal use and efficiency?" I can imagine a theoretical Hell++ would use different sizes if allowed, but how about compilers people actually use?

I would also be interested in other types I see as closely related to pointers ( std::size_t , std::ptrdiff_t , std::intptr_t ).

As a "bonus question," can anything be said about other built-in types (eg char , int , float , long )? However, encountering different sizes across compilers wouldn't really surprise me with these.

EDIT

One more piece to consider: would this be affected by extern "C" linkage? As an example of application, if I have a library which publishes this function:

extern "C" void foo(void *);

is it theoretically possible I will not be able to call the function correctly, because the library's compiler used a different sizeof(void*) than my compiler does?

Answer 1

No, pointers to different data types are not required to be of the same size. One particular case when a pointer may not have an "expected" size is pointers to member functions. In order to be able to support virtual functions, member function pointers are usually implemented using some sort of struct, an array of pointers, whatever. For example, on my architecture, void * is 8 bytes long, but (Foo::*)() is 16:

h2co3-macbook:~ h2co3$ cat quirk.cpp
#include <iostream>
#include <algorithm>

class Foo {
    public:
    void bar()
    {
        std::cout << "bar()" << std::endl;
    }
};

int main()
{
    std::cout << "sizeof void *: " << sizeof(void *) << std::endl;
    std::cout << "sizeof (Foo::*)(): " << sizeof(&Foo::bar) << std::endl;
    return 0;
}
h2co3-macbook:~ h2co3$ clang++ -Wall -o quirk quirk.cpp
h2co3-macbook:~ h2co3$ ./quirk
sizeof void *: 8
sizeof (Foo::*)(): 16

The size of other types ( int , float , etc.) will also vary widely depending on compiler, architecture, and even some compiler flags and settings.