现代计算机中内存空间都是按照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， 所以只能存放在起始地址为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，所以顺序存放在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下的对齐处理
from DUI0067D_ADS1_2_CompLib

3.13 type  qulifiers

有部分摘自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]
*/

发现自己的审美观不咋的，俺觉得漂亮的人家觉得不漂亮。还是照着大家要求的画一个。

主要解决的问题是，这次行列都用宏表示，这样可以修改行列，窗口大小也动态改变。

另外长条旋转变成Z型问题也解决，主要是取模的时候绕回去了。

其中最重要的要算是解决了刷新闪烁问题，尽管HAM2008指点过，始终没做成，这次vczh说了一句话就点醒了我。根本不应该使用InvalidateRect函数，直接画，然后用缓冲DC就可以了。

VOID OnPaint()
{
    HDC hdc = GetDC(hWnd);
    HDC bitmap_dc = CreateCompatibleDC(hdc);
    HBITMAP bitmap = CreateCompatibleBitmap(hdc,1024,768);
    SelectObject(bitmap_dc,bitmap);
    
   /**//********************************************
   DrawBlock
   *********************************************/
   int x = tetris.GetX();
   int y = tetris.GetY();

   for(int i=0; i<4; ++i)
   {
       for(int j=0; j<4; ++j)
       {
           if(current_block[i][j] == 1)
           {
               DrawBlock(bitmap_dc,y+i+1,x+j+1,3,3,tetris.GetColor(),RGB(0,0,0));
           }
       }
   }

   /**//*****************************************
   *DrawContainer
   ******************************************/
   for(int i=0; i<ROWS; ++i)
   {
       for(int j=0; j<COLS; ++j)
       {
           if(Container[i][j] == 1)
           {
               DrawBlock(bitmap_dc,i+1,j+1,3,3,ColorTable[i][j],RGB(0,0,0));
           }
       }
   }

   BitBlt(hdc,0,0,1024,768,bitmap_dc,0,0,SRCCOPY);
   DeleteDC(bitmap_dc);
   DeleteObject(bitmap);
   ReleaseDC(hWnd,hdc);
}

条件编译的使用
以下是该头文件用到的几个宏

 1//每种环境都设置一个宏且都置0
 2#define PLAT_GTK 0
 3#define PLAT_GTK_WIN32 0
 4#define PLAT_MACOSX 0
 5#define PLAT_WIN 0
 6#define PLAT_WX  0
 7#define PLAT_FOX 0
 8//如果该环境有效则取消原有宏且置1
 9#if defined(FOX)
10#undef PLAT_FOX
11#define PLAT_FOX 1
12
13#if defined(__WIN32__) || defined(_MSC_VER)
14#undef PLAT_GTK_WIN32
15#define PLAT_GTK_WIN32 1
16#endif
17
18#else
19#undef PLAT_WIN
20#define PLAT_WIN 1
21
22#endif
23

如此设置各个宏后就可以使用了

class Palette {
    int used;
    int size;
    ColourPair *entries;
#if PLAT_GTK//1为真，这里可以是一个常量表达式
    void *allocatedPalette; // GdkColor *
    int allocatedLen;
#endif

如果是GTK环境则需要另外设置两个变量，一个是分配调色板，一个是指明长度。若为win32环境就无需这两个变量了。该条件编译用于生成不同平台下的产品。即编译代码的不同部分，这就是预处理的一个功能。

二.Typedef的使用

typedef void *FontID;
typedef void *SurfaceID;
typedef void *WindowID;
typedef void *MenuID;
typedef void *TickerID;
typedef void *Function;
typedef void *IdlerID;

不同平台的具体类型不同，可以用该方法定义新的名字，使程序更清晰。

 

三.关于颜色的管理的几个类

ColourDesired

颜色使用一个长整形，也就是用32位来描述一种颜色。

主要看两个Set函数的实现，第一个是从指定的三基色的值来构造一种颜色。

void Set(unsigned int red, unsigned int green, unsigned int blue) {
        co = red | (green << 8) | (blue << 16);
    }

 

从代码看出从高到低依次是bgr，这个顺序正好是RGB模型。那么每个值占8位。总共是24位，最高的8位我想是alpha通道吧。

 

另一种是从一个数组构造，目前猜测是xpm格式描述的数组的部分。他首先有个提取十六进制真值的函数作为辅助，比较简单。

static inline unsigned int ValueOfHex(const char ch) {
        if (ch >= '0' && ch <= '9')
            return ch - '0';
        else if (ch >= 'A' && ch <= 'F')
            return ch - 'A' + 10;
        else if (ch >= 'a' && ch <= 'f')
            return ch - 'a' + 10;
        else
            return 0;
    }

void Set(const char *val) {
        if (*val == '#') {
            val++;
        }
        unsigned int r = ValueOfHex(val[0]) * 16 + ValueOfHex(val[1]);
        unsigned int g = ValueOfHex(val[2]) * 16 + ValueOfHex(val[3]);
        unsigned int b = ValueOfHex(val[4]) * 16 + ValueOfHex(val[5]);
        Set(r, g, b);
    }

 

再看一个图标的数组

