C语言中字节对齐

字节对齐：

      字节对齐有助于加快计算机的取数速度，否则就得多花指令周期了。为此，编译器默认会对结构体进行处理（实际上其它地方的数据变量也是如此）

      字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，
如有需要编译器会在成员之间加上填充字节（internal adding）；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最
末一个成员之后加上填充字节（trailing padding）。
4）联合体的sizeof
结构体在内存组织上是顺序式的，联合体则是重叠式，各成员共享一段内存，所以整个联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型，这里，复合类型成员是被作为整体考虑的。
所以，下面例子中，U的sizeof值等于sizeof(s)。
union U
{
int i;
char c;
S1 s;
};

32位和64位系统区别及int字节数

一）64位系统和32位有什么区别？ 

1、64bit CPU拥有更大的寻址能力，最大支持到16GB内存，而32bit只支持4G内存

2、64位CPU一次可提取64位数据，比32位提高了一倍，理论上性能会提升1倍。但这是建立在64bit操作系统，64bit软件的基础上的。

 

什么是64位处理器？

之所以叫做“64位处理器”，是因为电脑内部都是实行2进制运算，处理器（CPU）一次处理数据的能力也是2的倍数。8位处理器、16位处理器、32位处理器和64位处理器，其计数都是2的倍数。一次处理的数据越大，该电脑处理信息的能力越来越大；因此64位处理在先天就比32位处理器具有快速的能力。那为什么不用更高级的128位处理器呢？因为位数越高，处理器芯片的设计也就越复杂，目前的技术水平暂时无法制造这么复杂的芯片。

 

64位处理器之失

※硬件———缺乏驱动程序，很多现有硬件无法使用

※软件———操作系统不是问题，但是软件出现不兼容难题

 

64位处理器之得

※硬件———更快的执行速度，更大的内存管理

※软件———最新的尖端软件首先出现在64位平台

 

（二）数据类型对应字节数

程序运行平台
      不同的平台上对不同数据类型分配的字节数是不同的。
      个人对平台的理解是CPU+OS+Compiler，是因为： 
      1、64位机器也可以装32位系统（x64装XP）； 
      2、32位机器上可以有16/32位的编译器（XP上有tc是16位的，其他常见的是32位的）； 
      3、即使是32位的编译器也可以弄出64位的integer来（int64）。 
      以上这些是基于常见的wintel平台，加上我们可能很少机会接触的其它平台（其它的CPU和OS），所以个人认为所谓平台的概念是三者的组合。 
      虽然三者的长度可以不一样，但显然相互配合（即长度相等，32位的CPU+32位的OS+32位的Compiler）发挥的能量最大。 
      理论上来讲 我觉得数据类型的字节数应该是由CPU决定的，但是实际上主要由编译器决定(占多少位由编译器在编译期间说了算)。

常用数据类型对应字节数
  可用如sizeof（char),sizeof(char*)等得出

 32位编译器：

      char ：1个字节
      char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
      short int : 2个字节
      int：  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   4个字节
      long long:  8个字节
      unsigned long:  4个字节

  64位编译器：

      char ：1个字节
      char*(即指针变量): 8个字节
      short int : 2个字节
      int：  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   8个字节
      long long:  8个字节
      unsigned long:  8个字节

一：整形

      int                             4字节

      long int                     4字节

      short int                   2字节

      unsigned int             4字节

      unsigned long int     4字节

      unsigned short int    2字节

二：字符型

      char                          1字节

      unsigned char           1字节

三：浮点型

      float                              4字节

      double                          8字节

      long double                  8字节

      unsigned long double   8字节

      unsigned double           8字节

四：字符串型

      string                           16字节

五：指针类型

      所有类型的指针都是 4字节

六：函数

      除了void型。其他都函数占有的字节数等于函数的返回类型所占有的字节数。与函数体内部无关。

如：int fun(){}

      sizeof(fun()) = 4;

     

      int fun2(){string a;}

      sizeof(fun2()) = 4;

七：结构体、类

      内部各数据类型占用之和，然后取比这个和值最近的4的倍数。（如果本身已经是4的倍数就不用取了）

如：struct fun
    {
      string a;   //16
      char b;     //1。和为17，最近的4的倍数是20，所以sizeof（a） = 20；
    }a;

    struct fun2
    {
      string a;   //16
      char b,c,d;     //3。和为19，最近的4的倍数是20，所以sizeof（b） = 20；
    }b;

八：联合体union

      取其中占有字节数最大的数据类型所占有的字节数。

浮点数没有无符号型的usinged float/double，全是有符号的

可用如sizeof（char),sizeof(char*)等得出

32位编译器

char ：1个字节

char*（即指针变量）: 4个字节（32位的寻址空间是2^32,即32个bit，也就是4个字节。同理64位编译器）

short int : 2个字节

int：  4个字节

unsigned int : 4个字节

float:  4个字节

double:   8个字节

long:  4个字节

long long:  8个字节

unsigned long: 4个字节

 

64位编译器

char ：1个字节

char*(即指针变量): 8个字节

short int : 2个字节

int：  4个字节

unsigned int : 4个字节

float:  4个字节

double:   8个字节

long:  8个字节

long long:  8个字节

unsigned long: 8个字节

记住：double和 long long是8字节  并且不变  我总结

32位系统记住4字节对齐，有超过4字节的加上就是了

short a2=2

long int a1=4

unsigned int a3=4

unsigned short int a5=2

unsigned long int a4=4

char b=1

unsigned char b1=1

float d=4

double e=8

long double e1=12  注意

long f=4

unsigned long f1=4

long long g=8

unsigned long long g1=8

我自测的

结构体字节对齐 ：                  

      在用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;

}