C/C++中的数据结构对齐，#pragma pack() 和 __attribute__

news2024/11/14 3:42:39

C/C++中的数据结构对齐

总览

数据结构对齐是指在计算机内存中排列和访问数据的方式。它包含三个独立但相关的问题：数据对齐（data alignment），数据结构填充（ data structure padding）和打包（packing）。

当数据自然对齐时，现代计算机硬件中的CPU最有效地执行对内存的读写操作，这通常意味着数据的内存地址是数据大小的倍数。

  1. 读/写总是从word_size的倍数的地址开始的。
  2. 读/写的长度总是word_size的倍数。 例如，在32位体系结构中，如果数据存储在4个连续字节中并且第一个字节位于4字节边界上，则可以对齐数据。

数据对齐是根据元素的自然对齐来进行的。为了确保自然对齐，可能需要在结构元素之间或结构的最后一个元素之后插入一些填充。例如，在32位机器上，一个包含16位值和32位值的数据结构可以在16位值和32位值之间有16位的填充，以使32位值在32位边界对齐。或者，我们可以将结构打包（packing），省略填充，这可能会导致较慢的访问速度，但只使用了四分之三的内存。

尽管数据结构对齐是所有现代计算机的一个基本问题，但许多计算机语言和计算机语言实现都会自动处理数据对齐。Fortran、Ada、 PL/I、Pascal、某些C和C++实现、D、Rust、C#和汇编语言，允许至少在部分范围内控制数据结构填充，这在某些特殊情况下可能是有用的。

数据对齐（alignment）

当一个内存地址a是n的倍数（其中 n = 2 k n=2^k n=2k）时，可以说是n字节对齐的。在这种情况下，一个字节是最小的内存访问单位，即每个内存地址指定一个不同的字节。一个n字节对齐地址，再用二进制表示时将至少有 l o g 2 ( n ) log_2(n) log2​(n)个最低有效零。

而b位对齐，实际上就是另一种说法，指 b / 8 b/8 b/8字节对齐的地址（例如，64位对齐的是8字节对齐的）。

当被访问的数据长度为n个字节，并且基准地址是n个字节对齐的时候，就可以说一个内存访问是对齐的。当一个内存访问没有被对齐时，它被称为错位（misaligned）。请注意，根据定义，字节内存访问总是被对齐的。

如果一个内存指针指的是n字节长的原始数据，并且只允许它包含n字节对齐的地址，那么这个指针就被称为对齐的。否则，它就被称作不对齐的（unaligned）。当（且仅当）集合中的每个原始数据是对齐的，指向数据集合（数据结构或数组）的内存指针才是对齐的。

请注意，上面的定义假定每个原始数据的长度是 2 k 2^k 2k。如果不是这种情况（如x86的80位浮点），上下文会影响数据是否被认为是对齐的条件。

数据结构可以存储在堆栈中，在栈中的静态尺寸被称为 有界（bounded），在堆中的动态尺寸被称为 无界（unbounded）。

典型对齐方式

结构的典型对齐方式：

  • 数组 ：按照基本数据类型对齐，第一个对齐了后面的自然也就对齐了。

  • 联合 ：按其包含的长度最大的数据类型对齐。

  • 结构体： 结构体中每个数据类型都要对齐。

结构字节对齐的原则主要有：

  1. 数据类型自身的对齐值：char型数据自身对齐值为1字节，short型数据为2字节，int/float型为4字节，double型为8字节 …（操作系统不同可能由偏差），在最后会有介绍。

  2. 结构体或类的自身对齐值：其成员中自身对齐值最大的那个值。（结构体的每一个成员相对结构体首地址的偏移量，应该其参数类型占字节数的整数倍，如果不满足则补足前面的字节使其满足），例如：

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

    补位结构为==（4 — 1 + 1（补） — 2）==，因为最后一个short占 2 2 2字节，但其前一个char占 1 1 1位，不补位其地址较结构体首地址偏移 5 ≠ 2 ∗ N 5 \ne 2*{\rm{N}} 5=2∗N，所以前面char补 1 1 1位，首地址偏移 6 = 2 ∗ N 6=2*N 6=2∗N ，总大小为 8 8 8字节，具体地址如下：

    image-20230426121248566

    这其实就是数据结构填充的补齐方式，详细例子在后面的填充中会说明。

  3. 指定对齐值：#pragma pack (value)时的指定对齐值value。

  4. 数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中较小者，即有效对齐值=min{自身对齐值，当前指定的pack值}。

不对齐存在的问题

