Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说Keil 字节对齐,希望能够帮助你!!!。

  一.什么是字节对齐,为什么要对齐    

    现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。
    对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问 一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那 么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数 据。显然在读取效率上下降很多。

二.字节对齐对程序的影响:    
先让我们看几个例子吧(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，因为要满足"存放起始地址%N=0"，所以只能存放在起始地址为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,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍。
同理,分析上面例子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，所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中，符合0x0002%2=0。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放在0x0006、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. 如果支持，查看设置了对齐与否。如果没有，则访问时需要加某些特殊的修饰来标志其特殊访问操作。

八.相关文章:转自http://blog.csdn.net/goodluckyxl/archive/2005/10/17/506827.aspx
ARM下的对齐处理 
对齐的使用:
1.__align(num)
   这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
   就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
   这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
   对齐,但是不能让4字节的对象2字节对齐。
   __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
   
2.__packed 
  __packed是进行一字节对齐
  1.不能对packed的对象进行对齐
  2.所有对象的读写访问都进行非对齐访问
  3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
  4.__packed对局部整形变量无影响
  5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定义为packed。
     __packed int* p;  //__packed int 则没有意义
  6.对齐或非对齐读写访问带来问题
  __packed struct STRUCT_TEST
{

  char a;
  int b;
  char c;
}  ;     //此时b的起始地址一定是不对齐的

         //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]

//将下面变量定义成全局静态不在栈上 
static char* p;
static struct STRUCT_TEST a;
void Main()
{
__packed int* q;  //此时定义成__packed来修饰当前q指向为非对齐的数据地址,因此下面的访问可以进行
p = (char*)&a;          
q = (int*)(p+1);      

*q = 0x87654321; 
}

得到赋值的汇编指令很清楚

ldr      r5,0x20001590 ; = #0x12345678
[0xe1a00005]   mov      r0,r5
[0xeb0000b0]   bl       __rt_uwrite4  //在此处调用一个写4byte的操作函数 
      
[0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
[0xe1a02420]   mov      r2,r0,lsr #8
[0xe5c12001]   strb     r2,[r1,#1]
[0xe1a02820]   mov      r2,r0,lsr #16
[0xe5c12002]   strb     r2,[r1,#2]
[0xe1a02c20]   mov      r2,r0,lsr #24
[0xe5c12003]   strb     r2,[r1,#3]
[0xe1a0f00e]   mov      pc,r14

如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
[0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321
[0xe5812000]   str      r2,[r1,#0]

这样可以很清楚的看到非对齐访问是如何产生错误的，以及如何消除非对齐访问带来问题，也可以看到非对齐访问和对齐访问的指令差异导致效率问题

Keil uVision4 第一个工程PC3口上的LED闪烁的详细分析（03）

#include "NUC1xx.h"
#include "DrvGPIO.h"
int main(void)
{
  long i;
  while(1)
  {
     for(i = 0; i < 0xffff; i++);
    GPIOC->DOUT ^= 1<<3;    
  }
}

========================NUC1xx.h文件中，（注意下面的红色字体的代码跟踪）
下面跟踪的GPIOC的具体含义：根据芯片手册知 GPIOC的其中一个模式控制寄存器GPIOC_PMD在芯片内部的地址就是0x50004080
其中的一段摘录：

..............
/******************************************************************************
//*                         Peripheral memory map                              *
//******************************************************************************
//* Peripheral and SRAM base address *
/#define FLASH_BASE          ((     uint32_t)0x00000000)
#define SRAM_BASE           ((     uint32_t)0x20000000)
#define AHB_BASE            ((     uint32_t)0x50000000)
#define APB1_BASE           ((     uint32_t)0x40000000)
#define APB2_BASE           ((     uint32_t)0x40100000)
/* Peripheral memory map *
/#define GPIO_BASE           (AHB_BASE        + 0x4000)
#define GPIOA_BASE          (GPIO_BASE               )
#define GPIOB_BASE          (GPIO_BASE       + 0x0040)
#define GPIOC_BASE          (GPIO_BASE       + 0x0080)
#define GPIOD_BASE          (GPIO_BASE       + 0x00C0)
#define GPIOE_BASE          (GPIO_BASE       + 0x0100)
#define GPIO_DBNCECON_BASE  (GPIO_BASE       + 0x0180)
...........

其中的另一段摘录：

..............
#define GPIOA               ((GPIO_T *) GPIOA_BASE)
#define GPIOB               ((GPIO_T *) GPIOB_BASE)
#define GPIOC               ((GPIO_T *) GPIOC_BASE) 

这句含义是强制类型转换，有上面红色字体知 GPIOC_BASE 就是模式控制寄存器GPIOC_PMD的地址，是一个地址常量(0x50004080)，所以转换后的指针就是一个常量指针（即是常量指针，就是固定不变的），
当代码中出现了GPIOC 就会用后面的   ((GPIO_T *) GPIOC_BASE) ，然后立即就会初始化一个结构体指针，由于GPIOC_BASE的值就是0x50004080，所以就从0x50004080地址处初始这个结构体，（因为0x50004080指向这个初始化结构体的首地址）
根据下面的数据手册中GPIOC相关寄存器分布图知道，这个结构体中的整好覆盖这个GPIOC相关寄存器，所以只要通过访问这个结构体指针的某个成员就是等于直接访问对应寄存器
这里把其强制转换为指针类型，指向内容的类型就是GPIO_T结构体类型(下面的紫色字体知道它是一个结构体类型)，后面就可以用GPIOC作为指针变量用了
所以在main函数中那句：GPIOC->DOUT ^= 1<<3;的含义就是：结构体GPIOC的成员DOUT的第3位取反操作
********************************************************
/#define GPIOD               ((GPIO_T *) GPIOD_BASE)
#define GPIOE               ((GPIO_T *) GPIOE_BASE)
..............
其中的另一段摘录：

..............
typedef __IO uint32_t GPIO_SCH_T;
typedef __IO  uint32_t  GPIO_DOUT_T;
typedef __IO uint32_t GPIO_DMASK_T;
typedef __IO uint32_t GPIO_PIN_T;
typedef __IO uint32_t GPIO_DBEN_T;
typedef __IO uint32_t GPIO_IMD_T;
typedef __IO uint32_t GPIO_IEN_T;
typedef __IO uint32_t GPIO_ISRC_T;
typedef struct
{
    __IO uint32_t  DBCLKSEL:4;
    __IO uint32_t  DBCLKSRC:1;
    __IO uint32_t  ICLK_ON:1;
    __I  uint32_t  RESERVE:26;    
} GPIO_DBNCECON_T;
typedef struct
{
    GPIO_PMD_T      PMD;
    GPIO_SCH_T      SCH;
    GPIO_DOUT_T     DOUT;
    GPIO_DMASK_T    DMASK;
    GPIO_PIN_T      PIN;
    GPIO_DBEN_T     DBEN;
    GPIO_IMD_T      IMD;
    GPIO_IEN_T      IEN;
    GPIO_ISRC_T     ISRC;
    
} GPIO_T;
...........

================================附：数据手册中GPIOC相关寄存器分布

===============================附：core_M0.h

......
#ifdef __cplusplus
#define     __I     volatile                  /*!< defines 'read only' permissions      *
/#else
#define     __I     volatile const            /*!< defines 'read only' permissions      *
/#endif
#define     __O     volatile                  /*!< defines 'write only' permissions     *
/#define     __IO    volatile                  /*!< defines 'read / write' permissions   *
/..........

=============================附：结构体指针的定义
一个指针变量当用来指向一个结构变量时，称之为结构指针变量。结构指针变量中的值是所指向的结构变量的首地址。通过结构指针即可访问该结构变量，这与数组指针和函数指针的情况是相同的。
结构指针变量说明的一般形式为：
struct 结构名 *结构指针变量名
例如，在前面的例题中定义了stu这个结构，如要说明一个指向stu的指针变量pstu，可写为：
struct stu *pstu;
当然也可在定义stu结构时同时说明pstu。与前面讨论的各类指针变量相同，结构指针变量也必须要先赋值后才能使用。
赋值是把结构变量的首地址赋予该指针变量，不能把结构名赋予该指针变量。如果boy是被说明为stu类型的结构变量，则：
pstu=&boy
是正确的，而：
pstu=&stu
是错误的。
结构名和结构变量是两个不同的概念，不能混淆。结构名只能表示一个结构形式，编译系统并不对它分配内存空间。只有当某变量被说明为这种类型的结构时，才对该变量分配存储空间。因此上面&stu这种写法是错误的，不可能去取一个结构名的首地址。有了结构指针变量，就能更方便地访问结构变量的各个成员。
其访问的一般形式为：
(*结构指针变量).成员名
或为：
结构指针变量->成员名
例如：
(*pstu).num
或者：
pstu->num
应该注意(*pstu)两侧的括号不可少，因为成员符“.”的优先级高于“*”。如去掉括号写作*pstu.num则等效于*(pstu.num)，这样，意义就完全不对了
=============================附：把一个固定地址强制转为指针的例子说明
(volatile unsigned char *)0x20是强制转换，将数0X20（也是地址）转换为指针变量，变量的地址是SRAM中的0X20,volatile告诉编译器每次执行后都刷新，前面再加一星号 
(*(volatile unsigned char *)0x20)表示取指针变量所指向地址的值。 
是这样吗， 
还有点糊涂; 
一般定义一个指针得有指针变量，如 
char *u; 
char i; 
u=&i; 
这样 u是一个指针变量，这里将u指向i，也即u是i的地址；*u=i 
可上面的那个谁是指针变量呢，指向谁？也即0X20到底是指针变量还是地址?

其实 上面u只是一个符号而已,实际运行里全都成了地址,所以0X20你不必关心要用什么符号来表示,前面不是定义了宏名TWBR来指示了吗？ 相当于把一个变量定在了0x20的位置。

通过Keil uVision4 中查看ARM（ NUV100） short int、int、long 和long int占用多少字节查看Keil ARM各种数据类型占用的字节数
笔者正在学习uCOS-II，移植到ARM时考虑到数据类型的定义，但对于Keil MDK编译器的数据类型定义还是很模糊，主要就是区分不了short int、int、long 和long int占用多少字节。为了得到一个权威的答案，改用编译器自身得出。
一、先定义几个变量，用于存放各数据类型的字节数。

#include<stdio.h>
unsigned char a,b,c,d,e,f,g;
main()
{
   a=sizeof(char);
   b=sizeof(short int);
   c=sizeof(int);
   d=sizeof(long);
   e=sizeof(long int);
   f=sizeof(float);
   g=sizeof(double);
   while(1);
}

二、查看各变量的存放地址。View---Watch1。

由上图可知得出：
char占用1个字节
short int占用2字节
int占用4字节
long占用4字节
long int占用4字节
float占用4字节
double占用8字节
我们即可这样定义宏：
typedef unsigned char    uint8;      // 无符号8位整型变量
typedef signed   char    int8;       // 有符号8位整型变量
typedef unsigned short   uint16;     // 无符号16位整型变量
typedef signed   short   int16;      // 有符号16位整型变量
typedef unsigned int     uint32;     // 无符号32位整型变量
typedef signed   int     int32;      // 有符号32位整型变量
typedef float            fp32;       // 单精度浮点数（32位长度）
typedef double           fp64;       // 双精度浮点数（64位长度）

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。