Important Data Types
====================
The result of subtracting two pointers in C is always an integer,
but the precise data type varies from C compiler to C compiler.
Likewise, the data type of the result of `sizeof' also varies between
compilers. ISO defines standard aliases for these two types, so you
can refer to them in a portable fashion. They are defined in the
header file `stddef.h'.
- Data Type: ptrdiff_t
This is the signed integer type of the result of subtracting two
pointers. For example, with the declaration `char *p1, *p2;', the
expression `p2 - p1' is of type `ptrdiff_t'. This will probably
be one of the standard signed integer types (`short int', `int' or
`long int'), but might be a nonstandard type that exists only for
this purpose.
- Data Type: size_t
This is an unsigned integer type used to represent the sizes of
objects. The result of the `sizeof' operator is of this type, and
functions such as `malloc' (Note:Unconstrained Allocation) and
`memcpy' (Note:Copying and Concatenation) accept arguments of
this type to specify object sizes.
*Usage Note:* `size_t' is the preferred way to declare any
arguments or variables that hold the size of an object.
In the GNU system `size_t' is equivalent to either `unsigned int' or
`unsigned long int'. These types have identical properties on the GNU
system and, for most purposes, you can use them interchangeably.
However, they are distinct as data types, which makes a difference in
certain contexts.
For example, when you specify the type of a function argument in a
function prototype, it makes a difference which one you use. If the
system header files declare `malloc' with an argument of type `size_t'
and you declare `malloc' with an argument of type `unsigned int', you
will get a compilation error if `size_t' happens to be `unsigned long
int' on your system. To avoid any possibility of error, when a
function argument or value is supposed to have type `size_t', never
declare its type in any other way.
*Compatibility Note:* Implementations of C before the advent of
ISO C generally used `unsigned int' for representing object sizes and
`int' for pointer subtraction results. They did not necessarily define
either `size_t' or `ptrdiff_t'. Unix systems did define `size_t', in
`sys/types.h', but the definition was usually a signed type.