Is size_t
the word size of the machine that compiled the code?
Parsing with g++, my compiler views size_t
as an long unsigned int
Such definitions are all implementation defined. I would use the sizeof(char *), or maybe sizeof(void *), if I needed a best guess size. The best this gives is the apparent word size software uses... what the hardware really has may be different (e.g., a 32-bit system may support 64-bit integers by software).
Also if you are new to the C languages see stdint.h for all sorts of material on integer sizes.
size_t was, orignally, just a typedef in sys/types.h (traditionally on Unix/Linux). It was assumed to be 'big enough' for, say, the maximum size of a file, or the maximum allocation with malloc. However, over time, standard committees grabbed it, and so it wound up copied into many different header files, protected each time with its own #ifdef protection from multiple definition. On the other hand, the emergence of 64-bit systems with very big potential file sizes clouded its role. So it's a bit of a palimpset.
Language standards now call it out as living in stddef.h. It has no necessary relationship to the hardware word size, and no compiler magic. See other answers with respect to what those standards say about how big it is.
No; size_t
is not necessarily whatever you mean by 'the word size' of the machine that will run the code (in the case of cross-compilation) or that compiled the code (in the normal case where the code will run on the same type of machine that compiled the code). It is an unsigned integer type big enough to hold the size (in bytes) of the largest object that the implementation can allocate.
sizeof
and size_t
I don't know when size_t
was introduced exactly, but it was between 1979 and 1989. The 1st Edition of K&R The C Programming Language from 1978 has no mention of size_t
. The 7th Edition Unix Programmer's Manual has no mention of size_t
at all, and that dates from 1979. The book "The UNIX Programming Environment" by Kernighan and Pike from 1984 has no mention of size_t
in the index (nor of malloc()
or free()
, somewhat to my surprise), but that is only indicative, not conclusive. The C89 standard certainly has size_t
.
The C99 Rationale documents some information about sizeof()
and size_t
:
6.5.3.4 The sizeof operator
It is fundamental to the correct usage of functions such as
malloc
andfread
thatsizeof(char)
be exactly one. In practice, this means that a byte in C terms is the smallest unit of storage, even if this unit is 36 bits wide; and all objects are composed of an integer number of these smallest units. Also applies if memory is bit addressable. C89, like K&R, defined the result of thesizeof
operator to be a constant of an unsigned integer type. Common implementations, and common usage, have often assumed that the resulting type isint
. Old code that depends on this behavior has never been portable to implementations that define the result to be a type other thanint
. The C89 Committee did not feel it was proper to change the language to protect incorrect code.The type of
sizeof
, whatever it is, is published (in the library header<stddef.h>
) assize_t
, since it is useful for the programmer to be able to refer to this type. This requirement implicitly restrictssize_t
to be a synonym for an existing unsigned integer type. Note also that, althoughsize_t
is an unsigned type,sizeof
does not involve any arithmetic operations or conversions that would result in modulus behavior if the size is too large to represent as asize_t
, thus quashing any notion that the largest declarable object might be too big to span even with anunsigned long
in C89 oruintmax_t
in C99. This also restricts the maximum number of elements that may be declared in an array, since for any arraya
ofN
elements,
N == sizeof(a)/sizeof(a[0])
Thus
size_t
is also a convenient type for array sizes, and is so used in several library functions. [...]7.17 Common definitions
<stddef.h>
is a header invented to provide definitions of several types and macros used widely in conjunction with the library:ptrdiff_t
,size_t
,wchar_t
, andNULL
. Including any header that references one of these macros will also define it, an exception to the usual library rule that each macro or function belongs to exactly one header.
Note that this specifically mentions that the <stddef.h>
was invented by the C89 committee. I've not found words that say that size_t
was also invented by the C89 committee, but if it was not, it was a codification of a fairly recent development in C.
In a comment to bmargulies answer, vonbrand says that 'it [size_t
] is certainly an ANSI-C-ism'. I can very easily believe that it was an innovation with the original ANSI (ISO) C, though it is mildly odd that the rationale doesn't state that.
Although the definition does not directly state what type exactly size_t
is, and does not even require a minimum size, it indirectly gives some good hints. A size_t
must be able to contain the size in bytes of any object, in other words, it must be able to contain the size of the largest possible object.
The largest possible object is an array (or structure) with a size equal to the entire available address space. It is not possible to reference a larger object in a meaningful manner, and apart from the availability of swap space there is no reason why it should need to be any smaller.
Therefore, by the wording of the definition, size_t
must be at least 32 bits on a 32 bit architecture, and at least 64 bits on a 64 bit system. It is of course possible for an implementation to choose a larger size_t
, but this is not usually the case.
Not necessarily. The C ISO spec (§17.1/2) defines size_t
as
size_t, which is the unsigned integer type of the result of the
sizeof
operator
In other words, size_t
has to be large enough to hold the size of any expression that could be produced from sizeof
. This could be the machine word size, but it could be dramatically smaller (if, for example, the compiler limited the maximum size of arrays or objects) or dramatically larger (if the compiler were to let you create objects so huge that a single machine word could not store the size of that object).
Hope this helps!
In the C++ standard, [support.types] (18.2) /6: "The type size_t
is an implementation-defined unsigned integer type that is large enough to contain the size in bytes of any object."
This may or may not be the same as a "word size", whatever that means.