结构体字节对齐

最新推荐文章于 2025-06-25 13:47:35 发布
最新推荐文章于 2025-06-25 13:47:35 发布
阅读量461 收藏
点赞数 1
文章标签： 结构体 字节对齐 C++

原文1网址：点击打开链接

 在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。从理论上讲，对于任何 变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列， 而不是简单地顺序排列，这就是内存对齐。

      内存对齐的原因：

      1)某些平台只能在特定的地址处访问特定类型的数据；

      2)提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。

       win32平台下的微软C编译器对齐策略：

      1)结构体变量的首地址能够被其最宽数据类型成员的大小整除。编译器在为结构体变量开辟空间时，首先找到结构体中最宽的数据类型，然后寻找内存地址能被该数据类型大小整除的位置，这个位置作为结构体变量的首地址。而将最宽数据类型的大小作为对齐标准。

      2)结构体每个成员相对结构体首地址的偏移量(offset)都是每个成员本身大小的整数倍，如有需要会在成员之间填充字节。编译器在为结构体成员开辟空 间时，首先检查预开辟空间的地址相对于结构体首地址的偏移量是否为该成员大小的整数倍，若是，则存放该成员；若不是，则填充若干字节，以达到整数倍的要 求。

      3)结构体变量所占空间的大小必定是最宽数据类型大小的整数倍。如有需要会在最后一个成员末尾填充若干字节使得所占空间大小是最宽数据类型大小的整数倍。

 

下面看一下sizeof在计算结构体大小的时候具体是怎样计算的

1.test1   空结构体

typedef struct  node
{
     
}S;

则sizeof(S)=1;或sizeof(S)=0;

在C++中占1字节，而在C中占0字节。

2.test2

typedef struct  node1
{
     int  a;
     char  b;
     short  c;
}S1;

则sizeof(S1)=8。这是因为结构体node1中最长的数据类型是int，占4个字节，因此以4字节对齐，则该结构体在内存中存放方式为

|--------int--------|   4字节

|char|----|--short-|   4字节

总共占8字节

3.test3

typedef struct  node2
{
     char  a;
     int  b;
     short  c;
}S2;

 则siezof(S3)=12.最长数据类型为int，占4个字节。因此以4字节对齐，其在内存空间存放方式如下:

|char|----|----|----|  4字节

|--------int--------|  4字节

|--short--|----|----|  4字节

总共占12个字节

4.test4  含有静态数据成员 

typedef struct  node3
{
     int  a;
     short  b;
     static  int  c;
}S3;

则sizeof(S3)=8.这里结构体中包含静态数据成员，而静态数据成员的存放位置与结构体实例的存储地址无关(注意只有在C++中结构体中才能含有静态数据成员，而C中结构体中是不允许含有静态数据成员的)。其在内存中存储方式如下：

|--------int--------|   4字节

|--short-|----|----|    4字节

而变量c是单独存放在静态数据区的，因此用siezof计算其大小时没有将c所占的空间计算进来。

5.test5  结构体中含有结构体

typedef struct  node4
{
     bool  a;
     S1 s1;
     short  b;
}S4;

则sizeof(S4)=16。是因为s1占8字节，而s1中最长数据类型为int，占4个字节，bool类型1个字节，short占2字节，因此以4字节对齐，则存储方式为

|-------bool--------|  4字节

|-------s1----------|  8字节

|-------short-------|  4字节

6.test6

typedef struct  node5
{
     bool  a;
     S1 s1;
     double  b;
     int  c;
}S5;

则sizeof(S5)=32。是因为s1占8字节，而s1中最长数据类型为int，占4字节，而double占8字节，因此以8字节对齐，则存放方式为：

|--------bool--------|    8字节

|---------s1---------|    8字节

|--------double------|    8字节

|----int----|---------|     8字节 

7.test7 

若在程序中使用了#pragma pack(n)命令强制以n字节对齐时，默认情况下n为8.

则比较n和结构体中最长数据类型所占的字节大小，取两者中小的一个作为对齐标准。

若需取消强制对齐方式，则可用命令#pragma pack()

如果在程序开头使用命令#pragma pack(4)，对于下面的结构体

typedef struct  node5
{
     bool  a;
     S1 s1;
     double  b;
     int  c;
}S5;

