C ++ byte length, byte alignment, class, object Length

Byte Length, byte alignment, class, object Length

struct  st {short  num;float  math_grade;float  Chinese_grade;float  sum_grade;};int _tmain(int argc, _TCHAR* argv[]){cout << " sizeof('$')= " << sizeof ( ' $ ' ) << endl;    cout << " sizeof(1)= " << sizeof ( 1 ) << endl;cout << " sizeof(1.5)= " << sizeof ( 1.5 ) << endl;  cout << " sizeof(Good!)= " ;cout << sizeof ( " Good! " ) << endl; int  i = 100 ;char  c = ' A ' ;float  x = 3.1416 ; double  p = 0.1 ;cout << " sizeof(i)= " << sizeof (i) << endl;cout << " sizeof(c)= " << sizeof (c) << endl;cout << " sizeof(x)= " << sizeof (x) << endl;cout << " sizeof(p)= " << sizeof (p) << endl; cout << " sizeof(x+1.732)= " << sizeof (x + 1.732 ) << endl;cout << " sizeof(char)= " << sizeof ( char ) << endl;cout << " sizeof(int)= " << sizeof ( int ) << endl;cout << " sizeof(float)= " << sizeof ( float ) << endl;cout << " sizeof(double)= " << sizeof ( double ) << endl;char  str[] = " This is a test. " ;int  a[ 10 ]; double  xy[ 10 ];cout << " sizeof(str)= " << sizeof (str) << endl;cout << " sizeof(a)= " << sizeof (a) << endl;cout << " sizeof(xy)= " <<   sizeof (xy) << endl;st student1;cout << " sizeof(st)= " << sizeof (st) << endl;cout << " sizeof(student1)= " << sizeof (student1);return 0;}

 

---------------------------- The result are :-------------------------------------

 

To enable the CPU to efficiently and quickly access variables, the starting address of the variable should have some characteristics, that is, the so-called "alignment ". For example, for a 4-byte int type variable, its starting address should be located on the 4-byte boundary, that is, the starting address can be divisible by 4. The variable alignment rules are as follows (32-bit system ):

Type alignment

Char alignment on Byte Boundary

Short (16-bit) alignment on the dual-byte Boundary

INT and long (32-bit) are aligned on the 4-byte Boundary

Float is aligned on the 4-byte Boundary

Double is aligned on the 8-byte Boundary

 

Structures considers the individual members of the struct, which are aligned on different byte boundaries. The maximum number of boundary bytes is the number of boundary bytes of the structure. In the original words of msdn: largest alignment requirement of any member, understanding the alignment of a struct is a bit scratching its head. If the struct contains struct Members, this is a recursive process. Alignment affects the offset of struct members in the struct. the maximum number of alignment byte Boundary set by the compiler is N. For a member item in the struct, it is aligned with the actual number of bytes at the beginning of the structure X should meet the following rules:

X = min (n, sizeof (item ))

For example, for struct {char a; int B} t;

When the system is 32-bit, n = 8: The offset of A is 0, the offset of B is 4, 3 bytes are filled in the middle, and X of B is 4;

In a 32-bit system, if n = 2: The offset of A is 0, the offset of B is 2, 1 byte is filled in the middle, and X of B is 2;

The sizeof of struct is set to lastitem as the last member of the struct, and its offset relative to the first address of the struct is offset (lastitem). Its size is sizeof (lastitem), and the bytes of the struct are aligned to n, then: the sizeof of struct is: If offset (lastitem) + sizeof (lastitem) can be divisible by N, It is offset (lastitem) + sizeof (lastitem). Otherwise, it will be filled later, until it can be divisible by N.

Example: 32-bit system, n = 8, struct {char a; char B;} t; struct {char a; int B;} T1; struct {char; int B; char C;} T2; sizeof (t) = 2; n = 1 No sizeof (t) = 8; 3 bytes in the middle of N = 4 sizeof (T2) = 12; n = 4, and 3 bytes in the end

Note:

1) For an empty struct, sizeof = 1, because each instance of the struct must have a unique address in the memory.

2) The static member of the struct does not affect the size of the struct because the storage location of the static variable is irrelevant to the instance address of the struct.

For example:

Struct {static int I ;}t; struct {char a; static int I ;}t1; sizeof (t) = 1; sizeof (T1) = 1;

3) Some compilers support extension instructions to set the alignment of variables or structures, such as VC. For details, see msdn (alignment of structures)

 

# Pragma pack (8) is not required. Each member must be 8-byte aligned, but a group of Members must be 8-byte aligned. Struct S1 {short a; // 2 bytes long B; // 4 bytes}; the whole S1 is smaller than 8 bytes, so S1 is 8 bytes.

Struct S2 {char C; // 1 byte S1 D; // 8 byte _ int64 E; // 8 byte}; the entire S2 is less than 12 bytes, however, due to the limitation of # pragma pack (8), 12 cannot be aligned with 8 bytes, so S2 is 24 bytes, and C occupies 8 bytes ---------------------------------
Class or object length: Non-virtual functions are equivalent to the global ones, not in the class. Static is global, not in the class. However, the const needs to allocate space.

Non-static variables, virtual function linked list (if there is a virtual function in the class) --------- allocate space

Original article: http://www.cppblog.com/mzty/archive/2005/10/24/832.html