CPU一次访问内存一个内存字。只要内存字大小至少与计算机支持的最大基本数据类型一样大，对齐访问将始终访问一个内存字。然而，对于未对齐的数据访问可能就不是这样了。

如果一个数据的高位和低位字节不在同一个内存字中，计算机必须将该数据的访问分成多个内存访问。 这需要复杂的电路来生成内存访问并协调它们。为了处理内存字位于不同的内存页的情况，处理器必须在执行指令之前验证两个内存页是否都存在，或者在任何内存访问过程中能够处理TLB缺失或页面故障。

内存地址不对齐，会引起什么样的问题呢？用一个例子来说明：

地址未对齐的情况

假定在一台32位机器上，有一个整型变量i的地址是34 ，那i存储在内存的34、35、36、37地址；

为了把这个变量从内存读进CPU，由于计算机从内存读取数据的天性（第一点，读/写总是从word_size的倍数的地址开始的），需要两次读取（第一次从32开始读32 33 34 35，第二次从36开始读36 37 38 39），然后把第一次读取的后两个字节（34 35）抽取出来，把第二次读取的前面两个字节（36 37）抽取出来拼到一起组成变量i：

一个int变量为4bytes，即32位，从CPU一次可以读取的内存块长度来看，本可以一次读完；但是因为这个变量的内存块地址没有对齐，将导致本来一个read指令就能完成的读取操作，需要两次read外加其它复杂的抽取拼接计算，从而大大地降低了性能。

一些处理器设计有意避免引入这种复杂性，在不对齐的内存访问时会产生替代行为。 例如，在ARMv6 ISA之前的一些ARM架构实现需要所有多字节的加载和存储指令强制对齐内存访问。根据执行哪个具体的指令，尝试未对齐访问的结果可能是将违规地址的最低有效位舍入为对齐访问（有时附加其他警告），或者抛出MMU异常（如果有MMU硬件），或者无声地产生其他潜在不可预测的结果。ARMv6和更新的架构在许多情况下支持不对齐访问，但并非全部情况。

当单个内存字被访问时，操作是原子性的，即整个内存字被一次性读或写，其他设备必须等到读或写操作完成后才能访问它。这对于对多个内存字的非对齐访问来说可能不是正确的，例如，第一个字由一个设备读取，然后另一设备写入两个字，然后再由第一设备读取第二个字。这种情况读取的值既不是原始值也不是更新的值。虽然这种故障很少，但却很难识别。

解决对齐：数据结构填充（padding）

尽管编译器（或解释器）通常将单个数据项分配到对齐的边界上，但数据结构通常具有不同对齐要求的成员。为了保持适当的对齐，翻译器通常插入额外的未命名数据成员，以便每个成员都得到适当的对齐。此外，整个数据结构可能会用最后一个未命名成员填充。这使得结构数组的每个成员都可以得到适当的对齐。

仅当结构成员后面紧跟具有较大对齐要求的成员或位于结构末尾时，才插入填充。通过改变结构中成员的顺序，可以改变维护对齐所需的填充量。例如，如果成员按降序排列要求进行排序，则需要最少的填充。所需的最少填充量始终小于结构中最大的对齐要求。计算所需最大填充量更为复杂，但始终小于所有成员对齐要求之和减去最不对齐的一半结构成员对齐要求之和的两倍。

尽管 C 和 C++ 不允许编译器重新排序结构成员以节省空间，但其他语言可能允许。大多数 C 和 C++ 编译器也可以指定将结构体成员“打包”到特定的对齐级别，例如 “pack(2)”表示将大于一个字节的数据成员对齐到两个字节边界，使得任何填充成员最多为一个字节长。同样，在 PL/I 中，可以声明结构体为 UNALIGNED 以除去除位串外的所有填充。

这种 "打包 " 结构的 一个用途是节约内存。例如，一个包含一个字节（如char）和一个四字节整数（如uint32_t）的结构将需要三个额外的字节填充。一个由此类结构组成的大数组如果被打包，将减少37.5%的内存，尽管访问每个结构可能需要更长时间。这种妥协可以被认为是一种空间-时间权衡的形式。

尽管使用 "打包 "结构最常被用来节省内存空间，但它也可以被用来 格式化数据结构，以便使用标准协议进行传输。然而，在这种用法中，还必须注意确保结构成员的值是以协议要求的字节数（通常是网络字节数）来存储的，这可能与主机本身使用的字节数不同。

计算填充

