sizeof详解，与strlen区别

题纲：

一：定义

二：用法

三：常量性

四：各类型的sizeof

1 基本数据类型的sizeof

2 指针变量sizeof

3 数组的sizeof

4 结构体的sizeof

5 联合的sizeof

6 枚举的sizeof

7 类的sizeof

五：与strlen的区别

一：定义

首先说明，sizeof不是一个函数，是一个C/C++中的一个操作符，它判断数据类型或者表达式占用的内存字节数，计算是在程序编译时进行，而不是在程序执行的过程中才计算。返回值类型为：size_t。

MSDN:

The sizeof keyword gives the amount of storage, in bytes, associated with avariable or a type(including aggregate types). This keyword returns a value of type size_t.

二：用法

sizeof(类型名 或 变量名 或 数组名 或 表达式);

sizeof 变量名;//不加括号

所以，sizeof有三种语法形式，如下：

sizeof(object);//sizeof(对象)
sizeof(type_name);//sizeof(类型)
sizeof object;//sizeof 对象

//所以，有以下判断：
int i ;
sizeof(i);     //OK
sizeof i;      //OK
sizeof(int); //OK
sizeof int;  //error

实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的不同对象其sizeof值都是一致的。这里，对象可以进一步延伸至表达式，即sizeof可以对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。如：

sizeof(2);//2的类型为int，所以等价于sizeof(int);
sizeof(2 + 3.14);//3.14的类型为double，2也会被提升成double类型，所以等价于sizeof(double);

sizeof也可以对 一个 函数调用 求值，其结果是函数返回类型的大小，函数并不会被调用，我们来看一个完整的例子：

char foo()
{
   printf("foo() has been called.\n");
   return'a';
}
int main()
{
    size_t sz=sizeof(foo());
    //foo()的返回值类型为char，所以sz=sizeof(char)，foo()并不会被调用
    printf("sizeof(foo())=%d\n",sz);
}

C99标准规定，函数、不能确定类型的 表达式 以及 位域 （bit-field）成员不能被计算sizeof值，即下面这些写法都是错误的：

sizeof(foo);//error
void foo2(){}
sizeof(foo2());//error
struct S
{
unsigned int f1:1;
unsigned int f2:5;
unsigned int f3:12;
};
sizeof(S.f1);//error

三：常量性

由于sizeof的计算发生在编译时刻，所以它可以被当作是常量表达式使用，如：

char ary[sizeof(int) * 10];

四：各类型的sizeof

1 ) 基本数据类型的sizeof

基本数据类型是指short、int、long、float、double这样的简单的内置数据类型，它们都和系统相关，所以在不同的系统下取值可能不同，这务必引起我们的注意，尽量不要在这方面给自己程序的移植造成麻烦

一般的，32位编译系统中:

sizeof(char); // 1
sizeof(bool); // 1
sizeof(short);// 2
sizeof(int); // 4
sizeof(long); // 4 注意
sizeof(float); // 4
sizeof(double); // 8
sizeof(1.234); // 8 注：与编译器有关，一般1.234被认为是double类型，所以为8

2 ) 指针变量sizeof

首先我们得了解指针是什么，指针是编程语言中的一个对象，它的值直接指向存在电脑存储器中的另一个地方的值。因此将地址形象化的称为“指针”，它的长度与当前CPU运行模式的寻址位数决定，在32位机32位OS的32位编译器下长度为4，参见：http://blog.sina.com.cn/s/blog_4fd9844201010n3v.html。

由上所述，指针变量的sizeof值与指针所指向的对象没有任何关系，例：

char *pChar = "abcd";
char **pPChar = &pChar;
int *pInt;
string *pStr;
void ( * pf)();

sizeof(pChar); //4
sizeof(pPChar);//4
sizeof(pInt);  //4
sizeof(pStr);  //4
sizeof(pf);    //4

3 ) 数组的sizeof

数组的sizeof等于数组所占用的内存字节数，数组的存储方式为在内存中开辟的一块连续的、大小相同的内存空间。

例：

<pre name="code" class="cpp">char a1[4] = "abc";
char a2[] = "abc";
char a3[3];
int a4[3];

