Why isn't sizeof for a struct equal to the sum of sizeof of each member?

When working with structs in C or C++, you may have come across a situation where the size of a struct is larger than the sum of the sizes of its individual members. This can be quite confusing, especially for beginners. In this article, we will explore the reasons behind this behavior and explain why the sizeof operator may return a size larger than expected for a struct.

Understanding the sizeof Operator

Before we delve into the specifics of why the sizeof operator behaves the way it does for structs, let us first understand what the sizeof operator does. In C and C++, the sizeof operator is used to determine the size in bytes of a type or a variable. It can be used with any data type, including primitive types like int and float, as well as user-defined types like structs and classes.

The sizeof operator is an unary operator that returns the size of its operand in bytes. It does not actually evaluate the operand or execute any code. Instead, it performs a compile-time calculation based on the type of the operand.

Padding and Alignment

To understand why the sizeof operator may return a larger size for a struct, we need to familiarize ourselves with the concepts of padding and alignment.


Padding refers to the insertion of additional bytes in a struct to meet alignment requirements. Alignment requirements are imposed by the hardware architecture and dictate how data should be organized in memory for efficient access.

Most computer architectures require that certain types of data, such as integers or pointers, be stored at specific memory addresses that are divisible by their size. For example, on a 32-bit architecture, integers should be aligned on 4-byte boundaries, while on a 64-bit architecture, they should be aligned on 8-byte boundaries.

To ensure the proper alignment of members, the compiler may insert padding bytes between struct members. These padding bytes are added to ensure that each member is properly aligned according to the architecture's requirements.


Alignment refers to the memory addresses at which fundamental data types are stored. The most common alignment requirements are 1-byte alignment, 2-byte alignment, 4-byte alignment, and 8-byte alignment. Different data types have different alignment requirements.

When a struct is defined, the compiler automatically determines the alignment requirements of each member and inserts padding bytes if necessary. The size of the struct is then calculated by summing the sizes of the individual members, including any padding bytes that have been inserted.


Let's consider an example to illustrate how padding and alignment can affect the size of a struct. Suppose we have the following struct in C:

        struct Example {
            char c;
            int i;
            float f;

In this struct, char is typically aligned on a 1-byte boundary, int on a 4-byte boundary, and float on a 4-byte boundary. The size of each member is 1 byte, 4 bytes, and 4 bytes, respectively. Therefore, if we were to calculate the size of this struct based on the sum of the sizes of its members, we would expect a size of 1 + 4 + 4 = 9 bytes.

However, due to padding and alignment requirements, the actual size of this struct when using the sizeof operator may be larger. On most architectures, the compiler would insert 3 padding bytes between the char and the int to ensure that the int is properly aligned on a 4-byte boundary. The resulting size of this struct would be 12 bytes.

Here's a graphical representation of the struct in memory:

        | c |   padding   |       i       |       f       |

As you can see, the 3 padding bytes have been inserted to align the int on a 4-byte boundary and ensure efficient memory access.

Sizeof Operator and Portable Code

It's worth noting that the padding and alignment requirements of a struct may vary depending on the specific architecture and compiler being used. This means that the size of a struct can differ on different systems.

If you're writing code that needs to be portable across different systems, it's important to take padding and alignment into account. You should never rely on the sizeof operator to calculate the size of a struct and assume that it will always be equal to the sum of the sizes of its members.

A more reliable way to determine the size of a struct is to use the sizeof operator on the struct itself. This will give you the actual size of the struct, including any padding bytes that have been added.


In conclusion, the sizeof operator may return a size larger than the sum of the sizes of the members of a struct due to padding and alignment requirements. Padding bytes are inserted between members to ensure proper alignment, as dictated by the hardware architecture. This can result in a larger size for the struct than expected.

Understanding padding and alignment is important when working with structs in C and C++. It allows you to write code that is aware of memory layout and is portable across different systems.