size_t ptrdiff_t and address space

Question

On my system both ptrdiff_t and size_t are 64-bit .

I would like to clarify two things:

• I believe that no array could be as large as size_t due to address space restrictions. Is this true?

• If yes, then, is there a guarantee that ptrdiff_t will be able to hold the result of subtraction of any pointers within the max-sized array?

Answer 1

No, there is no such guarantee. See, for example, here: https://en.cppreference.com/w/cpp/types/ptrdiff_t

If an array is so large (greater than PTRDIFF_MAX elements, but less than SIZE_MAX bytes), that the difference between two pointers may not be representable as std::ptrdiff_t, the result of subtracting two such pointers is undefined.

Answer 2

Most implementations artificially restrict the maximum array size to make sure that difference between two pointers pointing into the same array fits into ptrdiff_t . So, it is more than likely that on your platform the maximum allowed array size is about SIZE_MAX / 2 (try it). This is not an "address space restriction", it is just a restriction internally enforced by your implementation. Under this restriction, legal pointer subtraction ("legal" = two pointers into the same array) will not overflow.

The language specification does not require that though. Implementations are not required to restrict their array size in that way, meaning that language specification allows seemingly legal pointer subtractions to overflow and produce undefined behavior. But most implementations prefer to defend against this by restricting their array sizes.

See the "three options" here for more details: Why is the maximum size of an array "too large"?

Answer 3

From [support.types.layout]/3

The type size_t is an implementation-defined unsigned integer type that is large enough to contain the size in bytes of any object.

So you are guaranteed that size_t can hold the size of the largest array you can have.

ptrdiff_t unfortunately is not so guaranteed. From [support.types.layout]/2

The type ptrdiff_t is an implementation-defined signed integer type that can hold the difference of two subscripts in an array object, as described in 8.7.

Which is okay-ish but then we have [expr.add]/5

When two pointers to elements of the same array object are subtracted, the type of the result is an implementation-defined signed integral type; this type shall be the same type that is defined as std::ptrdiff_t in the header (21.2). If the expressions P and Q point to, respectively, elements x[i] and x[j] of the same array object x, the expression P - Q has the value i − j; otherwise, the behavior is undefined. [ Note: If the value i − j is not in the range of representable values of type std::ptrdiff_t, the behavior is undefined. —end note ]

Which states that ptrdiff_t may not be large enough.