sizeof(a1); //4
sizeof(a2); //4
sizeof(a3); //3
sizeof(a4); //3*4 = 12

sizeof(a4[0]); //4

再来看下面的例子：

void f3(char a3[3])
{
int c3 = sizeof(a3);
}
void f4(char a4[])
{
int c4 = sizeof(a4);
}

当数组a3,a4作为参数传递时，会蜕变成指针，相当于char * a3,char *a4，所以c3,c4都为4。

4 ) 结构体的sizeof

4-1) 案例

struct S1
{ char c; int i;};

问sizeof(s1)等于多少聪明的你开始思考了，char占1个字节，int占4个字节，那么加起来就应该是5。是这样吗？你在你机器上试过了吗？也许你是对的，但很可能你是错的！VC6中按默认设置得到的结果为8。我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节数，好吧，那就让我们来看看S1的内存分配情况：

S1 s1={'a',0xFFFFFFFF};

定义上面的 变量 后，加上 断点 ，运行程序，观察s1所在的内存，你发现了什么? 以我的VC6.0为例，s1的地址为0x0012FF78，其数据内容如下：

0012FF78: 61 CC CC CC FF FF FF FF

发现了什么怎么中间夹杂了3个字节的CC看看MSDN上的说明： When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.

4-2) 字节对齐

原来如此，这就是传说中的 字节对齐 啊！一个重要的话题出现了。

为什么需要字节对齐 计算机组成原理 教导我们这样有助于加快计算机的取数速度，否则就得多花 指令周期 了。为此， 编译器 默认会对 结构体 进行处理（实际上其它地方的数据 变量 也是如此），让宽度为2的基本 数据类型 （short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个数中间就可能需要加入填充字节，所以整个 结构体 的sizeof值就增长了。

让我们交换一下S1中char与int的位置：

structS2{inti;charc;};

看看sizeof(S2)的结果为多少，怎么还是8再看看内存，原来成员c后面仍然有3个填充字节，为什么?下面总结规律。

字节对齐 的细节和 编译器 实现相关，但一般而言，满足三个准则：

(1)结构体变量的 首地址能够被其 最宽基本类型成员 的大小所整除

(2) 结构体 每个成员相对于结构体首地址的偏移量 （offset）都是成员大小的整数倍，如有需要编译器 会在成员之间加上填充字节

(3)结构体的总大小为结构体 最宽基本类型成员大小的整数倍 ，如有需要编译器会在最末一个成员之后加上填充字节

对于上面的准则，有几点需要说明：

1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏移量了呢？因为有了第1点存在，所以我们就可以只考虑成员的偏移量，这样思考起来简单。想想为什么。

结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得，这个宏也在stddef.h中定义，如下：

#defineoffsetof(s,m)(size_t)&(((s*)0)->m)

例如，想要获得S2中c的偏移量，方法为

size_t pos = offsetof(S2, c); //pos等于4

2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型，这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型，比如另外一个结构体，所以在寻找最宽基本类型成员时，应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。

这里叙述起来有点拗口，思考起来也有点挠头，还是让我们看看例子吧（具体数值仍以VC6为例，以后不再说明）

struct S3
{
char c1;
S1 s;
char c2;
};

S1的最宽简单成员的类型为int，S3在考虑最宽简单类型成员时是将S1“打散”看的，所以S3的最宽简单类型为int，这样，通过S3定义的变量，其存储空间首地址需要被4整除，整个sizeof(S3)的值也应该被4整除。

c1的偏移量为0，s的偏移量呢？这时s是一个整体，它作为结构体变量也满足前面三个准则，所以其大小为8，偏移量为4，c1与s之间便需要3个填充字节，而c2与s之间就不需要了，所以c2的偏移量为12，算上c2的大小为13，13是不能被4整除的，这样末尾还得补上3个填充字节。最后得到sizeof(S3)的值为16。

通过上面的叙述，我们可以得到一个公式：

结构体的大小 = 最后一个成员的偏移量加上其大小再加上末尾的填充字节数目 ，即：

sizeof(struct) = offsetof(lastitem) + sizeof(lastitem) + sizeof(trailingpadding)

