sizeof 让你不再模糊

0）printf( "%d\n",sizeof(1==1) );
1）printf( "%d\n",sizeof(1==1.1) );
2）printf( "%d\n",sizeof(1,10) );
3）printf( "%d\n",sizeof(1,1.1) );
4）printf( "%d\n",sizeof(1,1.1,10) );
int a=0;
5）printf("%d%d\n",sizeof(a=3.1)，a);
6）printf("%d\n",sizeof((3>1.1)?3:1));
7)printf("%d\n",sizeof((3>1)?3:1.1));
8）printf("%d\n",sizeof(char *));
9）printf("%d\n",sizeof(int **));
在Ubuntu上的答案：
4
4
4
8 
4
4 0 
8
8
4
4




0）1）都是一样 返回一个int型的0或者1
5）不会对表达式进行计算，就算他复制给我a,a也是int类型
6）7）不论你最终结果是哪个类型，符合操作符最后还是会取占地大的
2）3）4）都是逗号操作符去后面一个；
8）9）都是指针所以都是4


sizeof是C/C++中的一个操作（operator)符，简单的说其作用就是返回一个对象或者类型所占的内存字节数。
不是一个函数，字节数的计算在程序编译时进行，而不是在程序执行的过程中才计算出来!
sizeof有三种语法形式，如下：
1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i ); // ok
sizeof i; // ok
sizeof( int ); // ok
sizeof int; // error
既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，第3种写法，忘掉它吧！
实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，


同种类型的不同对象其sizeof值都是一致的


。这里，对象可以进一步延伸至表达式，即sizeof可以对一个表达式求值，


编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。
char arr[]="1234567";
char *pstr="1234567";
printf("%d\n",sizeof(arr));
printf("%d\n",sizeof(pstr));
printf("%d\n",sizeof(*pstr));
printf("%d\n",strlen(pstr));
还要sizeof结构体，就不说了。（对齐和补齐）
当然结构体的话可以用#pragma pack（num）来调整对齐的字节数
对齐的字节数=min（num,结构体中占地最大的）；
double* (*a)[3][6];
cout< cout< cout< cout< cout< 4a是一个很奇怪的定义，他表示一个指向 
double*[3][6]类型数组的指针。既然是指针，所以
sizeof(a)就是4。 
既然a是捆绑的是double*[3][6]类型的指针，*a就表示
一个double*[3][6]的多维数组类型，因此
sizeof(*a)= 3*6*sizeof(double*)=72。同样的，
**a表示一个double*[6]类型的数组，所以
sizeof(**a)=6*sizeof (double*)=24。***a就表示其
中的一个元素，也就是double*了，所以
sizeof(***a)=4。至于****a，就是一个 double了，所以
sizeof(****a)=sizeof(double)=8。
读懂指针需要掌握 1）他的类型 2）他的捆绑储存区（也就是他指向的储存区的内容）
简单来说就是两个方法1)去掉指针名字后就是他的类型  2)再去掉一个*号就是他的捆绑储存区
例如：int **p;    int(*p)()
（1）int**               int *
（2）int(*)()            int ();


其实可以把二维数组理解成数组指针，应为他们都可以相互赋值，用二级指针给二维数组赋值就不行
int a[3][4];
改写下形式，也许，你就懂了 int (a[3])[4];
a[0], a[1], a[2]    //他们都是int [4]的类型，都是4个int元素的首地址;
a   // 是 int [3] [4]的类型，它是a[0] , a[1], a[2] ，3个元素的首地址；


a + 1 就是&a[1] ,  a + 2 就是&a[2];
*(a + 1 ) + 2 就是 a[1] + 2, 也就是 &a[1][2],  于是 *( *(a + 1) + 2)  就是a[1][2]