 1/**//* XPM */
 2static char * arrow_xpm[] = {
 3"12 12 3 1",
 4"     c None",
 5".    c #000000",
 6"+    c #808080",
 7"            ",
 8"     .+     ",
 9"      .+    ",
10"      +.+   ",
11" ..+  ",
12" + ",
13" + ",
14" ..+  ",
15"      +.+   ",
16"      .+    ",
17"     .+     ",
18"            "};
19

可以看到该字符图像由三种符号组成，然后三种符号的颜色显然是这么描述的"    

c None",

". c #000000",

"+ c #808080",

 Set函数遇到一个#号就开始提取计算颜色rgb值了。那么整个图像应该是通过这个Set函数的几次调用进行的。ColourAllocated类简单的把上一个类求的值赋给他的成员。具体作用还不清楚。ColourPair类包含以上两个类的对象，这些可能是设计上的原因。因为具体的操作都是ColourDesired完成。

const_cast，reinterpret_cast，static_cast，dynamic_cast等等。   

1）static_cast<T*>(a)   

将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。   

表达式static_cast<T*>(a), a的值转换为模板中指定的类型T。在运行时转换过程中，不进行类型检查来确保转换的安全性。   

例子：   

class B {  };   

class D : public B {  };   

void f(B* pb, D* pd)   

{    

   D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针   

   B* pb2 = static_cast<B*>(pd);        // 安全的   
    
} 

2）dynamic_cast<T*>(a)   

完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。   

表达式dynamic_cast<T*>(a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。   

例子：   

class A {  };   

class B {  };    

void f()   

{   

  A* pa = new A;   

  B* pb = new B;   

  void* pv = dynamic_cast<A*>(pa);   

  // pv 现在指向了一个类型为A的对象   
   

  pv = dynamic_cast<B*>(pb);   

  // pv 现在指向了一个类型为B的对象   

}  

3）const_cast<T*>(a)   

去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。   

表达式const_cast<T*>(a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。   

例子：   

class A {  };   

void f()   

{   

 const A *pa = new A;//const对象   

 A *pb;//非const对象   

//pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象   

 pb = const_cast<A*>(pa); // 现在OK了   

..   }  

4）reinterpret_cast<T*>(a)   

任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。   

表达式reinterpret_cast<T*>(a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。   

例子：   

class A {  };   

class B {  };   

void f()   

{   

  A* pa = new A;   

  void* pv = reinterpret_cast<A*>(pa);   

  // pv 现在指向了一个类型为B的对象，这可能是不安全的   

     

}  

 
本文转自http://www.libing.net.cn/read.php?520

容易出错的常用用法，做了一些整理。

一．起别名的两种用法

1.       typedef (int *） pInt;

2.       typedef   pInt (int *)

比如pInt a,b;

第一种表示： int*a;int*b;

第二种表示： int*a,b;

所以第一种更像一个类型，第二种更像宏。

二．旧式代码中声明对象

typedef struct tagPoint

{

   Int x;

   Int y;

}POINT;

POINT a,b;

三．代码简化

为复杂的声明定义一个新的简单的别名

方法：在原来的声明里逐步用别名替换一部分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化版

typedef int (*PF) (const char *, const char *);

这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个 int 类型的返回值。

如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：

PF Register(PF pf);

Register() 的参数是一个 PF 类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同。如果不用 typedef，那么代码是这样的：

int (*Register (int (*pf)(const char *, const char *)))(const char *, const char *);