4-3) pack指令--调整结构体对齐方式

到这里，朋友们应该对结构体 的sizeof有了一个全新的认识，但不要高兴得太早，有一个影响sizeof的重要参量还未被提及，那便是编译器 的pack指令。它是用来调整结构体对齐方式的，不同编译器 名称和用法略有不同，VC6中通过#pragma pack实现，也可以直接修改/Zp编译开关。#pragma pack的基本用法为：

#pragma pack(n)

n为字节对齐数，其取值为1、2、4、8、16，默认是8，如果这个值比结构体成员的sizeof值小，那么 该成员的偏移量 应该以此值为准，即是说，结构体 成员的偏移量应该取二者的最小值，

公式如下： offsetof(item)=min(n, sizeof (item)； 再看示例：

#pragma pack(push)//将当前pack设置压栈保存
#pragma pack(2)//必须在结构体定义之前使用
struct S1
{char c; int i;};
struct S3
{char c1;S1 s;char c2;};
#pragma pack(pop)//恢复先前的pack设置

计算sizeof(S1)时，min(2, sizeof(i))的值为2，所以i的偏移量为2，加上sizeof(i)等于6，能够被2整除，所以整个S1的大小为6。 同样，对于sizeof(S3)，s的偏移量 为2，c2的偏移量为8，加上sizeof(c2)等于9，不能被2整除，添加一个填充字节，所以sizeof(S3)等于10。

4-4) 空结构体

还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。试想一个“不占空间”的变量如何被取地址、两个不同的“空 结构体”变量又如何得以区分呢于是，“空 结构体”变量也得被存储，这样编译器也就只能为其分配一个字节的空间用于占位了。

如下：

struct S5 { }; sizeof( S5 ); // 结果为1

4-5) 含位域结构体的sizeof

前面已经说过，位域成员不能单独被取sizeof值，我们这里要讨论的是含有位域的 结构体的sizeof，只是考虑到其特殊性而将其专门列了出来。

C99规定int、unsigned int和bool可以作为位域类型，但编译器几乎都对此作了扩展，允许其它类型类型的存在。使用位域的主要目的是压缩存储，其 大致规则为 ：

1) 如果相邻 位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止；

2) 如果相邻 位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍；

3) 如果相邻的 位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式，Dev-C++采取压缩方式；

4) 如果 位域字段之间穿插着非位域字段，则不进行压缩 ；

5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。

还是让我们来看看例子。

示例1：

struct BF1
{
  char f1:3;
  char f2:4;
  char f3:5;
};

其内存布局为：

|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|

0 3 7 8 1316

位域类型为char，第1个字节仅能容纳下f1和f2，所以f2被压缩到第1个字节中，而f3只 能从下一个字节开始。因此sizeof(BF1)的结果为2。

示例2：

struct BF2
{
  char f1:3;
  shor tf2:4;
  char f3:5;};

由于相邻位域类型不同，在VC6中其sizeof为6，在Dev-C++中为2。

示例3：

struct BF3
{
  char f1:3;
  char f2;
  char f3:5;};

非位域字段穿插在其中，不会产生压缩，在VC6和Dev-C++中得到的大小均为3。

5 ) 联合的sizeof

结构体在内存组织上是顺序式的， 联合体则是重叠式，各成员共享一段内存 ，所以整个联合体的sizeof也就是每个成员sizeof的最大值。结构体 的成员也可以是复合类型，这里，复合类型成员是被作为整体考虑的。

所以，下面例子中，U的sizeof值等于sizeof(s)。

union U
{
  int i;
  char c;
  S1 s;
};

6 ) 枚举的sizeof

在C/C++中，枚举是一个被命名的整型常数的集合。

例：

enum en
{
  e1,
  e2
}_en;

sizeof(_en);得到的值为4，一个整形占用的字节数

7 ) 类的sizeof

7-1) 空类

7-2) 类中包含成员

7-3) 类中包含虚函数

7-4) 子类

7-5) 子类和父类中都包含有虚函数

7-6) 虚继承的子类

7-7) 既有虚继承又有虚函数的子类

五：与strlen的区别

更新中。。。。