sizeof

sizeof的常量性

• 常量性的概念：简单的说就是编译的时候就可以确定他的值了，就好像是const一样

  在一些老式的编译器里面你是不能够声明一个不确定大小的数组的，也就是说以下写法是错误的：
  int n = 10; int a[n] = {};
  这样子却是可以的：
  const int n = 10; int a[n] = {};
  原因就是const声明的变量是在编译的时候就已经确定好了，大小不允许改变，就是说经过了编译期之后，你的代码变成了这个样子：
  int a[10] = {}
  那么又回到了上面的问题，sizeof在编译的时候就确定了他的值，所以：
  int a[sizeof(int)] = {};
  这句话是完全没有错误的

sizeof基本数据类型

在一般的32位操作系统中
sizeof(bool)->1
sizeof(char)->1
sizeof(short)->2
sizeof(int)->4
sizeof(float)->4
sizeof(double)->8

sizeof数组和指针

• 数组

  sizeof(数组)就是这个数组的所有元素占用内存空间的总和
  在32位操作系统中，
  int a[10] = {}; // sizeof(a)->10*sizeof(int)->40

• 指针

  指针和数组很多新手一开始混淆两者的概念，来个比较简单形象的解释就是指针就是指向了某段内存但没有包含这段内存，而数组包含了整段内存
  所以sizeof(指针)仅仅是这个指针在内存中占有的空间，不包括指针指向的整段内存所占用的空间
  在32位操作系统中?????
  int* a; bool** b; // sizeof(a) = sizeof(b) = 4

这里看一个坑：(网上找来的)

int myfun(int a[10]) {return sizeof(a);
}
int main() {int a[10] = {};printf("%d\n", myfun(a));
}

如果你会觉得返回10，那你就错咯，编译器会输出8。8是怎么来的呢，很简单，就是在64位操作系统下的指针占用内存大小，这个时候你大概有点明白了吧～myfun函数传进去的参数实际上不是整个数组吧，而只是一个指向数组头的指针，这个指针大小仅仅是8而已。

结构体

这大概能算是sizeof里面比较难的的了

offsetof(struct, vari)是返回vari离struct的偏离量
先看一个例子

    #include<stdio.h>#include<stddef.h>#define s sizeofstruct student {char a;short a2;int b[10];float c;double d;short d2;} stu1;int main() {printf("%d\n", s(stu1));printf("\n");printf("%d\n", s(stu1.a));printf("%d\n", s(stu1.a2));printf("%d\n", s(stu1.b));printf("%d\n", s(stu1.c));printf("%d\n", s(stu1.d));printf("%d\n", s(stu1.d2));printf("\n");printf("%d\n", offsetof(struct student, a));printf("%d\n", offsetof(struct student, a2));printf("%d\n", offsetof(struct student, b));printf("%d\n", offsetof(struct student, c));printf("%d\n", offsetof(struct student, d));printf("%d\n", offsetof(struct student, d2));}// 输出如下641240482024444856

估计看了这个还是一脸蒙蔽(什么！明明是看了才会一脸MB)
为了更好的理解struct这个东西的内部构造，你首先要知道对齐这个概念，就是说struct里面的结构不会是一沓书那样堆积起来，而是有些书会悬浮，没错，你可以理解为悬浮。这种效果在struct里面就叫做对齐啦
好的，接下来，我引入百科到的对齐规则：
1. 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2. 结构体每个成员相对于结构体首地址的偏移量(offset)都是每个成员大小的整数倍，如有需要编译器会在成员之间加上填充字节(internal adding)；
3. 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节(trailing padding)。
最宽基本类型是看单个的，也就是说数组只会看一个元素，结构体会打散看最大的哪个元素
现在尝试分析上面的例子，一开始char是1字节，偏移量为0；第二个short是2字节，那么根据第二条规则，偏移量是2；第三个是int[10]数组，占用4*10字节，根据最宽基本类型是看单个的原则，偏移量就是int的整数倍，那就是4；float占用4个字节，偏移量是44；double占用8个字节，偏移量是48；short占用2的字节，偏移量是56，那最后64是怎么得到的？56+2=58并不能整除最宽成员大小8，所以取最接近的64就ok啦。

再来看一个结构体包含结构体的例子把～

    struct S1{char c;int i;};struct S2{char c1;S1 s;char c2};

这时候sizeof(S2)->16
首先sizeof(s)->8，然后注意了，S2里面的最宽类型大小不是sizeof(s)而是S1里面最宽的一个元素int->4。S2第一个元素：c1偏移量为0，大小是1。s偏移量是4，大小是8。c2偏移量是12，大小是1。12+1=13不能整除4，所以取最接近的16。

然而事情并没有你想的那么简单，编译器算出的sizeof还与另外一个东西有关，那就是pack指令，pack指令可以控制偏移量，那么偏移量就会取pack指令的那个标准偏移量和item字节大小的较小的那个
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设置

联合体

联合体比较简单，就是取联合体内最大的那个元素占有的字节大小就好了

    union U {int i;char c;}; // sizeof(U)->sizeof(i)

以上内容属个人理解，难免会有错误，如有错误，请各位大神帮忙纠正，不甚感激！