则sizeof(S5)=24.因为强制以4字节对齐，而S5中最长数据类型为double，占8字节，因此以4字节对齐。在内存中存放方式为：

  |-----------a--------|   4字节

  |--------s1----------|   4字节

  |--------s1----------|   4字节

  |--------b-----------|   4字节

  |--------b-----------|   4字节

  |---------c----------|    4字节

总结一下，在计算sizeof时主要注意一下几点：

1)若为空结构体，则只占1个字节的单元

2)若结构体中所有数据类型都相同，则其所占空间为 成员数据类型长度×成员个数

若结构体中数据类型不同，则取最长数据类型成员所占的空间为对齐标准，数据成员包含另一个结构体变量t的话，则取t中最 长数据类型与其他数据成员比较，取最长的作为对齐标准，但是t存放时看做一个单位存放，只需看其他成员即可。

3)若使用了#pragma pack(n)命令强制对齐标准，则取n和结构体中最长数据类型占的字节数两者之中的小者作为对齐标准。

 

另外除了结构体中存在对齐之外，普通的变量存储也存在字节对齐的情况，即自身对齐。编译器规定：普通变量的存储首地址必须能被该变量的数据类型宽度整除。

测试程序：

?
/*测试sizeof运算符  2011.10.1*/
 
#include <iostream>
using  namespace  std;
//#pragma pack(4)    //设置4字节对齐
//#pragma pack()     //取消4字节对齐
 
typedef  struct  node
{
     
}S;
 
typedef  struct  node1
{
     int  a;
     char  b;
     short  c;
}S1;
 
typedef  struct  node2
{
     char  a;
     int  b;
     short  c;
}S2;
 
typedef  struct  node3
{
     int  a;
     short  b;
     static  int  c;
}S3;
 
typedef  struct  node4
{
     bool  a;
     S1 s1;
     short  b;
}S4;
 
typedef  struct  node5
{
     bool  a;
     S1 s1;
     double  b;
     int  c;
}S5;
 
 
 
int  main( int  argc,  char  *argv[])
{
     cout<< sizeof ( char )<< " " << sizeof ( short )<< " " << sizeof ( int )<< " " << sizeof ( float )<< " " << sizeof ( double )<<endl;
     S s;
     S1 s1;
     S2 s2;
     S3 s3;
     S4 s4;
     S5 s5;
     cout<< sizeof (S3)<<endl;
     cout<< sizeof (s)<< " " << sizeof (s1)<< " " << sizeof (s2)<< " " << sizeof (s3)<< " " << sizeof (s4)<< " " << sizeof (s5)<<endl;
     return  0;
}
原文2网址： 点击打开链接

1 -- 结构体数据成员对齐的意义
许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的起始地址的值是某个数k的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。 
比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。
2 -- 结构体对齐包括两个方面的含义
1)结构体总长度； 
2)结构体内各数据成员的内存对齐，即该数据成员相对结构体的起始位置；
3 -- 结构体大小的计算方法和步骤
1)将结构体内所有数据成员的长度值相加，记为sum_a； 
2)将各数据成员为了内存对齐，按各自对齐模数而填充的字节数累加到和sum_a上，记为sum_b。对齐模数是#pragma pack指定的数值以及该数据成员自身长度中数值较小者。该数据相对起始位置应该是对齐模式的整数倍; 
3)将和sum_b向结构体模数对齐，该模数是【 #pragma pack指定的数值 】、【 未指定#pragma pack时，系统默认的对齐模数（32位系统为4字节，64位为8字节） 】和【 结构体内部最大的基本数据类型成员 】长度中数值较小者。结构体的长度应该是该模数的整数倍。
4 -- 结构体大小计算举例
在计算之前，我们首先需要明确的是各个数据成员的对齐模数，对齐模数和数据成员本身的长度以及pragma pack编译参数有关，其值是二者中最小数。如果程序没有明确指出，就需要知道编译器默认的对齐模数值。下表是Windows XP/DEV-C++和Linux/GCC中基本数据类型的长度和默认对齐模数。 
    char short int long float double long long long double
Win-32 长度 1 2 4 4 4 8 8 8
模数 1 2 4 4 4 8 8 8
Linux-32 长度 1 2 4 4 4 8 8 12
模数 1 2 4 4 4 4 4 4
Linux-64 长度 1 2 4 8 4 8 8 16
模数 1 2 4 8 4 8 8 16

例子1：

struct my_struct 
{ 
    char a; 
    long double b; 
};

