C语言中“内存对齐”解析

时间 2019-12-11

标签 c语言内存对齐解析繁體版

原文原文链接

C语言字节对齐

转载链接1：http://blog.csdn.net/21aspnet/article/details/6729724html

转载链接2：http://blog.chinaunix.net/uid-10995602-id-2918694.htmlc++

文章最后本人作了一幅图，一看就明白了，这个问题网上讲的很多，可是都没有把问题说透。程序员

1、概念　　　　web

　　对齐跟数据在内存中的位置有关。若是一个变量的内存地址正好位于它长度的整数倍，他就被称作天然对齐。好比在32位cpu下，假设一个整型变量的地址为0x00000004，那它就是天然对齐的。编程

2、为何要字节对齐　　　　数组

　　须要字节对齐的根本缘由在于CPU访问数据的效率问题。假设上面整型变量的地址不是天然对齐，好比为0x00000002，则CPU若是取它的值的话须要访问两次内存，第一次取从0x00000002-0x00000003的一个short，第二次取从0x00000004-0x00000005的一个short而后组合获得所要的数据，若是变量在0x00000003地址上的话则要访问三次内存，第一次为char，第二次为short，第三次为char，而后组合获得整型数据。而若是变量在天然对齐位置上，则只要一次就能够取出数据。一些系统对对齐要求很是严格，好比sparc系统，若是取未对齐的数据会发生错误，举个例：　缓存

　　//　　　数据结构

　　char ch[8]; 　　多线程

　　char *p = &ch[1]; 　　架构

　　int i = *(int *)p; 　　　　　　

　　......

运行时会报segment error，而在x86上就不会出现错误，只是效率降低。　　　　

3、正确处理字节对齐　　　　

　　对于标准数据类型，它的地址只要是它的长度的整数倍就好了，而非标准数据类型按下面的原则对齐：　　　　

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

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

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

好比有以下一个结构体：　　　　

　　struct stu { 　　

　　　　char sex; 　　

　　　　int length; 　　

　　　　char name[10]; 　　

　　}; 　　

　　struct stu my_stu; 　　　　　　

因为在x86下，GCC默认按4字节对齐，它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。因而咱们sizeof(my_stu)会获得长度为20，而不是15. 　　　　

4、__attribute__选项　　　　

　　咱们能够按照本身设定的对齐大小来编译程序，GNU使用__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; 　　　　　　

__attribute__((packed))得变量或者结构体成员使用最小的对齐方式，即对变量是一字节对齐，对域（field）是位对齐. 　　　　

5、何时须要设置对齐　　　　

　　在设计不一样CPU下的通讯协议时，或者编写硬件驱动程序时寄存器的结构这两个地方都须要按一字节对齐。即便看起来原本就天然对齐的也要使其对齐，以避免不一样的编译器生成的代码不同.

//************************************************************************************************************************************************************//

1、快速理解

1. 什么是字节对齐？

　　在C语言中，结构是一种复合数据类型，其构成元素既能够是基本数据类型（如int、long、float等）的变量，也能够是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每一个成员按其天然边界（alignment）分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。为了使CPU可以对变量进行快速的访问,变量的起始地址应该具备某些特性,即所谓的”对齐”. 好比4字节的int型,其起始地址应该位于4字节的边界上,即起始地址可以被4整除.

2. 字节对齐有什么做用？

　　字节对齐的做用不只是便于cpu快速访问，同时合理的利用字节对齐能够有效地节省存储空间。

对于32位机来讲，4字节对齐可以使cpu访问速度提升，好比说一个long类型的变量，若是跨越了4字节边界存储，那么cpu要读取两次，这样效率就低了。可是在32位机中使用1字节或者2字节对齐，反而会使变量访问速度下降。因此这要考虑处理器类型，另外还得考虑编译器的类型。在vc中默认是4字节对齐的，GNU gcc 也是默认4字节对齐。

