C language Review (4) bytes occupied by struct

 

Struct mystruct
{
Double dda1;
Char DDA;
Int type
};
What will happen if sizeof is used for the structure mystruct? What is sizeof (mystruct? Maybe you

The following is the result:
Sizeof (mystruct) = sizeof (double) + sizeof (char) + sizeof (INT) = 13
However, when the above structure is tested in VC, you will find that sizeof (mystruct) is 16. You know why

Will such a result be obtained in VC?
In fact, this is a special processing of variable storage by VC. To speed up CPU storage

The starting address is aligned. By default, VC specifies that the starting address of each member variable is relative to the ending address.

The offset of the starting address must be a multiple of the number of bytes occupied by the variable type. The following lists common types

Alignment mode (vc6.0, 32-bit system ).
Type alignment (offset of the starting address of the variable to the starting address of the structure)
The Char offset must be sizeof (char), that is, a multiple of 1.
The short offset must be a multiple of sizeof (short), that is, 2.
The Int offset must be a multiple of sizeof (INT), that is, 4.
The float offset must be a multiple of sizeof (float), that is, 4.
The double offset must be sizeof (double), that is, a multiple of 8.
When each member variable is stored, it applies for space in sequence according to the order in which the structure appears.

Adjust the position in full mode. The vacant byte VC is automatically filled. At the same time, to ensure that the size of the structure is the byte edge of the Structure

The number of bounds (that is, the number of bytes occupied by the type that occupies the maximum space in the structure ).

After the variable is applied for space, the vacant bytes are automatically filled as needed.

The following uses the previous example to illustrate how VC stores the structure.
Struct mystruct
{
Double dda1;
Char DDA;
Int type
};
When allocating space for the above structure, VC is the first according to the sequence and alignment of the member variables.

The member dda1 allocates space. The starting address is the same as the starting address of the structure (the offset 0 is exactly sizeof (doub

The member variable occupies the sizeof (double) = 8 bytes. Then, the second member DDA is allocated with null values.

The offset of the next allocable address to the starting address of the structure is 8, which is a multiple of sizeof (char ).

Therefore, the DDA is stored in an alignment where the offset is 8. This member variable occupies sizeof (char) = 1 word.

Next, allocate space for the third member type. Then, the next address that can be allocated is the starting address of the structure.

The offset of is 9, not a multiple of sizeof (INT) = 4. To meet the offset constraints of alignment

Fill 3 bytes (these three bytes do not have anything), then the next address that can be allocated starts with the structure

The offset of the Start address is 12, which is a multiple of sizeof (INT) = 4. Therefore, the type is stored in the location where the offset is 12.

The member variable occupies sizeof (INT) = 4 bytes. At this time, the member variables in the entire structure have been allocated space, total

The occupied space is 8 + 1 + 3 + 4 = 16, which is exactly the number of bytes boundary in the structure (that is,

The number of bytes occupied by the Type sizeof (double) = 8), so no vacant bytes need to be filled. So the whole

Structure size: sizeof (mystruct) = 8 + 1 + 3 + 4 = 16, three of which are automatically filled by VC, no

Put anything meaningful.
Next, let's take another example to change the position of the member variable of mystruct above to the following:

Struct mystruct

{
Char DDA;
Double dda1;
Int type
};
How much space does this structure occupy? In the vc6.0 environment, we can obtain that sizeof (mystruc) is 24. End

Based on the space allocation principles mentioned above, we will analyze how VC allocates space for the above structure. (To put it simply

Ming)
Struct mystruct
{
Char DDA; // The offset is 0. The alignment is satisfied and the DDA occupies 1 byte;
Double dda1; // the offset of the next available address is 1, not sizeof (double) = 8
// Multiple. You need to add 7 bytes to make the offset 8 (the alignment is satisfied ).
// Method). Therefore, VC automatically fills in 7 bytes, and dda1 is stored at an offset of 8
// Address, which occupies 8 bytes.
Int type; // the offset of the next available address is 16, which is twice that of sizeof (INT) = 4.
// Number, which meets the alignment of int, so no VC auto-fill is required.
// Put the address at the offset of 16, which occupies 4 bytes.
}; // All member variables are allocated space. The total size of the space is 1 + 7 + 8 + 4 = 20, not a structure.
// Number of knots (that is, the number of bytes occupied by the largest space type in the structure sizeof
// (Double) = 8), so four bytes need to be filled to meet the structure size
// Sizeof (double) = a multiple of 8.
Therefore, the total size of this structure is: sizeof (mystruc) is 1 + 7 + 8 + 4 + 4 = 24. The total size is 7 + 4 = 11 bytes.

It is automatically filled by VC, and nothing makes sense.
The special processing of structured storage by VC does increase the speed of CPU storage variables, but sometimes it also brings some trouble

We also eliminate the default alignment of variables. We can set the alignment of variables by ourselves.
# Pragma pack (n) is provided in VC to set the variable to n-byte alignment. N-byte alignment means variable Storage

There are two types of offsets for the starting address: first, if n is greater than or equal to the number of bytes occupied by the variable, the offset is biased.

The shift must meet the default alignment. Second, if n is less than the number of bytes occupied by the type of the variable, the offset

The default alignment mode is not required because the number is a multiple of N. The total size of the structure also has a constraint, which is divided into the following two conditions:

: If n is greater than the number of bytes occupied by all member variable types, the total size of the structure must be

A multiple of the space occupied by the variable;
Otherwise, it must be a multiple of N. The following is an example of its usage.
# Pragma pack (push) // save alignment status
# Pragma pack (4) // set to 4-byte alignment
Struct Test
{
Char M1;
Double M4;
Int m3;
};
# Pragma pack (POP) // restore alignment

The size of the above structure is 16, and the storage is analyzed below. First, space is allocated for M1, and its offset is 0, which meets

We set our own alignment mode (4-byte alignment). M1 occupies 1 byte. Then we start to allocate space for M4.

The offset is 1 and three bytes need to be supplemented. In this way, the offset must be a multiple of N = 4 (because sizeof (double) is large.

At N), M4 occupies 8 bytes. Then allocate space for M3. At this time, the offset is 12, which must be a multiple of 4.

4 bytes. At this time, space has been allocated for all member variables. A total of 16 bytes are allocated, which is a multiple of N. For example

If we change # pragma pack (4) to # pragma pack (16), the size of the structure is 24.