sizeof的用法，在C，C++语言笔试面试中常见问题

(以下讨论针对32位系统)  

1，基本数据类型 

cout<<sizeof(char)<<endl;                     

结果是1

cout<<sizeof(int)<<endl;                        

结果是4

cout<<sizeof(unsigned int)<<endl;

结果是4 

cout<<sizeof(long int)<<endl;                

结果是4 

cout<<sizeof(short int)<<endl;               

结果是2

cout<<sizeof(float)<<endl;                     

结果是4 

cout<<sizeof(double)<<endl;               

结果是8

2，指针变量 

指针变量的sizeof的值与指针所指的值没有任何关系，所以指针变量的内存大小都是相等的，如：

int* a;

char* b="uestc";

char** c=&b;

sizeof(a)==sizeof(b)==sizeof(c)==4;

但是

sizeof(*a)=4;

sizeof(*b)=1;

sizeof(*c)=4;

sizeof(**c)=1;

3,数组的大小 

数组的sizeof值等于数组所占用的内存字节数 

char a1[] = "abc";

int a2[3];

sizeof( a1 ); // 结果为4，字符串末尾还存在一个NULL终止符

sizeof( a2 ); // 结果为3*4=12（依赖于int）

但是，当数组作为函数参数的时候呢？这时候，数组是传地址的，即这时用指针来处理 ，所以，如果有：

void foo(char a[])

{

int b= sizeof( a ); // b == 4

}

所以，这时候，a的类型为char*，而sizeof(char*)==4; 

4,联合体和结构体 

联合体： 

union a{int a;char b;float c;};

由于联合体公用储存空间，所以只取最大的来计算联合体占用空间，这里sizeof(a)==4;

结构体： 

比较麻烦，注意3点：

1，首地址应为结构中最宽成员的倍数，首成员都是0  

2，整个结构体长度应为最宽成员的倍数 

3，把单一元素看成结构体

如,

struct a{double a;char b;int c;};

sizeof(a)==8+1+3+4==12;

这里，先分配double，首地址为8的倍数0，再分配char，这时其偏移量为8，为1的倍数，再分配int，其偏移量为9，不是4的倍数，应该用3个空字节补齐，所以int的偏移为9+3=12，再加上4=16，这时16为最宽成员8的倍数，所以该结构体的长度为16。

当结构体中包含结构体时，最宽成员不包括内部结构体，最宽成员应从这两个结构体的基础成员中去找。

struct A{char a;int b;}; 

sizeof(A)==8; 

sturct B{char a; A b;char c};

sizeof(B)==16;

把内部结构体打开来看，分配char为1，再分配A，A中最宽成员为4，则其起始偏移应为最宽的倍数，1+3=4，4+8=12，再分配char，这时，其偏移为12，是char的倍数，12+1=13，根据规则2，再用3来补齐，13+3=16，是int的倍数，所以结构体B的长度为16.

5，类的sizeof大小 

1，空类大小为1

2，虚函数大小为4，构造析构不算大小

3，类大小等于所有数据成员大小之和

4，继承中类大小等于父类和子类的数据成员大小之和

#include<iostream>
using namespace std;
void test_v1()
{
int *a;
char *b="uestc";
char **c=&b;
cout<<"sizeof(a)= "<<sizeof(a)<<'n';
cout<<"sizeof(b)= "<<sizeof(a)<<'n';
cout<<"sizeof(c)= "<<sizeof(a)<<'n';
cout<<"--------------------------------n";
cout<<"*a= "<<*a<<'n';
cout<<"sizeof(*a)= "<<sizeof(*a)<<'n';
cout<<"*b= "<<*b<<'n';
cout<<"sizeof(*b)= "<<sizeof(*b)<<'n';
cout<<"*c= "<<*c<<'n';
cout<<"sizeof(*c)= "<<sizeof(*c)<<'n';
cout<<"**c= "<<**c<<'n';
cout<<"sizeof(**c)= "<<sizeof(**c)<<'n';
}
/******************************************
test_v1()运行结果：
sizeof(a)= 4
sizeof(b)= 4
sizeof(c)= 4
--------------------------------
*a= 2293608
sizeof(*a)= 4
*b= u
sizeof(*b)= 1
*c= uestc
sizeof(*c)= 4
**c= u
sizeof(**c)= 1
*******************************************/
void test_fun(char A[],int B[])
{
cout<<"sizeof(A)= "<<sizeof(B)<<'n';
cout<<"sizeof(B)= "<<sizeof(B)<<'n';
}
void test_v2()
{
char code[]="trust";
int future[]={2,5,0};
test_fun(code,future);
}
/******************
运行结果：
sizeof(A)= 4
sizeof(B)= 4
********************/
void test_v3()
{
union union_a{int a;char b;float c;};
cout<<"sizeof(union_a)= "<<sizeof(union_a)<<'n';
}
/********************
运行结果：
sizeof(union_a)= 4
*********************/
void test_v4()
{
struct struct_a{double a;char b;int c;};
cout<<"sizeof(struct_a)= "<<sizeof(struct_a)<<'n';
}
/*********************
运行结果:
sizeof(struct_a)= 16
**********************/
void test_v5()
{
struct struct_A{char a;int b;};
cout<<"sizeof(struct_A)= "<<sizeof(struct_A)<<'n';
struct b{char a;struct_A b;char c;};
cout<<"sizeof(b)= "<<sizeof(b)<<'n';
}
/*****************************
运行结果：
sizeof(struct_A)= 8
sizeof(b)= 16
******************************/
void test_v6()
{
class empty{};
cout<<"sizeof(empty) = "<<sizeof(empty)<<'n';
}
/******************
运行结果：
sizeof(empty) = 1
********************/
int main()
{
//test_v1();
//test_v2();
//test_v3();
//test_v4();
//test_v5();
test_v6();
}