sizeof

什么是sizeof

sizeof不是一个函数，你见过给一个函数传参数，而不加括号的吗？sizeof可以，所以sizeof不是函数。网上有人说sizeof是一元操作符，但是我并不这么认为，因为sizeof更像一个特殊的宏，它是在编译阶段求值的。

1 int a = 0;
2 cout<<sizeof(a=3)<<endl;
3 cout<<a<<endl;

这里有个陷阱，输出为什么是4，0而不是期望中的4，3？？？就在于sizeof在编译阶段处理的特性。由于sizeof不能被编译成机器码，所以sizeof作用范围内，也就是()里面的内容也不能被编译，而是被替换成类型。=操作符返回左操作数的类型，所以a=3相当于int

cout << sizeof("abcd") << endl;//5

“abcd”返回是字符串类型

用法

（1）sizeof(object) 或 sizeof object 也就是对对象使用sizeof，也可以写成sizeof object 的形式。例如：

（2）sizeof(typename) 也就是对类型使用sizeof，注意这种情况下写成sizeof typename是非法的。下面举几个例子说明一下：

1 int i = 2;
2 cout<<sizeof(i)<<endl; // sizeof(object)的用法，合理
3 cout<<sizeof i<<endl; // sizeof object的用法，合理
4 cout<<sizeof 2<<endl; // 2被解析成int类型的object, sizeof object的用法，合理
5 cout<<sizeof(2)<<endl; // 2被解析成int类型的object, sizeof(object)的用法，合理
6 cout<<sizeof(int)<<endl;// sizeof(typename)的用法，合理
7 cout<<sizeof int<<endl; // 错误！对于操作符，一定要加()

unsigned影响的只是最高位bit的意义，数据长度不会被改变的。

1 cout<<sizeof(unsigned int) == sizeof(int)<<endl; // 相等，输出 1

自定义类型的sizeof取值等同于它的类型原形。

对函数使用sizeof，在编译阶段会被函数返回值的类型取代

只要是指针，大小就是4。（64位机上要变成8也不一定）。

    char a[] = "abcdef";
    cout << sizeof(*a) << endl;//1

相比于这个

1 int *d = new int[10];
2 
3 cout<<sizeof(d)<<endl; // 4

d是我们常说的动态数组，但是他实质上还是一个指针，所以sizeof(d)的值是4。

计算普通变量

• int字节数跟语言无关，跟机器位长相同，32位机器是4字节，64位机器是8字节。数据类型的字节数应该是由CPU决定的，但是实际上主要由编译器决定(占多少位由编译器在编译期间说了算)，TC下，2个字节，WINNT是4个字节
• sizeof指针是4（32位）或者8（64位)

类对象

计算类的，而不计算对象的

• 结构体或者类对象（字节对齐）
  1. 首地址被其最宽基本类型成员大小整除（注意是基本类型成员）
  2. 相对于首地址偏移量都是基本成员大小(自身)的整数倍，要不填充字节
  3. 总大小为最宽基本类型成员大小的整数倍，要不填充字节（注意是基本类型成员）
  4. 对于类对象，不算静态成员，不算函数 如

struct s{
    char c1;
    int 1;
    char c2;
}
sizeof: 12

含有虚函数的类对象

• c++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。
• 普通对象不占用内存，只要有虚函数，就会占用一个指针大小的内存。一个隐含的虚表指针成员，并且，无论多少个虚函数都不会再影响类的大小
• 多继承会有多个虚函数表，就多个指针

虚拟继承的类对象大小

• 空类1个字节
• 静态变量在静态存储区，不计入大小
• 每一个虚继承，编译器会为该类安插一个指向父类的指针，多个虚拟继承，就多个指向父类的指针

其他

• sizeof和strlen区别
  1. sizeof是操作符，strlen是函数
  2. sizeof是size_t,unsigned int
  3. sizeof可以用类型做参数,strlen只用char*,以\0结尾
  4. sizeof接变量可以不加括弧，类型加括弧
• sizeof计算联合体 union对齐与struct一样，按最大的来，char[]和int ,按int对齐，取整数，如union{ char a[13];int a;}是最接近13的整数16
• #pragma pack(n)将对齐设置为n，编译器默认是8，所以每个成员使用自身的对齐. C++固有类型的对界取编译器对界方式（默认或指定)与自身大小中较小的一个.

复杂对象的计算

union的sizeof问题与cpu的对界

1 union u //8对齐
2 {
3   double a;
4   int b;
5 };
6 
7 union u2 //4对齐
8 {
9   char a[13];
10   int b;
11 };
12 
13 union u3 //1对齐
14 {
15   char a[13];
16   char b;
17 };
18 
19 cout<<sizeof(u)<<endl;  // 8
20 cout<<sizeof(u2)<<endl;  // 16
21 cout<<sizeof(u3)<<endl;  // 13

都知道union的大小取决于它所有的成员中，占用空间最大的一个成员的大小。所以对于u来说，大小就是最大的double类型成员a了，所以sizeof(u)=sizeof(double)=8。但是对于u2和u3，最大的空间都是char[13]类型的数组，为什么u3的大小是13，而u2是16呢？关键在于u2中的成员int b。由于int类型成员的存在，使u2的对齐方式变成4(4字节对齐)，也就是说，u2的大小必须在4的对界上，所以占用的空间变成了16（最接近13的对界）。

结论：复合数据类型，如union，struct，class的对齐方式为成员中对齐方式最大的成员的对齐方式。

1 struct s1
2 {
3   char a;
4   double b;
5   int c;
6   char d; 
7 };
8 
9 struct s2
10 {
11   char a;
12   char d;
13   int c;
14   double b;
15 };
16 
17 cout<<sizeof(s1)<<endl; // 24
18 cout<<sizeof(s2)<<endl; // 16

对于s1，首先把a放到8的对界，假定是0，此时下一个空闲的地址是1，但是下一个元素d是double类型，要放到8的对界上，离1最接近的地址是8了，所以d被放在了8，此时下一个空闲地址变成了16，下一个元素c的对界是4，16可以满足，所以c放在了16，此时下一个空闲地址变成了20，下一个元素d需要对界1，也正好落在对界上，所以d放在了20，结构体在地址21处结束。由于s1的大小需要是8的倍数，所以21-23的空间被保留，s1的大小变成了24。

对于s2，首先把a放到8的对界，假定是0，此时下一个空闲地址是1，下一个元素的对界也是1，所以b摆放在1，下一个空闲地址变成了2；下一个元素c的对界是4，所以取离2最近的地址4摆放c，下一个空闲地址变成了8，下一个元素d的对界是8，所以d摆放在8，所有元素摆放完毕，结构体在15处结束，占用总空间为16，正好是8的倍数。

1 struct s1
2 {
3   char a[9];
4 };

注意这个是1对齐，所以sizeof是9

这里有个陷阱，对于结构体中的结构体成员，不要认为它的对齐方式就是他的大小

1 struct s1
2 {
3   char a[9];
4 };
5 
6 struct s2
7 {
8   double d;
9 };
10 
11 struct s3
12 {
13   s1 s;
14   char a;
15 };
16 
17 struct s4 //s1为1对齐，大小为9
18 {
19 
20     s1 s;
21     double d;
22 };
23 
24 struct s5
25 {
26   s2 s;
27   char a; 
28 };
29 
30 
31 
32 cout << sizeof(s1) << endl; // 9
33 cout << sizeof(s2) << endl; // 8
34 cout << sizeof(s3) << endl; // 10
35 cout << sizeof(s4) << endl; // 24
36 cout << sizeof(s5) <<endl; //16