3. 更改C编译器的缺省字节对齐方式

在缺省状况下，C编译器为每个变量或是数据单元按其天然对界条件分配空间。通常地，能够经过下面的方法来改变缺省的对界条件： · 使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。 · 使用伪指令#pragma pack ()，取消自定义字节对齐方式。

另外，还有以下的一种方式： · __attribute((aligned (n)))，让所做用的结构成员对齐在n字节天然边界上。若是结构中有成员的长度大于n，则按照最大成员的长度来对齐。 · __attribute__ ((packed))，取消结构在编译过程当中的优化对齐，按照实际占用字节数进行对齐。

4. 举例说明

例1

　　struct test {

　　　　char x1;

　　　　short x2;

　　　　float x3;

　　　　char x4;

　　};

因为编译器默认状况下会对这个struct做天然边界（有人说“天然对界”我以为边界更顺口）对齐，结构的第一个成员x1，其偏移地址为0，占据了第1个字节。第二个成员x2为short类型，其起始地址必须2字节对界，所以，编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4刚好落在其天然边界地址上，在它们前面不须要额外的填充字节。在test结构中，成员x3要求4字节对界，是该结构全部成员中要求的最大边界单元，于是test结构的天然对界条件为4字节，编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

例2

　　#pragma pack(1) //让编译器对这个结构做1字节对齐

　　struct test {

　　　　char x1;

　　　　short x2;

　　　　float x3;

　　　　char x4;

　　};

　　#pragma pack() //取消1字节对齐，恢复为默认4字节对齐

这时候sizeof(struct test)的值为8。

例3

　　#define GNUC_PACKED __attribute__((packed))

　　struct PACKED test {

　　　　char x1;

　　　　short x2;

　　　　float x3;

　　　　char x4;

　　}GNUC_PACKED;

这时候sizeof(struct test)的值仍为8。

2、深刻理解

　　什么是字节对齐,为何要对齐? TragicJun 发表于 2006-9-18 9:41:00 现代计算机中内存空间都是按照byte划分的，从理论上讲彷佛对任何类型的变量的访问能够从任何地址开始，但实际状况是在访问特定类型变量的时候常常在特定的内存地址访问，这就须要各类类型数据按照必定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。

1.对齐的做用和缘由：

　　各个硬件平台对存储空间的处理上有很大的不一样。一些平台对某些特定类型的数据只能从某些特定地址开始存取。好比有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其余平台可能没有这种状况，可是最多见的是若是不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。好比有些平台每次读都是从偶地址开始，若是一个int型（假设为32位系统）若是存放在偶地址开始的地方，那么一个读周期就能够读出这32bit，而若是存放在奇地址开始的地方，就须要2个读周期，并对两次读出的结果的高低字节进行拼凑才能获得该32bit数据。显然在读取效率上降低不少。

2.字节对齐对程序的影响:

　　先让咱们看几个例子吧(32bit,x86环境,gcc编译器):

设结构体以下定义：

　　struct A {

　　　　int a;

　　　　char b;

　　　　short c;

　　};

　　struct B {

　　　　char b;

　　　　int a;

　　　　short c;

　　};

如今已知32位机器上各类数据类型的长度以下:

char:1(有符号无符号同)

short:2(有符号无符号同)

int:4(有符号无符号同)

long:4(有符号无符号同)

float:4

double:8 那么上面两个结构大小如何呢?

结果是: sizeof(strcut A)值为8 sizeof(struct B)的值倒是12

结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也同样;按理说A,B大小应该都是7字节。之因此出现上面的结果是由于编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么咱们是否是能够改变编译器的这种默认对齐设置呢,固然能够.例如:

　　#pragma pack (2) /*指定按2字节对齐*/

　　struct C {

　　　　char b;

　　　　int a;

　　　　short c;

　　};

　　#pragma pack () /*取消指定对齐，恢复缺省对齐*/

sizeof(struct C)值是8。

修改对齐值为1：

