sizeof计算类的大小

待我称王封你为后i 2022-08-06 11:10 221阅读 0赞

关于sizeof与strlen的部分内容参考[该文章][Link 1]

# 先看一个空的类占1字节？ #

class Base  
        {  
        public:  
            Base();  
            ~Base();  
          
        };

注意到我这里显示声明了构造跟析构，但是sizeof(Base)的结果是1.

因为一个空类也要实例化，所谓类的实例化就是在内存中分配一块地址，每个实例在内存中都有独一无二的地址。同样空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。

而析构函数，跟构造函数这些成员函数，是跟sizeof无关的，也不难理解因为我们的sizeof是针对实例，而普通成员函数，是针对类体的，一个类的成员函数，多个实例也共用相同的函数指针，所以自然不能归为实例的大小。

## C语言中空struct的大小 ##

我们知道，在C++中struct和class的含义很类似，那么在C++中一个空的struct和如上的空class一样吗，其大小也是1吗？在C语言中空的struct的大小又是多少？

如下代码：

//C++语言
    #include <iostream>
    using namespace std;
    
    class A {};
    struct B {};
    int main() {
      cout << sizeof(A) << endl;  //1
      cout << sizeof(B) << endl;  //1
    }

//C语言
    #include <stdio.h>
    
    typedef struct A{
    }a;
    int main() {
      printf("%d\n", sizeof(a)); //在gcc下输出0，VS2010下提示错误
    }

对于C++而言，因为struct和class的相似性，很容易知道空struct大小为1（在gcc和VS2010都是）。但是，在C语言中，VS2010中会提示“C要求一个结构体或联合至少有一个成员”，而gcc却输出结果为0.

接着看下面一段代码

class Base  
        {  
        public:  
            Base();                  
            virtual ~Base();         //每个实例都有虚函数表，虚表指针占4个字节 
            void set_num(int num)    //普通成员函数，为各实例公有，不归入sizeof统计  
            {  
                a=num;  
            }  
        private:  
            int  a;                  //占4字节  
            char *p;                 //4字节指针  
        };  
          
        class Derive:public Base  
        {  
        public:  
            Derive():Base(){};       
            ~Derive(){};  
        private:  
            static int st;         //非实例独占  
            int  d;                     //占4字节  
            char *p;                    //4字节指针  
          
        };  
          
        int main()   
        {   
            cout<<sizeof(Base)<<endl;  
            cout<<sizeof(Derive)<<endl;  
            return 0;  
        }

结果自然是

Base类里的int a;char \*p;占8个字节。

而虚析构函数virtual ~Base();，虚表的指针占4子字节。

其他成员函数不归入sizeof统计。

Derive类首先要具有Base类的部分，也就是占12字节。

int d;char \*p;占8字节

static int st;不归入sizeof统计

所以一共是20字节。

在考虑在Derive里加一个成员char c;

class Derive:public Base  
        {  
        public:  
            Derive():Base(){};  
            ~Derive(){};  
        private:  
            static int st;  
            int  d;  
            char *p;  
            char c;  
          
        };

这个时候，结果就变成了

一个char c;增加了4字节，说明类的大小也遵守类似class字节对齐，的补齐规则。

另外注意，**不同编译器对字节对齐的处理不尽相同**：

#include <iostream>
    using namespace std;
    
    class test {
    public:
    	test() {
    		cout << "gouzao" <<endl;
    	}
    	~test() {
    		cout << "xigou" << endl;
    	}
    private:
    	double a;
    	char b;
    };
    
    int main() {
    	cout << sizeof(test) << endl;
    }

上面程序在VS2010下运行结果为16，而在G++下运行结果为12.

# 虚继承的类大小 #

class Top {};
    class Left: public virtual Top {};
    class Right: public virtual Top {};
    class Bottom: public Left, Right {};

在VS2010和g++下，类大小都依次为：1，4，4，8

文章[C++模型：第2章-构造函数语意学][C_2_-]，中情况4是一个虚继承的例子，该例子中Left类和Right类虚继承类Top，而Buttom类继承了Left和Top，代码如下：