此例子Windows和Linux计算方法有些许不一致。 
在Windows中计算步骤如下： 
步骤1：所有数据成员自身长度和：1B + 8B = 9B --> sum_a = 9B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_a + 7 = 16B --> sum_b = 16 B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。 
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1-1所示。 

在Linux中计算步骤如下： 
步骤1：所有数据成员自身长度和：1B + 12B = 13B --> sum_a = 13B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_a + 3 = 16B --> sum_b = 16 B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为12后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。 
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1-2所示。 

1-1 

例子2：

#pragma pack(2) 
struct my_struct 
{ 
    char a; 
    long double b; 
}; 
#pragma pack()

例子1和例子2不同之处在于例子2中使用了#pragma pack(2)编译参数，它强制指定对齐模数是2。此例子Windows和Linux计算方法有些许不一致。 

在Windows中计算步骤如下： 
步骤1：所有数据成员自身长度和：1B + 8B = 13B --> sum_a = 9B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_a + 1 = 10B --> sum_b = 10 B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为2，所以结构体对齐模数是2。sum_b是2的5倍，不需再次对齐。 
综上3步，可知结构体的长度是10B，各数据成员在内存中的分布如图2-1所示。 

在Linux中计算步骤如下： 
步骤1：所有数据成员自身长度和：1B + 12B = 13B --> sum_a = 13B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_a + 1 = 14B --> sum_b = 14 B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为2，所以结构体对齐模数是2。sum_b是2的7倍，不需再次对齐。 
综上3步，可知结构体的长度是14B，各数据成员在内存中的分布如图2-2所示。 

2 

例子3：

struct my_struct 
{ 
    char a; 
    double b; 
    char c; 
};

前两例中，数据成员在Linux和Windows下都相同，例3中double的对齐模数在Linux中是4，在Windows下是8，针对这种模数不相同的情况加以分析。 
在Windows中计算步骤如下： 
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B --> sum_a = 10B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_a + 7 = 17B --> sum_b = 17B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b应该是8的整数倍，所以要在结构体后填充8*3 - 17 = 7个字节。 
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图3-1所示。 

在Linux中计算步骤如下： 
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B，sum_a = 10B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 13B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma 
pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b应该是4的整数倍，所以要在结构体后填充4*4 - 13 = 3个字节。 
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图3-2所示。 

3 

例子4：

struct my_struct 
{ 
    char a[11]; 
    int b; 
    char c; 
};

此例子Windows和Linux计算方法一样，如下： 
步骤1：所有数据成员自身长度和：11B + 4B + 1B = 16B --> sum_a = 16B 
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_a + 1 = 17B --> sum_b = 17B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充4*5 - 17 = 1个字节。 
综上3步，可知结构体的长度是20B，各数据成员在内存中的分布如图4所示。 

4 

例子5：

struct my_test 
{ 
    int my_test_a; 
    char my_test_b; 
}; 
struct my_struct 
{ 
    struct my_test a; 
    double my_struct_a; 
    int my_struct_b; 
    char my_struct_c; 
};

例子5和前几个例子均不同，在此例子中我们要计算struct my_struct的大小，而my_struct中嵌套了一个my_test结构体。这种结构体应该如何计算呢？原则是将my_test在my_struct中先展开，然后再计算，即是展开成如下结构体：

struct my_struct
{
    int my_test_a;
    char my_test_b;
    double my_struct_a;
    int my_struct_b;
    char my_struct_c;
};

此例子Windows中的计算方法如下： 
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B --> sum_a = 18B 
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充3个字节：sum_a + 3 = 21B --> sum_b = 21B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b是8的整数倍，需在结构体后填充3*8 - 21 = 3个字节。 
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图5所示。 

此例子Linux中的计算方法如下： 
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B 
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 21B 
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma 
pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充6*4 - 21 = 3个字节。 
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图5所示。 

5

5 -- 源代码附录

上面的例子均在Windows(VC++6.0)和Linux(GCC4.1.0)上测试验证。下面是测试程序。

#include <iostream>

#include <stdio.h>

using namespace std;

