我可以将 size_t 类型的 sizeof 的屈服值存储在 unsigned int 对象中吗？

Question

sizeof is a standard C operator.

sizeof yields the size (in bytes) of its operand in type size_t , Quote from ISO/IEC 9899:2018 (C18), 6.5.3.4/5. Phrases surrounded by -- are my addition for clarification of context:

The value of the result of both operators -- (sizeof and _Alignof) -- is implementation-defined, and its type (an unsigned integer type) is size_t , defined in <stddef.h> (and other headers).

Implicitly, if I want my program to be standard conform and want to use sizeof , I need to include one of the header files in which size_t is defined, because the value it yields is of type size_t and I want to store the value in an appropriate object.

Of course, in any program which would not be a toy program I would need at least one of these headers all the way up regardless but in a simple program I need to explictly include those headers, although I do not need them otherwise.

Can I use an unsigned int object to store the size_t value sizeof yields without an explicit cast?

Like for example:

char a[19];
unsigned int b = sizeof(a);

I compiled that with gcc and -Wall and -Werror option flag but it did not had anything to complain.

But is that standard-conform?

Answer 1

It is totally conformant, though if you have a very large object (typically 4GB or larger) its size may not fit into an unsigned int . Otherwise there is nothing to worry about.

Having said that, your question and this answer probably have more characters than you would save by not including an appropriate header in a lifetime worth of toy programs.

Answer 2

It is permissible but it is your responsibility to provide that there will not be an overflow storing a value of the type size_t in an object of the type unsigned int . For unsigned integer types overflow is well-defined behavior.

However it is a bad programming style to use types that were not designed to store values of a wider integer type. This can be a reason of hidden bugs.

Usually the type size_t is an alias for the type unsigned long . On some 64-bit systems, the type unsigned long has the same size as the type unsigned long long , which is 8 bytes instead of the 4 bytes that unsigned int can be stored in.

Answer 3

This is allowed. It is an implicit conversion ("as if by assignment"). See the section labelled "Integer conversions":

A value of any integer type can be implicitly converted to any other integer type. Except where covered by promotions and boolean conversions above, the rules are:

• if the target type can represent the value, the value is unchanged
• otherwise, if the target type is unsigned, the value 2^(b-1), where b is the number of bits in the target type, is repeatedly subtracted or added to the source value until the result fits in the target type. In other words, unsigned integers implement modulo arithmetic.

In other words, this is always defined behaviour, but if the size is too big to fit in an unsigned int , it will be truncated.

Answer 4

In principle it is ok. The unsigned int can handle almost any sizeof except artificially constructed exotic things.

PS I have seen code similar to yours even in Linux kernel modules.