#include <iostream>
    #include <string>
    using namespace std;
    
    class Top {
    public:
    	Top():a(1) {}
    	int a;
    };
    
    class Left: virtual public Top {
    public:
    	Left(): b(2) {}
    	int b;
    };
    
    class Right: virtual public Top {
    public:
    	Right():c(3){}
    	int c;
    };
    
    class Buttom: public Left, public Right {
    public:
    	Buttom(): d(4){}
    	int d;
    };
    
    int main() {
            //这里输出类的大小，分别为4,12,12,24
            cout << sizeof(Top) << " " << sizeof(Left) << " " << sizeof(Right) << " " <<sizeof(Buttom) << endl;
    }

内存布局参考： [C++对象模型：多重继承和虚继承的内存布局][C]

至此，我们可以归纳以下几个原则：

**1.类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑。**

C++将类的非静态数据成员存放在类的每个对象中，对于继承而来的非静态数据成员（不管基类是否为虚）都是如此。

**静态数据成员**不是类的组成部分，它存放在程序的全局数据区中，独立于任何类的对象而存在，不会影响类对象的大小；类无论产生多少对象，**static数据成员都仅存在一份实例**；静态数据成员不在类的对象中，因此存取static数据成员不需要通过类对象，例如可以直接使用Top类的静态数据成员val\_static：

cout << Top::val_static << endl;

如果取静态数据成员val\_static的地址，会得到一个指向其数据类型的指针，而不是一个指向其类成员的指针，因为静态数据成员并不内含在任何一个类对象中：

&Top::val_static; //取类的静态数据成员的地址会获得类型如下的内存地址：
    const int *

而**非静态数据成员**直接存放在每个类对象中，除非经由显示或隐式类对象，否则无法直接存取它们。只要程序员在一个成员函数中直接处理一个非静态数据成员，即隐式类对象就会发生。如成员函数add( const Top &pt)：

Top Top::add(const Top &pt) {
        x += pt.x;
    }

表面上对x是直接存取的，但是实际上是通过“隐式类对象”（this指针）完成的：

Top Top::add(Top * const this const Top &pt) {
        this->x += pt.x;
    }

要对一个非静态数据成员存取，编译器需要把类对象的起始地址加上该数据成员的偏移位置，例如：

Top top;
    top.x = 1;
    //那么地址&top.x将等于：&top + (&Top::x)

**2.普通成员函数与sizeof无关。**

类的普通成员、静态成员函数是不占类内存的，至于你说的函数指针在你的类中有虚函数的时候存在一个虚函数表指针，也就是说如果你的类里有虚函数则 sizeof(CObject)的值会增加4个字节。**其实类的成员函数 实际上与普通的全局函数一样**。 只不过编译器在编译的时候，会在成员函数上加一个参数，传入这个对象的指针。**成员函数地址是全局已知的，对象的内存空间里根本无须保存成员函数地址**。 对成员函数(非虚函数)的调用在编译时就确定了。 像 myObject.Fun() 这样的调用会被编译成形如 \_CObject\_Fun( &myObject ) 的样子。函数是不算到sizeof中的，因为函数是代码，被各个对象共用，跟数据处理方式不同。对象中不必有函数指针，因为对象没必要知道它的各个函数的地址（调 用函数的是其他代码而不是该对象）。 类的属性是指类的数据成员，他们是实例化一个对象时就为数据成员分配内存了，而且**每个对象的数据成员是对立的，而成员函数是共有的**。静态成员函数与一般成员函数的唯一区别就是没有this指针，因此不能访问非静态数据成员。总之，程序中的所有函数都是位于代码区的。

**3.虚函数由于要维护在虚函数表，所以要占据一个指针大小，也就是4字节。**

**4.类的总大小也遵守类似class字节对齐的，调整规则。**

**5.如果子类中也含有虚函数，那么它不会有自己的虚表，而是和基类公用，因此派生类的大小不包含派生类虚表所占用的空间。**

\------------------------------------------------------------------------------------------------------------

# [C++ 虚函数表解析][C_] #

**C++ 虚函数表解析**

**陈皓**