int main()
{
    cout << "sizeof(char)        = " << sizeof(char) << endl;
    cout << "sizeof(short)       = " << sizeof(short) << endl;
    cout << "sizeof(int)         = " << sizeof(int) << endl;
    cout << "sizeof(long)        = " << sizeof(long) << endl;
    cout << "sizeof(float)       = " << sizeof(float) << endl;
    cout << "sizeof(double)      = " << sizeof(double) << endl;
    cout << "sizeof(long long)   = " << sizeof(long long) << endl;
    cout << "sizeof(long double) = " << sizeof(long double) << endl << endl;    

    // 例子1
    {
        struct my_struct 
        { 
            char a; 
            long double b; 
        };
        cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << endl;
  
        struct my_struct data;
 
        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子2
    {
        #pragma pack(2) 
        struct my_struct 
        { 
            char a; 
            long double b; 
        }; 
        
        #pragma pack()
        struct my_struct data;
 
        cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << endl;
  
        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }
    
    // 例子3
    {
        struct my_struct 
        { 
            char a; 
            double b; 
            char c; 
        }; 
 
        struct my_struct data;
 
        cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << endl;
  
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data.a, &data.b, &data.c);
    }

    // 例子4
    {
        struct my_struct 
        {  
            char a[11];  
            int b;  
            char c;  
        };
  
        cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;
  
        struct my_struct data;
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data, &data.b, &data.c);
    }

    // 例子5 
    {
        struct my_test 
        { 
            int my_test_a; 
            char my_test_b; 
        }; 
        
        struct my_struct 
        { 
            struct my_test a; 
            double my_struct_a; 
            int my_struct_b; 
            char my_struct_c; 
        }; 
        cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;
  
        struct my_struct data;
        printf("my_struct->my_test_a  : %u\n"
            "my_struct->my_test_b  : %u\n"
            "my_struct->my_struct_a: %u\n"
            "my_struct->my_struct_b: %u\n"
            "my_struct->my_struct_c: %u\n", &data.a.my_test_a, &data.a.my_test_b, 
            &data.my_struct_a, &data.my_struct_b, &data.my_struct_c);
    }

    return 0;
}
执行结果：  
//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 28 19:20:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 8
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 16

exapmle-1: sizeof(my_struct) = 32
my_struct->a: 2163695552
my_struct->b: 2163695568

exapmle-2: sizeof(my_struct) = 18
my_struct->a: 2163695680
my_struct->b: 2163695682

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2163695648
my_struct->b: 2163695656
my_struct->c: 2163695664

example-4: sizeof(my_struct) = 20
my_struct->a: 2163695616
my_struct->b: 2163695628
my_struct->c: 2163695632

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2163695584
my_struct->my_test_b  : 2163695588
my_struct->my_struct_a: 2163695592
my_struct->my_struct_b: 2163695600
my_struct->my_struct_c: 2163695604

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) i686 i686 i386 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 3213889904
my_struct->b: 3213889908

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 3213889890
my_struct->b: 3213889892

exapmle-3: sizeof(my_struct) = 16
my_struct->a: 3213889872
my_struct->b: 3213889876
my_struct->c: 3213889884

example-4: sizeof(my_struct) = 20
my_struct->a: 3213889852
my_struct->b: 3213889864
my_struct->c: 3213889868

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 3213889828
my_struct->my_test_b  : 3213889832
my_struct->my_struct_a: 3213889836
my_struct->my_struct_b: 3213889844
my_struct->my_struct_c: 3213889848

//CYGWIN_NT-6.1 motadou-PC 1.7.20(0.266/5/3) 2013-06-07 11:11 i686 Cygwin
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 2272336
my_struct->b: 2272340

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 2272322
my_struct->b: 2272324

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2272296
my_struct->b: 2272304
my_struct->c: 2272312

example-4: sizeof(my_struct) = 20
my_struct->a: 2272276
my_struct->b: 2272288
my_struct->c: 2272292

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2272248
my_struct->my_test_b  : 2272252
my_struct->my_struct_a: 2272256
my_struct->my_struct_b: 2272264
my_struct->my_struct_c: 2272268