下面的公式提供了对准数据结构的开始所需的填充字节数（其中mod是模除运算符）：
 padding  = (  align  − (  offset   m o d   align  ) )   m o d   a l i g n  aligned  =  offset  +  padding  =  offset  + ( (  align  − (  offset   m o d   align  ) )   m o d   a l i g n ) \begin{aligned} \text { padding } & =(\text { align }-(\text { offset } \ mod \ \text{ align })) \ mod \text \ { align } \\ \text { aligned } & =\text { offset }+ \text { padding } \\ & =\text { offset }+((\text { align }-(\text { offset } \ mod \ \text{ align })) \ mod \text \ { align }) \end{aligned}  padding  aligned ​=( align −( offset  mod  align )) mod align= offset + padding = offset +(( align −( offset  mod  align )) mod align)​
例如，对于一个地址偏移是0x59d的4字节对齐结构体，该结构体将从0x5a0开始存储并添加3字节的填充，因为0x5a0是4的倍数。计算过程如下：
 padding  = ( 4 − ( 0x59d  m o d   4 ) )   m o d   4 = ( 4 − 1 )   m o d   4 = 3  aligned  = 0x59d + 3 = 0x5a0 \begin{aligned} \text { padding } &= (4 - (\text{0x59d} \ mod \ 4)) \ mod \ 4 = (4 - 1) \ mod \ 4 = 3 \\ \text { aligned } &= \text{0x59d} + 3 = \text{0x5a0} \end{aligned}  padding  aligned ​=(4−(0x59d mod 4)) mod 4=(4−1) mod 4=3=0x59d+3=0x5a0​
反之，当地址偏移量offset已经和对齐字节数align相等时，第二个*(align - (offset mod align)) mod align*中的模除将返回0，因此原始值将保持不变。

因为对齐操作根据定义是按照2的幂次方，所以模除运算可以简化为布尔和位运算。

下面的公式可以产生正确的值（其中&是位与，~是位非）—— 但前提是地址偏移量是无符号的，或者系统使用二进制补码运算：

 padding  = (  align  − (  offset &  (  align  − 1 ) ) ) & ( align ⁡ − 1 ) = −  offset &  (  align  − 1 )  aligned  = (  offset  + (  align  − 1 ) ) & ∼ (  align  − 1 ) = (  offset  + (  align  − 1 ) ) & − a l i g n \begin{aligned} \text { padding } & =(\text { align }-(\text { offset \& }(\text { align }-1))) \&(\operatorname{align}-1) \\ & =- \text { offset \& }(\text { align }-1) \\ \text { aligned } & =(\text { offset }+(\text { align }-1)) \& \sim(\text { align }-1) \\ & =(\text { offset }+(\text { align }-1)) \&-a l i g n \end{aligned}  padding  aligned ​=( align −( offset & ( align −1)))&(align−1)=− offset & ( align −1)=( offset +( align −1))&∼( align −1)=( offset +( align −1))&−align​

数据对齐的编译器处理

编译器尝试以防止数据未对齐的方式分配数据。对于简单的数据类型，编译器将分配是数据类型的大小（以字节为单位）的倍数的地址。 例如，编译器将地址分配给类型为 long 且是 4 的倍数的变量，并将地址的最底部 2 位设置为零。

编译器还以自然对齐结构的每一个元素的方式填充结构。 来看看下面代码示例中的结构 struct x_：

struct x_
{
   char a;     // 1 byte
   int b;      // 4 bytes
   short c;    // 2 bytes
   char d;     // 1 byte
} bar[3];

编译器填充此结构以自动强制实施对齐方式。

下面的代码示例展示了编译器如何将填充的结构置于内存中：

// Shows the actual memory layout
struct x_
{
   char a;            // 1 byte
   char _pad0[3];     // padding to put 'b' on 4-byte boundary
   int b;            // 4 bytes
   short c;          // 2 bytes
   char d;           // 1 byte
   char _pad1[1];    // padding to make sizeof(x_) multiple of 4
} bar[3];

两个声明都将 sizeof(struct x_) 作为 12 个字节返回。

第二个声明包括两个填充元素：

  1. char _pad0[3]，对齐 4 字节边界上的 int b 成员，为了int b地址偏移为 4 ∗ ( s i z e o f ( i n t ) ) 4*(sizeof(int)) 4∗(sizeof(int))，补3字节。
  2. char _pad1[1]，对齐 4 字节边界上结构 struct _x bar[3] 的数组元素，为了数组中下一个struct _x bar地址偏移为 4 ∗ N 4*N 4∗N，补1字节。

填充以允许自然访问的方式对齐 bar[3] 的元素。

下面的代码示例展示了 bar[3] 的数组布局：