[http://blog.csdn.net/haoel][http_blog.csdn.net_haoel]

# 前言 #

C++中的虚函数的作用主要是实现了多态的机制。关于**多态**，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓**泛型技术**，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家一个清晰的剖析。

当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。

言归正传，让我们一起进入虚函数的世界。

# 虚函数表 #

对C++了解的人都应该知道**虚函数（Virtual Function）是通过一张虚函数表（Virtual Table，V-Table）来实现的**。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，**当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数**。

这里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。没关系，下面就是实际的例子，相信聪明的你一看就明白了。

假设我们有这样的一个类：

class Base {
         public:
                virtual void f() { cout <<"Base::f" << endl; }
                virtual void g() { cout <<"Base::g" << endl; }
                virtual void h() { cout <<"Base::h" << endl; }
     
    };

按照上面的说法，我们可以通过Base的实例来得到虚函数表。下面是实际例程：

typedef void(*Fun) (void);
    Base b;
    Fun pFun = NULL;
     
    cout << "虚函数表地址：" << (int*)(&b) << endl;
    cout << "虚函数表 —第一个函数地址：" << (int*)*(int*)(&b) << endl;
     
    // Invoke the first virtual function 
    pFun = (Fun)*((int*)*(int*)(&b));
    pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int \*，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int\*强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0); // Base::f()
    (Fun)*((int*)*(int*)(&b)+1); // Base::g()
    (Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

![o_vtable1.jpg][]

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“/0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

# 一般继承（无虚函数覆盖） #

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

![o_Drawing3.jpg][]

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d;的虚函数表如下：

![o_vtable2.JPG][]

我们可以看到下面几点：

**1）虚函数按照其声明顺序放于表中。**

**2）父类的虚函数在子类的虚函数前面。**

我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。

# 一般继承（有虚函数覆盖） #

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

![o_Drawing4.jpg][]

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

![o_vtable3.JPG][]

我们从表中可以看到下面几点，

**1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。**

**2）没有被覆盖的函数依旧。**

这样，我们就可以看到对于下面这样的程序，

Base \*b = new Derive();

b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

# 多重继承（无虚函数覆盖） #

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

![o_Drawing1.jpg][]

对于子类实例中的虚函数表，是下面这个样子：

![o_vtable4.JPG][]

我们可以看到：

**1）  每个父类都有自己的虚表。**

**2）  子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）**

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

# 多重继承（有虚函数覆盖） #

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

![o_Drawing2.jpg][]

下面是对于子类实例中的虚函数表的图：

![o_vtable5.jpg][]

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

Derive d;
                Base1 *b1 = &d;
                Base2 *b2 = &d;
                Base3 *b3 = &d;
                b1->f();       //Derive::f()
                b2->f();       //Derive::f()
                b3->f();       //Derive::f()
     
                b1->g();       //Base1::g()
                b2->g();       //Base2::g()
                b3->g();       //Base3::g()

# [多重继承和虚继承的内存布局][Link 2] #

# 安全性 #

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

**一、通过父类型的指针访问子类自己的虚函数**

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为**多态也是要基于函数重载的**。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

Base1 \*b1 =  new Derive();

b1->f1(); //编译出错

任何妄图使用父类指针想调用子类中的**未覆盖父类的成员函数**的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们**可以通过指针的方式访问虚函数表来达到违反C++语义的行为**。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

**二、访问non-public的虚函数**

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

如：

class Base {
        private:
                virtual void f() { cout <<"Base::f" << endl; }
    };
     
    class Derive : public Base{
    };
     
    typedef void(*Fun)(void);
     
    void main() {
        Derive d;
        Fun  pFun = (Fun)*((int*)*(int*)(&d)+0);
        pFun();
    }

# 结束语 #

C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己脚的编程语言。

在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了，目前是软件开发技术主管，技术方面，主攻Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax等一切和互联网相关的东西。管理方面比较擅长于团队建设，技术趋势分析，项目管理。欢迎大家和我交流，我的MSN和Email是：[haoel@hotmail.com][haoel_hotmail.com]

# 附录一：VC中查看虚函数表 #

我们可以在VC的IDE环境中的Debug状态下展开类的实例就可以看到虚函数表了（并不是很完整的）

![o_vtable_vc.JPG][]

# 附录 二：例程 #

下面是一个关于多重继承的虚函数表访问的例程：

\#include <iostream>

using namespace std;

class Base1 \{

public:

virtual void f() \{ cout <<"Base1::f" << endl; \}

virtual void g() \{ cout <<"Base1::g" << endl; \}

virtual void h() \{ cout <<"Base1::h" << endl; \}

\};

class Base2 \{

public:

virtual void f() \{ cout <<"Base2::f" << endl; \}

virtual void g() \{ cout <<"Base2::g" << endl; \}

virtual void h() \{ cout <<"Base2::h" << endl; \}

\};

class Base3 \{

public:

virtual void f() \{ cout <<"Base3::f" << endl; \}

virtual void g() \{ cout <<"Base3::g" << endl; \}

virtual void h() \{ cout <<"Base3::h" << endl; \}

\};

class Derive : public Base1,public Base2,public Base3 \{

public:

virtual void f() \{ cout <<"Derive::f" << endl; \}

virtual void g1() \{ cout <<"Derive::g1" << endl; \}

\};

typedef void(\*Fun)(void);

int main()

Fun pFun = NULL;

Derive d;

int\*\* pVtab = (int\*\*)&d;

**//Base1's vtable**

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+0)+0);

