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?

For `ptrdiff_t` to "overflow" , the object size has to be 1 (char sized). For object size > 2 everthing is ok. — Robert Andrzejuk, Aug 20 '18 at 17:07
@RobertAndrzejuk, Sorry if I wasn't clear enough. What I meant was: "pointers to elements of the array". — Constantineous, Aug 20 '18 at 17:13
What I wanted to bring your attention too,(using @NathanOliver quotes) is that given a definition `long long arr[2]`, then a subtraction `&arr[1] - &arr[0]` gives the result `1` (not `4` as may be expected). So to get this "overflow" problem You have to be dealing with raw memory (1 byte sized types). — Robert Andrzejuk, Aug 21 '18 at 12:11
@RobertAndrzejuk A remark though. One might expect the result of subtraction from your example to be 8, not 4. — Constantineous, Aug 21 '18 at 16:34

score 4 · Answer 1 · answered Aug 20 '18 at 16:27

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.

AnT stands with Russia · Accepted Answer · 2018-08-20T17:53:19.243

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"?

Indeed! Compiling the following code: `char array[SIZE_MAX/2+1];` results in error: size of array ‘array’ is too large — Constantineous, Aug 21 '18 at 14:54

score 3 · Answer 3 · answered Aug 20 '18 at 16:32

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.

size_t ptrdiff_t and address space

3 Answers3