Compile-time type functions

Every object a program uses occupies some amount of memory. Usually you do not need to think about that amount, but sometimes you must know it exactly. A low-level program that stores data in a fixed-size buffer depends on knowing how many bytes each value takes. So does a piece of code that must lay out data for another system.

The source for this topic describes a built-in tool for exactly this purpose: the sizeof operator. Instead of writing code that calculates an object's size, you ask the language for the answer.

Two details in that definition matter. First, the unit is the byte. Second, the operator reports what the object occupies in storage, which is a different question from how many items the object holds. A value of type int is one object, and sizeof reports the bytes that one object takes up.

The chapter this topic belongs to is about compile-time type functions. The result of sizeof describes a type, so the compiler can determine it without running the program. That is the idea behind the word compile-time: the value is settled while the program is being built, not while it executes.

The diagram below traces this path. The source code contains a line that uses sizeof. The compiler evaluates that expression during the build. The resulting constant is then fixed before the program runs.

The source states that sizeof can be applied to a type, such as int, and also to an object. In the type form you place a type name inside the parentheses, as in sizeof(int). The expression then evaluates to the number of bytes in one object of that type. In the object form you give sizeof a variable name instead of a type name.

The two forms describe the same quantity when the object's type is the type named in the type form. If x is an int, then sizeof(x) and sizeof(int) ask about the same storage.

The source example uses the type form. It declares a named constant called szi, of type int, and initializes it with sizeof(int). The source comment describes the meaning of the value: it is the number of bytes in an int. The question to answer is what number szi will hold.

The keyword constexpr is why this example is useful. sizeof produces a value that can be used directly in a constant declaration like this one. Notice that the example never writes the number of bytes. It asks the language for it.

sizeof counts each byte that an object occupies. The diagram below shows an object as a row of byte positions. Each position is one byte of that object's storage. The row here has four positions only to make the idea visible. The real number of bytes for a given type is set by the implementation, so do not treat this picture as a fixed size for int.

When you read sizeof(x), the answer is the length of that run. The count is in bytes, so a larger count means the object takes more storage, not that it holds more items.