pFun = (Fun)pVtab\[0\]\[0\];

pFun();

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+0)+1);

pFun = (Fun)pVtab\[0\]\[1\];

pFun();

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+0)+2);

pFun = (Fun)pVtab\[0\]\[2\];

pFun();

//Derive's vtable

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+0)+3);

pFun = (Fun)pVtab\[0\]\[3\];

pFun();

//The tail of the vtable

pFun = (Fun)pVtab\[0\]\[4\];

cout<<pFun<<endl;

**//Base2's vtable**

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+1)+0);

pFun = (Fun)pVtab\[1\]\[0\];

pFun();

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+1)+1);

pFun = (Fun)pVtab\[1\]\[1\];

pFun();

pFun = (Fun)pVtab\[1\]\[2\];

pFun();

//The tail of the vtable

pFun = (Fun)pVtab\[1\]\[3\];

cout<<pFun<<endl;

**//Base3's vtable**

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+1)+0);

pFun = (Fun)pVtab\[2\]\[0\];

pFun();

//pFun = (Fun)\*((int\*)\*(int\*)((int\*)&d+1)+1);

pFun = (Fun)pVtab\[2\]\[1\];

pFun();

pFun = (Fun)pVtab\[2\]\[2\];

pFun();

//The tail of the vtable

pFun = (Fun)pVtab\[2\]\[3\];

cout<<pFun<<endl;

return  0;

[Link 1]: http://blog.csdn.net/u013074465/article/details/40421943
[C_2_-]: http://blog.csdn.net/u013074465/article/details/46379481
[C]: http://blog.csdn.net/u013074465/article/details/46390731
[C_]: http://blog.csdn.net/haoel/article/details/1948051
[http_blog.csdn.net_haoel]: http://blog.csdn.net/haoel
[o_vtable1.jpg]: /images/20220806/c43a3c5a4fdc4efa8e21c80d3c876ac7.png
[o_Drawing3.jpg]: /images/20220806/76a72ecd75ba4868a0e3de4378e5140a.png
[o_vtable2.JPG]: /images/20220806/c9935c8a139446a688fc80429bd92687.png
[o_Drawing4.jpg]: /images/20220806/66826a37c988435d9c46052193fcffd7.png
[o_vtable3.JPG]: /images/20220806/689637325a14415eac29fbd74bc5c9cf.png
[o_Drawing1.jpg]: /images/20220806/cea0751f8ddd400fa34441774cfb028a.png
[o_vtable4.JPG]: /images/20220806/96bea2b3a42b45f99039c3a3d55da4a8.png
[o_Drawing2.jpg]: /images/20220806/e9e16c9e003244f1bd0da03a48d1f1d9.png
[o_vtable5.jpg]: /images/20220806/4cdc070f2b0f4b77b38a414e4bafc87e.png
[Link 2]: http://blog.csdn.net/littlehedgehog/article/details/5442430
[haoel_hotmail.com]: mailto:haoel@hotmail.com
[o_vtable_vc.JPG]: /images/20220806/7d89077d75cb4ca3bcfab09c53046915.png