Do all pointers have the same size in C++?

by

While it might be tempting to conclude that all pointers are the same size because “pointers are just addresses, and addresses are just numbers of the same size”, it is not guaranteed by the standard and thus cannot be relied upon.

The C++ standard explicitly guarantees that:

  • void* has the same size as char* ([basic.compound]/5)
  • T const*, T volatile*, and T const volatile* have the same size as T*. This is because cv-qualified versions of the same type are layout-compatible, and pointers to layout-compatible types have the same value representation ([basic.compound]/3).
  • Similarly, any two enum types with the same underlying type are layout-compatible ([dcl.enum]/9), therefore pointers to such enum types have the same size.

It is not guaranteed by the standard, but it is basically always true in practice, that pointers to all class types have the same size. The reason for this is as follows: a pointer to an incomplete class type is a complete type, meaning that you are entitled to ask the compiler sizeof(T*) even when T is an incomplete class type, and if you then ask the compiler sizeof(T*) again later in the translation unit after T has been defined, the result must be the same. Furthermore, the result must also be the same in every other translation unit where T is declared, even if it is never completed in another translation unit. Therefore, the compiler must be able to determine the size of T* without knowing what’s inside T. Technically, compilers are still allowed to play some tricks, such as saying that if the class name starts with a particular prefix, then the compiler will assume that you want instances of that class to be subject to garbage collection, and make pointers to it longer than other pointers. In practice, compilers do not seem to use this freedom, and you can assume that pointers to different class types have the same size. If you rely on this assumption, you can put a static_assert in your program and say that it doesn’t support the pathological platforms where the assumption is violated.

Also, in practice, it will generally be the case that

  • any two function pointer types have the same size,
  • any two pointer to data member types will have the same size, and
  • any two pointer to function member types will have the same size.

The reason for this is that you can always reinterpret_cast from one function pointer type to another and then back to the original type without losing information, and so on for the other two categories listed above (expr.reinterpret.cast). While a compiler is allowed to make them different sizes by giving them different amounts of padding, there is no practical reason to do this.

(However, MSVC has a mode where pointers to members do not necessarily have the same size. It is not due to different amounts of padding, but simply violates the standard. So if you rely on this in your code, you should probably put a static_assert.)

If you have a segmented architecture with near and far pointers, you should not expect them to have the same size. This is an exception to the rules above about certain pairs of pointer types generally having the same size.

More Related Contents:

  1. How many levels of pointers can we have?
  2. Is a pointer with the right address and type still always a valid pointer since C++17?
  3. Is it legal to compare dangling pointers?
  4. Get pointer to object from pointer to some member
  5. What is a void pointer and what is a null pointer?
  6. casting via void* instead of using reinterpret_cast [duplicate]
  7. Pointer interconvertibility vs having the same address
  8. Does accessing a declared non-volatile object through a volatile reference/pointer confer volatile rules upon said accesses?
  9. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  10. What does “void *(*)(void *)” mean in C++?
  11. Are pointer variables just integers with some operators or are they “symbolic”?
  12. Conversion from Derived** to Base**
  13. Are pointers to non-static member function “formally” not considered pointers
  14. Is incrementing a null pointer well-defined?
  15. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?
  16. How do I use arrays in C++?
  17. What is the difference between const int*, const int * const, and int const *?
  18. Will std::string always be null-terminated in C++11?
  19. One-dimensional access to a multidimensional array: is it well-defined behaviour?
  20. Returning arrays from a function in c++
  21. Returning a pointer of a local variable C++
  22. Can I use if (pointer) instead of if (pointer != NULL)?
  23. Why does std::cout convert volatile pointers to bool?
  24. Cast pointer to member function to normal pointer
  25. Does this really break strict-aliasing rules?
  26. Can I Allocate a specific memory address using pointers in c++?
  27. In C/C++, is char* arrayName[][] a pointer to a pointer to a pointer OR a pointer to a pointer?
  28. Static global variables in C++
  29. What is the meaning of this star (*) symbol in C++? — Pointer to member
  30. non-const pointer argument to a const double pointer parameter

Leave a Comment