View source for c/types/ptrdiff t

{{c/title|ptrdiff_t}}
{{c/types/navbar}}
{{ddcl|header=stddef.h|
typedef /*implementation-defined*/ ptrdiff_t;
}}

{{tt|ptrdiff_t}} is the signed integer type of the result of [[c/language/operator arithmetic#Pointer arithmetic|subtracting two pointers]].

{{rrev multi
|since1=c99|rev1=
The bit width of {{tt|ptrdiff_t}} is not less than 17.
|since2=c23|rev2=
The bit width of {{tt|ptrdiff_t}} is not less than 16.
}}

===Notes===
{{tt|ptrdiff_t}} is used for pointer arithmetic and array indexing, if negative values are possible. Programs that use other types, such as {{c|int}}, may fail on, e.g. 64-bit systems when the index exceeds {{lc|INT_MAX}} or if it relies on 32-bit modular arithmetic.

Only pointers to elements of the same array (including the pointer one past the end of the array) may be subtracted from each other.

If an array is so large (greater than {{lc|PTRDIFF_MAX}} elements, but equal to or less than {{lc|SIZE_MAX}} bytes), that the difference between two pointers may not be representable as {{tt|ptrdiff_t}}, the result of subtracting two such pointers is undefined.

For char arrays shorter than {{lc|PTRDIFF_MAX}}, {{tt|ptrdiff_t}} acts as the signed counterpart of {{lc|size_t}}: it can store the size of the array of any type and is, on most platforms, synonymous with {{tt|intptr_t}}).

===Possible implementation===
{{eq fun|1=
typedef typeof((int*)nullptr - (int*)nullptr) ptrdiff_t; // valid since C23
}}

===Example===
{{example
|code=
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    const size_t N = 100;
    int numbers[N];
    
    printf("PTRDIFF_MAX = %ld\n", PTRDIFF_MAX);
    int *p1 = &numbers[18], *p2 = &numbers[23];
    ptrdiff_t diff = p2 - p1;
    printf("p2-p1 = %td\n", diff);
}
|p=true
|output=
PTRDIFF_MAX = 9223372036854775807
p2-p1 = 5
}}

===References===
{{ref std c23}}
{{ref std|section=7.19|title=Common definitions <stddef.h>|p=TBD}}
{{ref std|section=7.20.3|title=Limits of other integer types|p=TBD}}
{{ref std end}}
{{ref std c17}}
{{ref std|section=7.19|title=Common definitions <stddef.h>|p=211}}
{{ref std|section=7.20.3|title=Limits of other integer types|p=215}}
{{ref std end}}
{{ref std c11}}
{{ref std|section=7.19|title=Common definitions <stddef.h>|p=288}}
{{ref std|section=7.20.3|title=Limits of other integer types|p=293}}
{{ref std end}}
{{ref std c99}}
{{ref std|section=7.17|title=Common definitions <stddef.h>|p=253}}
{{ref std|section=7.18.3|title=Limits of other integer types|p=258}}
{{ref std end}}
{{ref std c89}}
{{ref std|section=4.1.6|title=Common definitions <stddef.h>}}
{{ref std end}}

===See also===
{{dsc begin}}
{{dsc inc|c/types/dsc size_t}}
{{dsc inc|c/types/dsc offsetof}}
{{dsc see cpp|cpp/types/ptrdiff_t}}
{{dsc end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}