In-depth Exploration of Struct in Embedded C Language

#include <iostream> 
#pragma pack(8) 
using namespace std;
struct example1 
{ 
 short a; 
 long b; 
}; 
struct example2 
{ 
 char c; 
 example1 struct1; 
 short e; 
}; 
#pragma pack() 
int main(int argc, char* argv[]) 
{ 
 example2 struct2; 
 cout << sizeof(example1) << endl; 
 cout << sizeof(example2) << endl; 
 cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2) << endl; 
 return 0; 
}

What is the input result of the program?

The answer is: 8 16 4

Natural alignment is the default alignment method, which aligns according to the largest member size in the structure.For example:

struct naturalalign 
{ 
 char a; 
 short b; 
 char c; 
}; 

In the above structure, the largest size is short, which is 2 bytes, so the char members a and c in the structure are aligned to 2. The result of sizeof(naturalalign) is 6 (the structure alignment is determined by the largest size);

If changed to:

struct naturalalign 
{ 
 char a; 
 int b; 
 char c; 
};

The result above is obviously 12, not 6. Let’s see, char is one byte, int is 4 bytes, so the largest in the structure is int b, so the alignment is calculated in 4-byte units. Therefore, even though char a is one byte, it still requires a 4-byte space.

Generally, the default alignment conditions can be changed using the following methods:Use the pseudo-instruction #pragma pack (n), and the compiler will align according to n bytes; · Use the pseudo-instruction #pragma pack (), to cancel the custom byte alignment.

Note:If the n specified in #pragma pack (n) is greater than the size of the largest member in the structure, it will not take effect; the structure will still align according to the size of the largest member.

For example:

#pragma pack (n) 
struct naturalalign 
{ 
 char a; 
 int b; 
 char c; 
}; 
#pragma pack ()

When n is 4, 8, or 16, the alignment method is the same, and the result of sizeof(naturalalign) is 12. However, when n is 2, it takes effect, making the result of sizeof(naturalalign) equal to 6.

Additionally, using __attribute((aligned (n))) can also align the structure members on n-byte boundaries.

For example, defining struct class and class class:

struct structA 
{ 
 char a; 
… 
} 
class classB 
{ 
 char a; 
 … 
} 
then: 
structA a; 
a.a = 'a'; // Access public member, valid 
classB b; 
b.a = 'a'; // Access private member, invalid

Many documents state that this has given the full difference between struct and class in C++, but in fact, there is another point that needs attention: Struct in C++ maintains full compatibility with struct in C (which aligns with C++’s original intention—“a better C”), therefore, the following operations are legal:

// Define struct 
struct structA 
{ 
 char a; 
 char b; 
 int c; 
}; 
structA a = {'a' , 'a' ,1}; // Directly assign initial values during definition

That is, struct can be directly assigned initial values to its member variables using { } when defined, while class cannot. In the classic book “Thinking C++ 2nd Edition,” the author emphasizes this point.

#include <iostream>
using namespace std;
struct structA
{
 int iMember;
 char* cMember;
};
int main(int argc, char* argv[])
{
 structA instant1, instant2;
 char c = 'a';
 instant1.iMember = 1;
 instant1.cMember = &c;
 instant2 = instant1;
 cout << *(instant1.cMember) << endl;
 *(instant2.cMember) = 'b';
 cout << *(instant1.cMember) << endl;
 return 0;
}

The output order of the above result is: a,b;

Why is this? Because in line 16, the modification of instant2 changes the value in instant1!

The reason is that the assignment statement instant2 = instant1 in line 14 uses variable-by-variable copying, which makes the cMember in both instant1 and instant2 point to the same memory, hence the modification of instant2 also modifies instant1.

END