C\C++

1.定义

MSDN上的解释为：

The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types).

This keyword returns a value of type size_t.

其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为：

typedef unsigned int size_t;

2. 语法

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

1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;

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

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); }

3. 指针变量的sizeof

 

char* pc = "abc";int* pi;string* ps;char** ppc = &pc;void (*pf)(); // 函数指针sizeof( pc ); // 结果为4sizeof( pi ); // 结果为4sizeof( ps ); // 结果为4sizeof( ppc ); // 结果为4sizeof( pf ); // 结果为4

 

 

4. 数组的sizeof

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

char a1[] = "abc";int a2[3];sizeof( a1 ); // 结果为4，字符串末尾还存在一个NULL终止符sizeof( a2 ); // 结果为3*4=12（依赖于int）

void foo3(char a3[3]){    int c3 = sizeof( a3 ); // c3 == 4}void foo4(char a4[]){    int c4 = sizeof( a4 ); // c4 == 4}

5. 结构体的sizeof

结构体的sizeof需要注意的一点是字节对齐

struct S1{    char c;    int i;};sizeof(S1);// 8

 

struct S3{    char c1;    S1 s;    char c2;};sizeof(S3);//16

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

空结构体的大小不为0，而是1

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

 

6. 联合体的sizeof

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

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

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

7.类的sizeof

(1) 对于用sizeof()来测试类的大小，要注意一下几点，一就是空类的大小，当一个类中没有变量同时也没有虚函数时，其大小为1

例如：

class X{};X x;cout<<sizeof(x)<<endl;

其结果为1；

这是因为当我们实例化一个类对象时，就是为其分配内存空间，并且每一个实例化的类都会有一个独一无二的内存地址，空类也不例外，必须为其分配一个内存，因此编译器给分配了一个字节的内存，使其独一无

(2)对于一般的类来说：其还有一下两个原则：

a.对齐原则. 当一个类里有个数据类型占字节数最大时, 其他数据类型大小和最大的对齐. 比如:

class classA{char a;int b;double c;// int d;};

这里double最大,占八个字节, char 和 int 要和八个字节对齐, 两个加起来不到八个字节算成八个字节,所以sizeof(classA)=16, (如果不注释d, 两个int就是八个字节了,所以sizeof(classA)=24, char补上了七个字节,凑够八个,加上两个int和一个double).

b.虚函数指针.虚函数指针占四个字节,但不适用上面的对齐原则,它要拿出来单独处理.比如:

class classB{char a;// double b;// int c;virtual func1(){} };

因为虚函数指针占了四个字节,char占了一个字节,安照对齐原则,sizeof(classB)=8, 如果去掉注释int c,那就变成了12. 但,注意如果现在注释int c,而去掉double b的注释,guess what's it? 按一般来说,应该是16,一个double加char和一个指针,补足16位,但实际上是24,因为指针是单独拿出来算了,这就变成了double,加上char补足的八位,加上指针补足的八位,一共是24个字节了.

8.子类的sizeof

class A2{      public:             int a;      private:              char b;};class A3:public A2{      public:             char b;             short a;             };sizeof(A3)是8. 但如果A3如下：class A3:public A2{      public:             short a;               char b;           };sizeof(A3)是12.

9.子类和父类都有虚函数情况，子类的sizeof是它父类成员（无论成员是public或private)，再加上它自己的成员，对齐后的sizeof，再加4（虚表指针）

class Base{      public:             Base(){cout<<"Base-ctor"<<endl;}             ~Base(){cout<<"Base-dtor"<<endl;}             int a;             virtual void f(int) {cout<<"Base::f(int)"<<endl;}             virtual void f(double){cout<<"Base::f(double)"<<endl;}};class Derived:public Base{  public:         Derived(){cout<<"Derived-ctor"<<endl;}         int b;         virtual void g(int){cout<<"Derived::g(int)"<<endl;}};sizeof(Derived)是12.

10.对于虚继承的子类，其sizeof的值是其父类成员，加上它自己的成员，以及它自己一个指向父类的指针，对齐后的sizeof

#include   <iostream.h>         class   a     {     private:     int   x;     };                 class   b:   virtual   public   a     {     private:     int   y;     };         class   c:   virtual   public   a     {     private:     int   z;     };         class   d:public   b,public   c     {     private:     int   m;     };     int   main(int   argc,   char*   argv[])     {     cout<<sizeof(a)<<endl;     cout<<sizeof(b)<<endl;     cout<<sizeof(c)<<endl;     cout<<sizeof(d)<<endl;     return   0;     }     

调试结果为   
  4   
  12   
  12   
  24

sizeof(b)和sizeof(c)相同，都是4+4+4=12。

sizeof(d)是sizeof(b)(为12)+sizeof(c)(为12）-b和c相同的部分（a的成员，大小是4）+d自己的成员（大小为4）=24

11.对于既有虚继承又有虚函数的子类，其sizeof的值是其父类成员（计算虚表指针大小+4），加上它自己的成员（计算虚表指针大小+4），以及它自己一个指向父类的指针（大小为4），对齐后的sizeof

class Base{public: Base(){cout<<"Base-ctor"<<endl;} ~Base(){cout<<"Base-dtor"<<endl;} virtual void f(int) {cout<<"Base::f(int)"<<endl;}virtual void f(double){cout<<"Base::f(double)"<<endl;}};class Derived:virtual public Base{public: Derived(){cout<<"Derived-ctor"<<endl;} virtual void g(int){cout<<"Derived::g(int)"<<endl;}};

sizeof（Base）=4

sizeof（Derived）=12 （父类虚表指针大小4+自己虚表指针大小4+子类指向父类的一个指针大小4=12)