adr offset   	element
------   		-------
0x0000   		char a;         // bar[0]
0x0001   		char pad0[3];
0x0004   		int b;
0x0008   		short c;
0x000a   		char d;
0x000b   		char _pad1[1];

0x000c   		char a;         // bar[1]
0x000d   		char _pad0[3];
0x0010   		int b;
0x0014   		short c;
0x0016   		char d;
0x0017   		char _pad1[1];

0x0018   		char a;         // bar[2]
0x0019   		char _pad0[3];
0x001c   		int b;
0x0020   		short c;
0x0022   		char d;
0x0023   		char _pad1[1];

结构体填充举例

如果有如下八个结构体：

typedef struct node1 {
} S1;
typedef struct node2 {
    int a;
    char b;
    short c;
} S2;
typedef struct node3 {
    char a;
    int b;
    short c;
} S3;
typedef struct node4 {
    int a;
    short b;
    long c; 
} S4;
typedef struct node5 {
    char a;
    S1 b;
    short c;
} S5;
typedef struct node6 {
    char a;
    S2 b;
    int c;
} S6;
typedef struct node7 {
    char a;
    S2 b;
    double d;
    int c;
} S7;
typedef struct node8 {
    char a;
    S2 b;
    char* c;
} S8;

int main() {
    S1 xx;
    printf("start:\t 0x%p \n", &xx);
    printf("end:\t 0x%p \n", &xx+1);
    return 0;
}

按照之前的公式，在未指定对齐的情况下，各个结构体占用的内存如下：

node1：

node1为一个空结构体，在C中空结构体的大小为0字节，在C++中空结构体的大小为1字节。

typedef struct node1 {	// C:0, C++:1
} S1;

image-20230426121141645

node2：

node2的内存结构：（4 — 1 + 1（补） — 2），总大小为8字节（结构体的每一个成员相对结构体首地址的偏移量应该是对其参数的整数倍）。

typedef struct node2 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    int a;		// 4	4			%		1		=0 => 补0 			4
    char b;		// 1	(1+4)		%		2		=1 => 补2-1=1		1 + 1（补）	
    short c;	// 2	(2+2+4)		%		4		=0 => 补0			2
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S2;

image-20230426121248566

node3：

node3的内存结构：（1 +3（补） — 4 — 2 +2（补）），总大小为12字节（结构体的每一个成员相对结构体首地址的偏移量应该是对其参数的整数倍）。

typedef struct node3 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    char a;		// 1	1			%		4		=1 => 补4-1=3 		1 +3（补）
    int b;		// 4	(4+4)		%		2		=0 => 补0 			4
    short c;	// 2	(2+4+4)		%		4		=2 => 补4-2=2 		2 +2（补）
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S3;

image-20230426121822281

node4：

node4的内存结构：（4 — 2 + 2（补）—4），总大小为12字节。

typedef struct node4 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    int a;		// 4	4			%		2		=0 => 补0 			4
    short b;	// 2	(2+4)		%		4		=2 => 补4-2=2 		2 + 2（补）
    long c; 	// 4	(4+4+4)		%		4		=0 => 补0 			4
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S4;

image-20230426121712484

node5：

node5的内存结构：（1 — 1 — 2），总大小为4字节。

