struct A
{
    int a;
    char b;
    short c;
};

struct B
{
    char a;
    int b;
    short c;
};

#pragma pack(2)
struct C
{
    char a;
    int b;
    short c;
};

#pragma pack(1)
struct D
{
    int a;
    char b;
    short c;
};

int _tmain(int argc, _TCHAR* argv[])
{

    cout << sizeof(A) << "   "<< sizeof B << "   "<< sizeof C << "   "<< sizeof D <<endl;
    return 0;
}

    step 1: 确实结构体B对齐值：选择成员中最大的对齐值，即int a，对齐值为4
    step 2: 确定手工指定对齐值，使用默认的值：4(windows 32, VC6.0平台)　　　
    step 3: char a 的有效地址值=min(1,4),a的地址就是 0X0000(因为0x0000%1=0)　
    step 4: int b 的有效对齐值=min(4,4)，地址依次从0x0004~0x0007 (因为Ox0004%1=0)开始，分配4个字节，目前j地址段分配情况就是：0x0000~0x0007　　　　
    step 5: short c 的有效对齐值=min(2,4)，c从0x0008~0x0009(因为0x0008%2=0)开始，偏移2个字节的地址0x0006~0x0007.
    至止，地址段的分配情况就是：0x0000~0x0009共10个字节，但是Struct B的对齐值为4,这就要求地址地段再偏移2个字节,这样就是从0x0000~0x000B共12(因为12%4=0)个字节大小。这样，sizeof(B)=12.

    step 1: 确定结构体C对齐值：选择成员中最大的对齐值，即int a，对齐值为4  　　
    step 2: 确定手工指定对齐值，使用手工指定的值：2
    step 3: char a 的有效地址值=min(1,2),(因为0x0000%2=0)，这样a的地址就是0x0000　
    step 4: int b 的有效对齐值=min(4,2)，地址依次从0x0002~0x0005 (因为Ox0002%2=0)开始，分配4个字节，目前地址段分配情况就是：0x0000~0x0005　　　　
    step 5: short c 的有效对齐值=min(2,2)，由于要求考虑到对齐的情况,从0x0006(因为0x0006%2=0)开始，分配2个字节的地址0x0006~0x0007
    目前为止，地址段的分配情况就是：0x0000~0x0007共8个字节，同时也保证了Struct C的对齐情况（2字节对齐,pragma(2)），sizeof(C)=8.

#include <iostream>
using namespace std;
// 没有指定对齐字节，则使用 结构体或类 中字节最大的类型字节值(前提是不超过 8 字节，当超过8字节，则采用4字节对齐)
struct A  // 8 ->(8%4 == 0)-> 8
{
    int a;     //4
    char b;
    short c;
};

struct B     // 10 ->(10%4 != 0)-> 12
{
    char a;
    int b;     // 4
    short c;
};

struct C  // 12 ->(12%8 != 0)-> 16
{
    double b;     // 8
    char a;
    short c;
};

struct D  // 18 ->(18%8 != 0)-> 24
{
    char a;
    double b;     // 8
    short c;
};

struct E  // 20 ->(20%4 == 0)-> 20
{
    char a;
    long double b;     // (12 > 8) -> 采用 4 字节对齐， 和 #pragma pack(4) 效果一样
    short c;
};

struct F  // 16 ->(16%4 == 0)-> 16
{
    long double b;     // 12
    char a;
    short c;
};

#pragma pack(4) // 和 struct E 效果一样
struct G  // 20 ->(20%4 == 0)-> 20
{
    char a;
    long double b;     // 12
    short c;
};

#pragma pack(2) // 会影响后续类型的对齐有效值，直到重新设置
struct H // 8 ->(8%2 == 0)-> 8
{
    char a;
    int b;
    short c;
};

//#pragma pack(2)
struct I // 12 ->(12%2 == 0)-> 12
{
    char a;
    double b; // 8
    short c;
};

#pragma pack(1)
struct J  // 7 ->(7%1 == 0)-> 7
{
    int a;
    char b;
    short c;
};

int main()
{    
    long double bb;
    cout << sizeof(bb) << endl;  // 12
    // 输出结果为： 8 12 16 24 20 16 20 8 12 7

    cout << sizeof(A) << "   "<< sizeof(B) << "   "<< sizeof(C) << "   "<< sizeof(D) << "   "<< sizeof(E) << "   "<< sizeof(F) << "   "<< sizeof(G) << "   "<< sizeof(H) << "   "<< sizeof(I) << "   "<< sizeof(J) << endl;
    return 0;
}