Alex123980
关注
【编程】C#中的结构体字节对齐
qq_41061045的博客
07-23 1303
C#结构体字节对齐的一些注意事项
结构体内存对齐
m0_55752775的博客
09-18 988
结构体内存对齐
字节对齐（强制对齐以及自然对齐）
Helloguoke的专栏
11-22 2244
struct {}node; 32为的x86，window下VC下sizeof(node)的值为1，而linux的gcc下值为0； 一、WINDOWS下（VC--其实GCC和其原理基本一样，象这种问题，一般要查具体的编译器设置）字节对齐的规则： 1、 一般设置的对齐方式为1，2，4字节对齐方式，VC一般默认为4字节(最大为8字节)。结构的首地址必须是结构内最宽类型的整数倍地址；另外，结构体的
C/C++结构体对齐全解析
最新发布
欢迎来到《技术探索》，这是一个专注于游戏开发技术的博客。在这里，我们将深入探讨游戏引擎、图形渲染、人工智能、物理模拟等领域的最新技术和最佳实践。无论您是初学者还是经验丰富的开发者，我们都希望为您提供有价值的见解和实用的技巧。
06-25 871
摘要： 在C语言中，结构体默认会按平台规则对齐以提高访问效率，但有时需取消对齐（如对接硬件或协议）。两种常用方法是： #pragma pack(n)：设定n字节对齐（如1字节），影响后续所有结构体，支持跨平台但需谨慎使用； attribute((packed))（GCC/Clang专用）：仅修饰单个结构体，无填充字节，推荐特定编译器使用。 区别在于作用范围和兼容性。取消对齐可能降低性能甚至导致崩溃，建议仅在需要精确内存布局时使用，两者也可结合以兼容不同编译器。
C++结构体对齐补齐实例学习
Struggling_Jeff的博客
12-09 902
1、结构体的好处。 需要使用结构这种聚合数据类型来处理基本数据类型难以处理的场景。 2、为什么要内存对齐？ 2.1 平台原因：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 2.2 性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。因为为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问...
C/C++编程：结构体默认对齐方式
OceanStar的博客
12-21 4601
什么是内存对齐 还是用一个例子带出这个问题，看下面的小程序，理论上，32位系统下，int占4byte，char占一个byte，那么将它们放到一个结构体中应该占4+1=5byte；但是实际上，通过运行程序得到的结果是8 byte，这就是内存对齐所导致的。 #include<stdio.h> struct{ int x; char y; }s; int main() { printf("%d\n",sizeof(int)); // 4 printf("%d\n",
C/C++结构体字节对齐详解
12-22
　我们先看看sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节数，好吧，那让我们来看看S1的内存分配情况 　S1 s1 = { 'a'， 0xFFFFFFFF }; 　定义上面的变量后，加上断点，运行程序，观察s1所在的...
C - 结构体字节对齐问题
07-17
关于C语言中的结构体字节对齐问题，在《C与指针》一书中提到，但是似乎没有说清楚，还是我理解不完全？所以，根据书上和网上资料，总结一些关于C语言中的结构体字节对齐的知识。这里的讨论和代码，都在VS2010下，GCC...
结构体字节对齐规则
01-29
结构体字节对齐规则，主要是介绍结构体字节对齐规则，内容有点长，但是很全面.
【C/C++】结构体对齐详解
Michael
04-20 2421
如果结构体成员没有按照对齐要求排列，可能会导致结构体变量的大小增加，从而增加传输或存储的开销。结构体内存对齐是由编译器自动完成的，编译器会按照一定的规则将结构体成员按照一定的字节对齐方式排列在内存中。结构体成员的对齐方式通常按照其大小来确定，例如char类型通常按照1字节对齐，int类型通常按照4字节对齐，double类型通常按照8字节对齐等。结构体内存对齐是指编译器在分配结构体变量内存时，为了提高访问效率和内存对齐要求，按照一定规则将结构体成员按照一定的字节对齐方式排列在内存中的过程。
C/C++内存对齐规则（结构体、联合体、类）
2302_76941579的博客
11-10 2816
本篇博客介绍了内存对齐的规则，包括结构体嵌套结构体、结构体嵌套数组的例题；介绍了如何求union联合体的内存大小；还介绍了如何计算C++的类的内存大小
C++结构体对齐简要说明
半雨微凉
02-27 524
意义： 节约空间，提高存取效率 知识点： 1、结构体的起始存储位置必须是能够被该结构体中最大的数据类型所整除 2、每个数据成员存储的起始位置是自身大小的整数倍 3、对齐后的长度必须是成员中最大的对齐参数的整数倍 4、复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式 示例代码： struct A { int a; char b; short c; }...
Windows下struct和union字节对齐设置以及大小的确定（一 简介和结构体大小的确定）
liwugang43210的专栏
04-30 3067
在windows下设置字节对齐大小的方式，目前我了解有三种： 1.
关于VC下结构体内存对齐问题
菜菜菜菜鸟の成长记
04-10 953
#include //pragma pack(8) int main() { struct key{ int a; char b; long double c; char d; }kk; struct key1{ int a; char b; int c; }kk1; struct key2{ char a; char b; char
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值