typedef struct node5 {
    			// 系数	当前地址偏移		下一系数	padding			最终空间
    char a;		// 1	1			%		0		->0 => 补0 			1
    S1 b;		// 0	(0+1)		%		2		=1 => 补1 			1
    short c;	// 2	(2+1+1)		%		4		=0 => 补0 			2
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S5;

image-20230426121937421

node6：

node6的内存结构：（1 + 3（补） — 8 — 4），总大小为16字节，注意结构体变量的对齐参数的计算。

这里char补3的原因是： S2结构体内基本数据类型占空间最大的是4字节int类型 ，所以要补足4个字节。

typedef struct node6 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    char a;		// 1	1			%		4		=1 => 补4-1=3 		1 + 3（补）
    S2 b;		// 4	(8+4)		%		4		=0 => 补0 			8
    int c;		// 4	(4+8+4)		%		4		=0 => 补0 			4
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S6;

image-20230426122016567

node7：

node7的内存结构：（1 + 3（补）— 8 + 4（补） — 8 — 4 + 4（补）），总大小为32字节。

typedef struct node7 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    char a;		// 1	1			%		4		= 1 => 补4-1=3 		1 + 3（补）
    S2 b;		// 4	(8+4)		%		8		= 4 => 补8-4=4		8 + 4（补）
    double d;	// 8	(8+12+4)	%		4		= 0 => 补0 			8
    int c;		// 4	(4+8+12+4)	%		8		= 4 => 补8-4=4 		4 + 4（补）
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S7;

image-20230426122304199

node8：

node8的内存结构：（1 + 3（补） — 8 + 4（补）— 8），所有数据类型指针在64位系统都占8字节，总大小为24字节。

typedef struct node8 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    char a;		// 1	1			%		4		= 1 => 补4-1=3 		1 + 3（补）
    S2 b;		// 4	(8+4)		%		8		= 4 => 补8-4=4 		8 + 4（补）
    char* c;	// 8	(8+12+4)	%		8		= 0 => 补0 			8
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S8;

image-20230426122052089

C语言结构体在x86上的典型对齐方式

数据结构成员在内存中是按顺序存储的，因此，在下面的结构中，成员Data1总是在Data2之前；而Data2总是在Data3之前：

struct MyData
{
    short Data1;
    short Data2;
    short Data3;
};

如果 "short "类型存储在2字节的内存中，那么上面描述的数据结构的每个成员都将是2字节对齐的。数据1在偏移0，数据2在偏移2，数据3在偏移4。这个结构体的大小将是6个字节。

结构中每个成员的类型通常有一个默认的对齐方式，也就是说，除非程序员另有要求，否则它将在一个预先确定的边界上对齐。以下典型的对齐方式对微软（Visual C++）、Borland/CodeGear（C++Builder）、Digital Mars（DMC）和GNU（GCC）的编译器在为32位x86编译时有效：

数据类型对齐字节数
char（1字节）1字节对齐
short（2字节）2字节对齐
int（4字节）4字节对齐
long（4字节）4字节对齐
float（4字节）4字节对齐
double（8字节）Windows上是8字节对齐的，在Linux上是4字节对齐的（用-malign-double编译时选项是8字节）
long long（8字节）4字节对齐
long double（（C++Builder和DMC为10个字节，Visual C++为8个字节，GCC为12个字节））C++Builder上将是8字节对齐，DMC为2字节对齐，Visual C++为8字节对齐，GCC为4字节对齐。
指针（4字节）
(例如：char*, int*)		4字节对齐
long（8字节）8字节对齐
double（8字节）8字节对齐
long long（8字节）8字节对齐
long double（在Visual C++中是8个字节，在GCC中是16个字节）在Visual C++中是8字节对齐的，在GCC中是16字节对齐的。
指针（8字节）8字节对齐

有些数据类型则取决于实现方式。

强制指定对齐大小

在缺省情况下，C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地，可以通过下面的方法来改变缺省的对界条件：

使用伪指令#pragma pack (n)，C编译器将**按照n个字节对齐**。

使用伪指令#pragma pack ()，取消自定义字节对齐方式。

gcc里还可以使用__attribute__关键字来声明数据类型的对齐方式，优先级高于#pragma预编译指令。

__attribute((aligned (n)))，让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n，则按照最大成员的长度来对齐。

attribute ((packed))，取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐。

__attribute__方式

struct stu{
　　 char sex;
　　 int length;
　　 char name[10];
}__attribute__ ((aligned (1))); 
struct stu my_stu;

此时，sizeof(my_stu)可以得到大小为15。上面的定义等同于：

struct stu{
    char sex;
    int length;
    char name[10];
}__attribute__ ((packed)); 
struct stu my_stu;

  • 当aligned作用于**变量时，其作用是告诉编译器为变量分配内存的时候，要分配在指定对其的内存上，作用于变量之上不会改变变量的大小**。

    例如：int a attribute((aligned(16)))，该变量a的内存起始地址为16的倍数。

  • 当aligned作用于**类型时，其作用是告诉编译器该类型声明的所有变量都要分配在指定对齐的内存上。当该属性作用于结构体声明时可能会改变结构体的大小**。

测试的时候发现 __attribute__ ((aligned (1)))用法不适用于minGW ，使用第二种，效果如下：

struct node6 {
    char a;
    S2 b;
    int c;
}__attribute__ ((packed)) ;
typedef struct node6 S6;

可以发现与之前的声明相比，内存分配发生了变化，变量分配在了1对齐的内存上：

image-20230426185643455

pragma方式

声明#pragma可以设置对齐参数的数值，缺省是8字节：

#pragma pack(n) 				//作用：C编译器将按照n个字节对齐。
#pragma pack()               	//作用：取消自定义字节对齐方式。
#pragma pack(push,1)     		//作用：是指把原来对齐方式设置压栈，并设新的对齐方式设置为一个字节对齐
#pragma pack(pop)            	//作用：恢复对齐状态
#pragma pack(push)				//保存对齐状态
#pragma pack(4)					//设定为4字节对齐 相当于 #pragma  pack (push,4)

例如之前的node6，使用强制指定对齐的pack方式，实际上就是指定系数均为2：

# pragma pack(2)
typedef struct node6 {
    			// 系数	当前地址偏移		下一系数	padding				最终空间
    char a;		// 2	1			%		2		=1 => 补2-1=1 		1 + 1（补）
    S2 b;		// 2	(8+2)		%		2		=0 => 补0 			8
    int c;		// 2	(4+8+2)		%		2		=0 => 补0 			4
    			// 最后一个元素的下一系数参考本结构体最大元素的系数
} S6;
#pragma pack()

可以看到运行结果符合对齐要求，占用空间从之前的16字节缩小到了14字节：

image-20230426184840790

aligned和pack的主要区别

  1. pack作用于结构体或类的定义，而**aligned既可以作用于结构体或类的定义，也可以作用于变量的声明**。
  2. pack的作用是改变结构体或类中成员变量的布局规则，而aligned只是建议编译器对指定变量或指定类型的变量分配内存时的规则。
  3. pack可以压缩变量所占内存的空间
  4. align可以指定变量在内存的对其规则，而pack不可以。
  5. 若某一个结构体的默认pack为n，pack指定的对齐规则m大于n，则该pack忽略。若aligned指定的对齐规则s大于n,则此时结构体的大小一定为s的整数倍。
  6. aligned和pack指定规则时都必须为2的n次幂。

拓展：64 位数据模型

在 32 位程序中，指针和整数等数据类型通常具有相同的长度。但在 64 位机器上不一定如此。因此，在C及其后代（如C++和Objective-C）等编程语言中混合数据类型可能适用于 32 位实现，但不适用于 64 位实现。

在 64 位机器上的许多 C 和 C 派生语言的编程环境中，int变量仍然是 32 位宽，但long int和pointer是 64 位宽。这些被描述为具有LP64 数据模型，它是==“Long, Pointer, 64”== 的缩写。其他模型有 ILP64数据模型，其中所有三种数据类型都是64位宽，甚至还有SILP64模型，其中short也是64位宽。然而，在大多数情况下，所需的修改相对较小且直接，许多编写良好的程序可以简单地针对新环境重新编译而无需更改。另一种选择是LLP64模型，它通过将int和long保留为 32 位来保持与 32 位代码的兼容性。LL指的是long long integer类型，在所有平台上至少是64位，包括32位环境。

也有使用ILP32数据模型的 64 位处理器的系统，添加了 64 位 long long 整数；这也用于许多具有 32 位处理器的平台。该模型以更小的地址空间为代价减少了代码大小和包含指针的数据结构的大小，对于某些嵌入式系统来说是一个不错的选择。对于 x86 和 ARM 等指令集，其中 64 位版本的指令集比 32 位版本的指令集具有更多的寄存器，它提供了对额外寄存器的访问而没有空间损失。它在 64 位 RISC 机器中很常见，在 x86 中作为x32 ABI 进行了探索，并且最近被用于Apple Watch Series 4和 5。

Data modelshort (integer)intlong (integer)long longpointers, size_tSample operating systems
ILP321632326432x32 and arm64ilp32 ABIs on Linux systems; MIPS N32 ABI.
LLP641632326464Microsoft Windows (x86-64 and IA-64) using Visual C++; and MinGW
LP641632646464Most Unix and Unix-like systems, e.g., Solaris, Linux, BSD, macOS. Windows when using Cygwin; z/OS
ILP641664646464HAL Computer Systems port of Solaris to the SPARC64
SILP646464646464Classic UNICOS[46][47] (versus UNICOS/mp, etc.)

今天许多64位平台使用LP64模型（包括Solaris、AIX、HP-UX、Linux、macOS、BSD和IBM z/OS）。微软Windows使用LLP64模型。LP64模型的缺点是，将long存储到int中会被截断。另一方面，在LP64中，将一个指针转换为一个长字符串会 “有效”。在LLP64模型中，情况恰恰相反。这些问题并不影响完全符合标准的代码，但代码的编写往往隐含着对数据类型宽度的假设。C代码在将指针转换为整数对象时，应该选择(u)intptr_t而不是long。

参考文献

1：Data structure alignment - Wikipedia

2：数据结构对齐 - 维基百科，自由的百科全书

3：64-bit computing - Wikipedia

4：Data structure alignment （数据结构对齐 / 内存对齐）_Jeff_的博客-CSDN博客

5：对齐方式 | Microsoft Learn


如有疑问或错误，欢迎和我私信交流指正。
版权所有，未经授权，请勿转载！
Copyright © 2023 by Mr.Idleman. All rights reserved.

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/464766.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

根据 vue-grid-layout 动态设置Echarts尺寸大小

根据 vue-grid-layout 动态设置Echarts尺寸大小

文章目录 前言一、vue-grid-layout 是什么？二、正文1.引入vue-grid-layout2.myEcharts组件3. Utils中的debounce防抖函数 总结 前言 此文背景是根据 vue-grid-layout 动态拖拽组件大小里面包含 Echarts 组件情景，也可以单独把监听动态设置Echarts 尺寸抽…
阅读更多...
Java文件IO操作基础

Java文件IO操作基础

目录 前言 java.io.File 1. 构造方法 2. 方法 get类方法 文件的创建和删除 目录的创建与删除 输入输出流 InputStream FileInputStream 概述 代码实例1 代码实例2 字符集问题? Scanner 读取 OutputStream Java输入输出流的使用案例 创作不易, 多多支持😶‍&…
阅读更多...
C++的异常

C++的异常

文章目录 1. C语言传统的处理错误的方式2. C异常概念3. 异常的使用3.1 异常的抛出和匹配原则 4. C标准库的异常体系5. 自定义异常体系6. 异常的重新抛出7. 函数调用链中异常栈展开匹配原则8. 异常安全9. 异常规范10. 异常的优缺点 1. C语言传统的处理错误的方式 传统的错误处理…
阅读更多...
Windows下版本控制器（SVN）-TortoiseSVN使用+权限配置+合并深度介绍+分支介绍

Windows下版本控制器（SVN）-TortoiseSVN使用+权限配置+合并深度介绍+分支介绍

文章目录 基础知识-Windows下版本控制器(SVN)3.4 TortoiseSVN使用3.4.1 SVN检出(SVN Checkout)3.4.2 SVN更新(SVN Update)3.4.3 **SVN**提交(SVN Commit)3.4.4 **SVN**还原(SVN Revert)3.4.5 解决文件冲突3.4.6 授权访问3.4.7 显示日志(Show log)3.4.8 版本库浏览(Repo-browser…
阅读更多...
中国社会科学院大学与美国杜兰大学金融管理硕士项目——找寻属于你的那道光

中国社会科学院大学与美国杜兰大学金融管理硕士项目——找寻属于你的那道光

人生的路很长，再不舍过去，也要朝前走。总有一束光在闪耀，总有路在前方。让我们去找寻属于自己的光。这道光或明或暗，或远或近。给自己一个希望，它就是那一束光会撒在你身上，未来会一片灿烂。社科院与杜兰大…
阅读更多...
什么是3D渲染，3D渲染在CG项目中为何如此重要？

什么是3D渲染，3D渲染在CG项目中为何如此重要？

随着科技的发展，现如今任何人都可以使用免费软件在个人计算机上创作 3D 图像，当然也有人对于专业 3D 艺术的创作方式及其相关工作流程存在一些误解，认为创建一个模型后，在上面放上材料和纹理，就可以立马得到一个漂亮的…
阅读更多...
软件测试职业发展方向有哪些

软件测试职业发展方向有哪些

随着人工智能时代的到来，IT行业受到了越来越多人的重视。软件测试作为把控软件质量必不可少的环节，其重要性可见一斑。 据第三方平台统计，北京软件测试工程师的平均薪资为16.2K，除了一线城市外，随着互联网行业逐渐下沉…
阅读更多...
虹科新品 | 用于医疗应用的压力和气体流量传感器

虹科新品 | 用于医疗应用的压力和气体流量传感器

ES Systems在创新MEMS方面拥有丰富的经验，设计了高质量和高性能的气体流量和压力传感器，由于其技术规格，出色的可靠性和有竞争力的价格，这些传感器在竞争产品中具有独特的品质。 Part.01 应用背景 众所周知，在医疗领域…
阅读更多...
软件测试技术（五）软件测试流程

软件测试技术（五）软件测试流程

软件测试流程 软件测试流程如下： 测试计划测试设计测试执行 单元测试集成测试确认测试系统测试验收测试回归测试验证活动 测试计划 测试计划由测试负责人来编写，用于确定各个测试阶段的目标和策略。这个过程将输出测试计划，明确要完成的测…
阅读更多...
freeswitch的任务引擎问题与解决方案

freeswitch的任务引擎问题与解决方案

概述 freeswitch核心框架中有一个定时任务系统task，在开发过程中用来做一些延时操作和异步操作很方便。 我们在VOIP的呼叫流程中，经常会有一些对实时性要求没那么高的操作，或者会有阻塞流程的操作，我们都可以开启一个定时任务子…
阅读更多...
【 Spring 事务 】

【 Spring 事务 】

文章目录 一、为什么需要事务(简单回顾)二、MySQL 中的事务使⽤三、Spring 中事务的实现3.1 Spring 编程式事务(手动事务)3.2 Spring 声明式事务(自动事务)3.2.1 Transactional 作⽤范围3.2.2 Transactional 参数说明3.2.3 Transactional 不进行事务回滚的情况3.2.4 Transactio…
阅读更多...
Android 使用Retrofit+协程实现超简单大文件下载并回显进度条

Android 使用Retrofit+协程实现超简单大文件下载并回显进度条

安卓自带的进度条弹窗过时了&#xff0c;这里简单创建一个进度条弹窗 在drawable文件夹创建progress_dialog_bg_style.xml一个圆角白色背景样式 <?xml version"1.0" encoding"utf-8"?> <shape xmlns:android"http://schemas.android.com…
阅读更多...
IPTV系统架构的分析与研究

IPTV系统架构的分析与研究

1 引言 　　IPTV业务是伴随着宽带互联网的飞速发展而兴起的一项新兴的互联网增值业务,它利用宽带互联网的基础设施&#xff0c;以家用电视机和电脑作为主要终端 &#xff0c;利用网络机顶盒(STB,Set -TopBox) &#xff0c;通过互联网协议来传送电视信号.提供包括 电视节 目在 内…
阅读更多...
嵌入式51单片机05-中断与定时器系列

嵌入式51单片机05-中断与定时器系列

文章目录 中断与定时器一、中断系统与定时器1. 中断简单介绍2. 定时器简单介绍 二、中断系列代码1. 中断操作&#xff08;中断控制LED灯亮灭&#xff09;&#xff08;1&#xff09;仿真电路图&#xff08;2&#xff09;源代码&#xff08;3&#xff09;实验结果 2. 中断操作&am…
阅读更多...
c++强制类型转换：

c++强制类型转换：

强制类型转换&#xff1a;1. const属性用const_cast。 案例&#xff1a; 说明&#xff1a;该变量可以将变量的const 的属性去掉。如该案例&#xff0c;转换后修改x的值是合法的。2. 基本类型转换用static_cast。 案例&#xff1a; 说明&#xff1a;一般用在(1)基本类型&#xf…
阅读更多...
新黑马头条项目经验（黑马）

新黑马头条项目经验（黑马）

swagger (1)简介 Swagger 是一个规范和完整的框架&#xff0c;用于生成、描述、调用和可视化 RESTful 风格的 Web 服务(API Documentation & Design Tools for Teams | Swagger)。 它的主要作用是&#xff1a; 使得前后端分离开发更加方便&#xff0c;有利于团队协作 接…
阅读更多...
微服务知识

微服务知识

Spring Cloud Netfix&#xff1a;Eureka&#xff0c;Ribbon&#xff0c;Feign&#xff0c;Hystrix&#xff0c;Zuul | Gateway&#xff0c;Config Spring Colud Alibaba&#xff1a;Nacos&#xff0c;Sentinel&#xff0c;Seata Nacos通过Ribbon实现负载均衡&#xff0c;Ribb…
阅读更多...
【java笔记】java多线程

【java笔记】java多线程

目录 一、概念 1.1 什么是进程&#xff1f; 1.2 什么是线程&#xff1f; 1.3 什么事多线程&#xff1f; 1.4 进程和线程的关系 二、线程对象的生命周期 三、实现线程有两种方式 3.1 继承 java.lang.Thread&#xff0c;重写 run方法 3.2 实现 java.lang.Runnable 接口…
阅读更多...
材料写作素材：关于“大”排比句40例

材料写作素材：关于“大”排比句40例

1.一轮思想政治“大督查”&#xff0c;一轮政策落实“大检查”&#xff0c;一次非公企业“大走访”&#xff0c;一次问题线索“大起底”&#xff0c;一批典型案例“大曝光”。 2.在重大风险挑战面前豁得出去、顶得上去&#xff0c;在重大困难考验面前迎难而上、敢于胜利&#…
阅读更多...
【计网】WebSocket协议

【计网】WebSocket协议

目录 一、背景 二、WebSocket握手过程 三、SpringBoot中使用WebSocket协议 1、服务器 2、客户端 一、背景 一般的web开发以请求响应为主即客户端发送一个请求&#xff0c;服务器返回一个响应&#xff0c;这就使得类似聊天等需求基于HTTP协议进行实现时比较消费资源&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023