　　#pragma pack (1) /*指定按1字节对齐*/

　　struct D {

　　　　char b;

　　　　int a;

　　　　short c;

　　};

　　#pragma pack () /*取消指定对齐，恢复缺省对齐*/

sizeof(struct D)值为7。后面咱们再讲解#pragma pack()的做用.

三.编译器是按照什么样的原则进行对齐的?

　　先让咱们看四个重要的基本概念：

1.数据类型自身的对齐值：对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。

2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。

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

4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。

有了这些值，咱们就能够很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的前后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放，结构体自己也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度须要是对结构体有效对齐值的整数倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。

例子分析：分析例子B；

　　struct B {

　　　　char b;

　　　　int a;

　　　　short c;

　　};

假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。

第一个成员变量b的自身对齐值是1，比指定或者默认指定对齐值4小，因此其有效对齐值为1，因此其存放地址0x0000符合0x0000%1=0.

第二个成员变量a，其自身对齐值为4，因此有效对齐值也为4，因此只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为2，因此有效对齐值也是2，能够存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。因此从0x0000到0x0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）因此就是4，因此结构体的有效对齐值也是4。

根据结构体圆整的要求，0x0009到0x0000=10字节，（10＋2）％4＝0。因此0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B共有12个字节,sizeof(struct B)=12;其实若是就这一个就来讲它已将知足字节对齐了,由于它的起始地址是0,所以确定是对齐的,之因此在后面补充2个字节,是由于编译器为了实现结构数组的存取效率,试想若是咱们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,可是第二个结构呢?按照数组的定义,数组中全部元素都是紧挨着的,若是咱们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能知足结构的地址对齐了,所以咱们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只是由于这些类型的长度已知了,因此他们的自身对齐值也就已知了.

同理,分析上面例子C：

　　#pragma pack (2) /*指定按2字节对齐*/

　　struct C {

　　　　char b;

　　　　int a;

　　　　short c;

　　};

　　#pragma pack () /*取消指定对齐，恢复缺省对齐*/

第一个变量b的自身对齐值为1，指定对齐值为2，因此，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x0000%1=0;

第二个变量，自身对齐值为4，指定对齐值为2，因此有效对齐值为2，因此顺序存放在0x000二、0x000三、0x000四、0x0005四个连续字节中，符合0x0002%2=0。

第三个变量c的自身对齐值为2，因此有效对齐值为2，顺序存放在0x000六、0x0007中，符合0x0006%2=0。因此从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4，因此C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。因此sizeof(struct C)=8.

四.如何修改编译器的默认对齐值?

　　1.在VC IDE中，能够这样修改：[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认是8字节。

　　2.在编码时，能够这样动态修改：#pragma pack .注意:是pragma而不是progma.

五.针对字节对齐,咱们在编程中如何考虑?

　　若是在编程的时候要考虑节约空间的话,那么咱们只须要假定结构的首地址是0,而后各个变量按照上面的原则进行排列便可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽可能减小中间的填补空间.还有一种就是为了以空间换取时间的效率,咱们显示的进行填补空间进行对齐,好比:有一种使用空间换时间作法是显式的插入reserved成员：

　　struct A{

　　　　char a;

　　　　char reserved[3];//使用空间换时间

　　　　int b;

　　}

reserved成员对咱们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,固然即便不加这个成员一般编译器也会给咱们自动填补对齐,咱们本身加上它只是起到显式的提醒做用.

六.字节对齐可能带来的隐患:

代码中关于对齐的隐患，不少是隐式的。好比在强制类型转换的时候。例如：

　　unsigned int i = 0x12345678;

　　unsigned char *p=NULL;

　　unsigned short *p1=NULL;

　　p=&i;

　　*p=0x00;

　　p1=(unsigned short *)(p+1);

　　*p1=0x0000;

最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。在x86上，相似的操做只会影响效率，可是在MIPS或者sparc上，可能就是一个error,由于它们要求必须字节对齐.

七.如何查找与字节对齐方面的问题:

　　若是出现对齐或者赋值问题首先查看 1. 编译器的big little端设置 2. 看这种体系自己是否支持非对齐访问 3. 若是支持看设置了对齐与否,若是没有则看访问时须要加某些特殊的修饰来标志其特殊访问操做

举例：

[cpp] view plaincopy 
      
    
#include <stdio.h>  
main()  
{  
struct A {  
    int a;  
    char b;  
    short c;  
};  
  
struct B {  
    char b;  
    int a;  
    short c;  
};  
  
#pragma pack (2) /*指定按2字节对齐*/  
struct C {  
    char b;  
    int a;  
    short c;  
};  
#pragma pack () /*取消指定对齐，恢复缺省对齐*/  
  
  
  
#pragma pack (1) /*指定按1字节对齐*/  
struct D {  
    char b;  
    int a;  
    short c;  
};  
#pragma pack ()/*取消指定对齐，恢复缺省对齐*/  
  
int s1=sizeof(struct A);  
int s2=sizeof(struct B);  
int s3=sizeof(struct C);  
int s4=sizeof(struct D);  
printf("%d\n",s1);  
printf("%d\n",s2);  
printf("%d\n",s3);  
printf("%d\n",s4);  
}  

输出：

修改代码：

　　struct A {

　　　　// int a;

　　　　char b;

　　　　short c;

　　};

　　struct B {

　　　　char b;

　　　　// int a;

　　　　short c;

　　};

输出：

输出都是4，说明以前的int影响对齐！

看图就明白了

//************************************************************************************************************************************************************//

内存对齐

在最近的项目中，咱们涉及到了“内存对齐”技术。对于大部分程序员来讲，“内存对齐”对他们来讲都应该是“透明的”。“内存对齐”应该是编译器的 “管辖范围”。编译器为程序中的每一个“数据单元”安排在适当的位置上。可是C语言的一个特色就是太灵活，太强大，它容许你干预“内存对齐”。若是你想了解更加底层的秘密，“内存对齐”对你就不该该再透明了。

1、内存对齐的缘由
大部分的参考资料都是如是说的：
一、平台缘由(移植缘由)：不是全部的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，不然抛出硬件异常。
二、性能缘由：数据结构(尤为是栈)应该尽量地在天然边界上对齐。缘由在于，为了访问未对齐的内存，处理器须要做两次内存访问；而对齐的内存访问仅须要一次访问。

2、对齐规则
每一个特定平台上的编译器都有本身的默认“对齐系数”(也叫对齐模数)。程序员能够经过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。

规则：
一、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，之后每一个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。
二、结构(或联合)的总体对齐规则：在数据成员完成各自对齐以后，结构(或联合)自己也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。
三、结合一、2颗推断：当#pragma pack的n值等于或超过全部数据成员长度的时候，这个n值的大小将不产生任何效果。

3、试验
咱们经过一系列例子的详细说明来证实这个规则吧!
我试验用的编译器包括GCC 3.4.2和VC6.0的C编译器，平台为Windows XP + Sp2。

咱们将用典型的struct对齐来讲明。首先咱们定义一个struct：
#pragma pack(n) /* n = 1, 2, 4, 8, 16 */
struct test_t {
int a;
char b;
short c;
char d;
};
#pragma pack(n)
首先咱们首先确认在试验平台上的各个类型的size，经验证两个编译器的输出均为：
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4

咱们的试验过程以下：经过#pragma pack(n)改变“对齐系数”，而后察看sizeof(struct test_t)的值。

一、1字节对齐(#pragma pack(1))
输出结果：sizeof(struct test_t) = 8 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(1)
struct test_t {
int a;  /* 长度4 < 1 按1对齐；起始offset=0 0%1=0；存放位置区间[0,3] */
char b;  /* 长度1 = 1 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* 长度2 > 1 按1对齐；起始offset=5 5%1=0；存放位置区间[5,6] */
char d;  /* 长度1 = 1 按1对齐；起始offset=7 7%1=0；存放位置区间[7] */
};
#pragma pack()
成员总大小=8

2) 总体对齐
总体对齐系数 = min((max(int,short,char), 1) = 1
总体大小 (size)=$(成员总大小) 按 $(总体对齐系数) 圆整 = 8 /* 8%1=0 */ [注1]

二、2字节对齐(#pragma pack(2))
输出结果：sizeof(struct test_t) = 10 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(2)
struct test_t {
int a;  /* 长度4 > 2 按2对齐；起始offset=0 0%2=0；存放位置区间[0,3] */
char b;  /* 长度1 < 2 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* 长度2 = 2 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d;  /* 长度1 < 2 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */
};
#pragma pack()
成员总大小=9

2) 总体对齐
总体对齐系数 = min((max(int,short,char), 2) = 2
总体大小 (size)=$(成员总大小) 按 $(总体对齐系数) 圆整 = 10 /* 10%2=0 */

三、4字节对齐(#pragma pack(4))
输出结果：sizeof(struct test_t) = 12 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(4)
struct test_t {
int a;  /* 长度4 = 4 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */
char b;  /* 长度1 < 4 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* 长度2 < 4 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d;  /* 长度1 < 4 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */
};
#pragma pack()
成员总大小=9

2) 总体对齐
总体对齐系数 = min((max(int,short,char), 4) = 4
总体大小 (size)=$(成员总大小) 按 $(总体对齐系数) 圆整 = 12 /* 12%4=0 */

四、8字节对齐(#pragma pack(8))
输出结果：sizeof(struct test_t) = 12 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(8)
struct test_t {
int a;  /* 长度4 < 8 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */
char b;  /* 长度1 < 8 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* 长度2 < 8 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d;  /* 长度1 < 8 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */
};
#pragma pack()
成员总大小=9

2) 总体对齐
总体对齐系数 = min((max(int,short,char), 8) = 4
总体大小 (size)=$(成员总大小) 按 $(总体对齐系数) 圆整 = 12 /* 12%4=0 */

五、16字节对齐(#pragma pack(16))
输出结果：sizeof(struct test_t) = 12 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(16)
struct test_t {
int a;  /* 长度4 < 16 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */
char b;  /* 长度1 < 16 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* 长度2 < 16 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d;  /* 长度1 < 16 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */
};
#pragma pack()
成员总大小=9

2) 总体对齐
总体对齐系数 = min((max(int,short,char), 16) = 4
总体大小 (size)=$(成员总大小) 按 $(总体对齐系数) 圆整 = 12 /* 12%4=0 */

4、结论
8字节和16字节对齐试验证实了“规则”的第3点：“当#pragma pack的n值等于或超过全部数据成员长度的时候，这个n值的大小将不产生任何效果”。另外内存对齐是个很复杂的东西，上面所说的在有些时候也可能不正确。呵呵^_^

[注1]
什么是“圆整”？
举例说明：如上面的8字节对齐中的“总体对齐”，总体大小=9 按 4 圆整 = 12
圆整的过程：从9开始每次加一，看是否能被4整除，这里9，10，11均不能被4整除，到12时能够，则圆整结束。

1 const

c　　onst限定的对象表示编译器能够将它放在只读存储器中，也就意味着在对其进行初始化以后就不能改变它的值。根据const使用的不一样场合，大体能够分为三种状况，其一限定普通变量，其二限定函数参数，其三限定指针变量。

　　第一和第二种状况最为简单，语句①和语句②分别展现了它的用法。语句①定义了一个值为10的整型常量。语句②中的const表示在函数体中不能修改src指向的区域中的数据，这与函数的拷贝功能相对应，只作它应该作的事情而不该该有其余反作用，编译器能够利用这些信息进行适当的优化。

　　① const int i=10;
　　② void *memcpy(void * dst, const void * src, size_t size);
　　③ const int *ptr;
　　④ int const *ptr;
　　⑤ int * const ptr;
　　⑥ int const * const ptr;

　　第3种状况最为复杂，虽然只是const位置不一样，可是却可能具备彻底不一样的意义。通常，一个声明语句由声明说明符 (declspecifier)和一系列声明子(declarator)两部分组成，并且声明说明符中的符号能够以任何次序出现。理解声明的第一步是定位说明符和声明子的边界。这很容易：全部的说明符都是关键字或者类型名，所以说明符终止于第一个不是以上类型之一的符号。例如，在语句③和④中第一个既不是关键字也不是类型名的符号是“*”，即声明说明符分别为const int和int const，因为声明说明符中的符号能够以任意次序出现，所以语句③和④的含义是相同的。

　　为了迅速弄清语句表达的含义，参考文献[1]介绍了一种简便的方法，其要点就是“逆序读出定义”。

2 static与extern

　　static的含义随着出现位置（全局变量仍是局部变量）和修饰对象（变量仍是函数）的不一样而有很大的差异。下面各条目中的模块指的是一个源文件或者一个翻译单元：

　　① 位于函数体中的静态变量在屡次函数调用间会维持其值。
　　② 位于模块内（但在函数体外）的静态变量能够被模块内的全部函数访问，但不能被模块外其余函数访问。也就是说，它是一个本地的全局变量。
　　③ 位于模块内的静态函数只能被此模块内的其余函数调用。也就是说，这个函数的做用域为声明所在的模块。

　　static int global;/*状况2*/
　　static void foo(void)/*状况3*/
　　{
　　　　static int local = 0;/*状况1*/
　　}

　　为了清楚地理解static的3种用法，必须首先了解C语言中每一个标识符都具备的做用域、连接和存储持续期等特性的含义。在ISO C99标准中，其定义以下：

　　① 对象的做用域指的是它仅在程序的某个区域中是可见的（便可以使用）。常见的做用域有文件做用域和块做用域。
　　② 对象的存储持续期决定对象的生命周期，即在程序执行某段区间中为对象保留存储区。有两种类型的存储持续期：静态的和自动的。静态存储持续期的对象的生命周期为程序执行的全过程，它的值在程序启动前仅初始化一次。
　　③ 连接指的是在不一样做用域中声明的或者同一个做用域中屡次声明的标识符能够引用相同的对象或函数。有3种类型的连接：外部、内部和无。

　　在状况②和③中，static分别用来修饰全局变量global和函数foo，改变它们的连接特性，使它们具备内部连接。也就是说，只有在定义它们的翻译单元或者文件内才能使用它们，这对于建立模块化的软件很是重要。

　　与static相反，extern修饰的对象或函数具备外部连接。对于那些暴露给外部使用的接口函数应该使用extern限定，那些非接口函数，例如工具函数或与实现细节相关的函数，则应该显式地使用static限定。这是由于若是函数声明不带任何存储类说明符，那么它具备外部连接就好像使用了extern同样。

　　在状况①中，static用来修饰局部变量local，将local的存储持续期由自动的改变为静态的，这样在foo函数的屡次调用间会为其保留值。注意做用域、连接和存储持续期特性之间是正交的。例如在状况①中，虽然变量local的存储持续期变成静态的，可是它的做用域仍然是块做用域。

3 volatile

　　volatile关键字用来声明这样的对象，它们的值可能因为程序控制以外的事件而被潜在改变。volatile强制编译器不会对其所限定的对象进行任何优化，每次读写都必须访问实际的存储器而不能使用寄存器中的副本。在实践中，它大量的用来描述一个对应于内存映射的输入/输出端口，例如飞利浦公司LPC21xx系列ARM处理器的向量地址寄存器定义为：

　　#define VICVectAddr(*((volatile unsigned long *) 0xFFFFF030))

　　其次，中断服务例程中使用的非自动变量或者多线程应用程序中多个任务共享的变量也必须使用volatile进行限定。例如在下面的示例中，若是没有使用volatile限定g_Flag变量，编译器看到在foo函数中并无修改g_Flag，可能只执行一次g_Flag读操做并将g_Flag的值缓存在寄存器中，之后每次g_Flag读操做都使用寄存器中的缓存值而不进行存储器访问，致使some_action函数永远没法执行。

　　int g_Flag = 0;
　　void foo(void){
　　　　while(1){
　　　　　　if(g_Flag){ some_action(); }
　　　　}
　　}
　　void isr_service(void){
　　　　g_Flag = 1;
　　}

4 __packed

　　在嵌入式软件编程中，常常须要精确控制结构体在内存中的布局和访问非天然对齐的数据，可是C语言标准中并无统一的规定而是留给编译器厂商自行处理。在ARM C编译器中，使用__packed关键字将任何类型的对齐设置为1字节。在实践中，__packed主要有两个功能：其一，当它修饰指针时，表示此指针指向的地址是非天然对齐的，编译器会生成特殊的代码以确保得到正确的结果；其二，当它修饰结构体、联合或它们中的域时，能够用来建立没有填充的结构。

　　与其余RISC架构同样，ARM处理器可以高效地访问对齐的数据，即字地址的末尾两位为零，半字地址的最后一位为零，也称这样的数据位于它的自然大小边界或者是天然对齐的。ARM编译器但愿普通的“C”指针指向一个4字节对齐内存地址，这样它能够在代码中使用LDR/STR指令一次操做4个字节，不然只能使用LDRB/LDRH等字节/半字操做指令。相反若是指针指向一个非天然对齐的地址，例如若是一个整型指针指向地址0x8006，固然但愿装载地址0x8006-0x8007-0x8008-0x8009处的数据，可是实际上ARM会对非天然对齐的地址进行转换而从装载地址 0x8004-0x8005-0x8006-0x8007处的数据。在下面的示例中（测试环境为uVision3），首先定义了一个大小为16字节的整型数组，依次初始化为0,1,2,…,15。因为array是一个整型数组，编译器会确保它是4字节对齐的，即指针pc指向一个4字节对齐的地址。运行程序后，能够看到若是对pc指针不加__packed标记进行修饰，将获得一个奇怪的0x01000302；而在添加了__packed关键字以后，就获得了正确的结果。也就是说，若是要访问非天然对齐的数据，必须使用__packed关键字显式地标记出来。

　　int main() {
　　　　int i, j, array[4];
　　　　char *pc = (char *)array;
　　　　for(i=0; i<16; i++){
　　　　　　*(pc+i)=i;
　　　　}
　　　　/*确保pc指向一个4字节对齐的地址*/
　　　　while((int)pc & 0x3){ ++pc; }
　　　　/*访问非天然对齐的整型数据，i=0x01000302*/
　　　　i = *((int*)(pc+2));
　　　　//访问“标明”为非天然对齐的数据 i=0x05040302
　　　　j = *((__packed int*)(pc+2));
　　}

　　ARM编译器老是保证程序中的变量、结构体或联合中的域分配到天然对齐的地址。这意味着编译器常常须要在各个域之间插入填充，以确保每一个域的自然对齐。一般来讲，程序员能够对这些填充视而不见，可是也有例外，例如为了节省结构体占用的空间，能够利用__packed去除填充。在了解了编译器的填充行为以后，能够经过调整域的顺序来减少结构体占用的空间。例如虽然结构体s1和s2的域相同，可是sizeof(s1)等于16，而 sizeof(s2)等于12。

　　struct s1{　　　　int i1;　　　　short s1;　　　　int i2;　　　　short s2;　　};　　struct s2{　　　　int i1;　　　　int i2;　　　　short s1;　　　　short s2;　　};