C++类成员空间分配和虚函数表

最近在自学python，看到继承和类，就顺便复习了C++的类和继承等方面的知识。

先看Base基类

class Base {

private:

    virtual void display() { cout<<"Base display()"<<endl; }

    void say(){ cout<<"Base say()"<<endl; }

public:

    virtual void func(){cout << "Base func()" << endl; }
    void exec(){ display(); say(); }

    void f1(string a) { cout<<"Base f1(string)"<<endl; }

    void f1(int a) { cout<<"Base f1(int)"<<endl; }   //overload

};

Base类中定义私有的虚函数display， 普通成员函数say，公共的虚函数func， 普通的成员函数exec，重载了f1函数。

下面是DeriveA类，继承于Base类

class DeriveA:public Base{

public:

    void display() { cout<<"DeriveA display()"<<endl; }         //override

    void f1(int a,int b) { cout<<"DeriveA f1(int,int)"<<endl; }   //redefining

    void say() { cout<<"DeriveA say()"<<endl; }   //redefining

    virtual void func(){cout << "DeriveA func()" << endl; }

};

DeriveA类继承了Base类，重写(覆盖)了虚函数display和func，并且将display权限修改为public。重定义了f1函数和say函数，但是修改了f1的参数列表。

下面是基础的几个测试

DeriveA a;

Base *b=&a;

    b->func();
    a.func();
    b->f1("abc");
    b->f1();
    a.f1(,);    

输出结果：

func函数在Base类中为虚函数，DeriveA继承Base后，根据多态机制实现了动态调用。所谓多态机制就是用基类指针指向子类对象，基类指针调用虚函数func，会动态调用实际的子类对象的func函数。

由于display函数在Base类中为虚函数，所以不可以通过b->display()调用。由于DeriveA重新定义(redefining)了f1函数，f1函数参数类型修改了，所以只能使用a.f1(int,int)这种调用，而采用a.f1(string)或者

采用a.f1(int)这种调用都会出错，编译阶段就会出错。因为DeriveA类对f1重新定义了，基类的f1函数不可通过对象直接调用。同样的道理对于基类指针或对象，无论基类指针指向子类还是基类对象，调用f1只能

调用基类定义的两个f1(int)， f1(string)两个函数，如果采用b->f1(3,5)，编译器在编译阶段就会提出错误。想实现子类对象调用基类的函数可在函数体内加上作用于Base::函数名(参数，...)

DeriveA类修改f1函数，先调用基类的f1在调用自己的f1

class DeriveA:public Base{

public:

    void display() { cout<<"DeriveA display()"<<endl; }   //override

    void f1(int a,int b) {
        Base::f1();
        Base::f1("test");
        cout<<"DeriveA f1(int,int)"<<endl; }   //redefining

    void say() { cout<<"DeriveA say()"<<endl; }   //redefining

    virtual void func(){

        cout << "DeriveA func()" << endl; }

}; 

打印输出

a.f1(3,5);

结果如下：

先调用了基类的两个f1函数，之后调用DeriveA的f1函数

下面调用如下函数

b->exec()；

a.exec()；

结果如下：

为什么两个结果一样呢？

先看b->exec()；由于b是Base类型变量，那么调用的Base类的exec函数，exec函数内部调用Base类的display()和say()函数。由于b为指向DeriveA类的基类指针，根据多态机制，调用Base类的display()函数时，会动态调用

DeriveA类的display()函数。调用Base类的say()函数时，由于say()函数不是虚函数，所以不触发多态机制。因此b->exec()函数的结果为调用DeriveA的display，调用Base的say函数。

由于DeriveA类继承于Base类，但是没有实现自己的exec()函数，即没有实现重定义，那么当执行a.exec()时，调用的时Base类的exec()函数，原理和上边一样，调用Base类中的display()函数和say()函数，由于display()函数为虚函数，

a为DeriveA类对象，调用基类的虚函数display()，根据多态机制，实际调用的是DeriveA类的display()函数。

执行下边代码

a.say()

结果如下：

下面修改DeriveA类的内容，在DeriveA类内部实现自己的exec()函数

class DeriveA:public Base{

public:

    void exec(){ display(); say(); }

    void display() { cout<<"DeriveA display()"<<endl; }   //override

    void f1(int a,int b) {
        cout<<"DeriveA f1(int,int)"<<endl; }   //redefining

    void say() { cout<<"DeriveA say()"<<endl; }   //redefining

    virtual void func(){

        cout << "DeriveA func()" << endl; }

};

执行下边代码，

b->exec()；

a.exec()；

结果如下：

因为DeriveA类重定义了exec函数，那么a.exec()函数调用的是DeriveA类的exec()函数，从而调用的都是DeriveA类的display()和say()函数。

继承类和基类成员函数调用规则总结：

DeriveA a;

Base *b=&a;

1 基类指针指向子类对象，该指针调用某个成员函数，先考虑该函数是否为虚函数，如果为虚函数，且子类有覆盖(重写)，会触发多态机制，动态调用子类的重写函数：

如 b->func()， 输出为DeriveA func()

2 基类指针指向子类对象，该指针调用某个成员函数，先考虑该函数是否为虚函数，如果为虚函数，子类没有覆盖(没有重写)，不会触发多态机制，调用基类的虚函数：

3  基类指针指向子类对象，该指针调用某个成员函数，如果该函数不为虚函数，无论该函数是否被子类重定义(redefined)，只调用基类的该成员函数。如DeriveA类内部不实现

exec()函数，那么b->exec()调用的是Base类的exec()函数。

4  在第3条基础上，基类有成员函数exec()， 子类没有成员函数exec()，在基类的exec() 内部调用虚函数display()， 且子类覆盖了display()函数，那么根据多态机制，调用子类的display()。

如果display()虚函数没有被重写，则调用基类的display()函数，同第2条。如果exec()内部调用普通函数say()， 无论子类是否重定义say()，都会调用基类的say()函数，同3

5  Base类中实现exec()函数，而子类DeriveA类内部不实现exec()函数，DeriveA类对象调用exec()函数，实际调用的为Base类内部的exec()函数。如果exec()内部调用虚函数或者普通成员函数，

情况如同第4条。

6  Base类中实现exec()函数，而子类DeriveA类重定义exec()函数，那么DeriveA类对象调用的是DeriveA类的exec()函数。如果exec()函数内部调用DeriveA类的其他成员函数，那么调用的都是

DeriveA类的成员函数。

7 子类重定义了基类的成员函数，那么子类对象调用该成员函数，要根据子类重定义的形参列表。如a.f1(3,5);

 虚函数使用和定义规则：

（1）非类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数也不能定义为虚函数，但可以将析构函数定义为虚函数。实际上，优秀的程序员常常把基类的析构函数定义为虚函数。

因为，将基类的析构函数定义为虚函数后，当利用delete删除一个指向派生类定义的对象指针时，系统会调用相应的类的析构函数。而不将析构函数定义为虚函数时，只调用基类的析构函数。

（2）只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数，而定义函数时不需要使用关键字“virtual”。

（3）如果声明了某个成员函数为虚函数，则在该类中不能出现和这个成员函数同名并且返回值、参数个数、参数类型都相同的非虚函数。在以该类为基类的派生类中，也不能出现这种非虚的同名同返回值

同参数个数同参数类型函数。

 类的静态函数和构造函数不可以定义为虚函数：

1  静态函数的目的是通过类名+函数名访问类的static变量，或者通过对象调用staic函数实现对static成员变量的读写，要求内存中只有一份数据。而虚函数在子类中重写，并且通过多态机制实现动态调用，

在内存中需要保存不同的重写版本。

2  构造函数的作用是构造对象，而虚函数的调用是在对象已经构造完成，并且通过调用时动态绑定。动态绑定是因为每个类对象内部都有一个指针，指向虚函数表的首地址。而且虚函数，类的成员函数，

static成员函数都不是存储在类对象中，而是在内存中只保留一份。

 知其然、知其所以然（虚函数表原理）：

虚函数存储在虚函数表中，每个类对象都包含一个指向该虚函数表首地址的指针。定义Baseclass类

class Baseclass { 

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

从虚函数表中依次取出函数执行：

    Baseclass b; 

    cout <<"类对象大小" <<  sizeof(b) << endl;

    int * p = (int *)(&b) ;
    cout << "指向虚函数表的指针的地址"<< p << endl;
    cout <<"成员a地址"<< p+ << endl;
    cout <<"成员a的数值" << *(p + ) << endl;
    cout << "虚函数表首地址" <<(int *)(*p)  << endl;

    Func pFun =(Func) *(int *)(*p);
    pFun();

     pFun =(Func) *((int *)(*p) + );
    pFun();

     pFun =(Func) *((int *)(*p) + );
    pFun();
    

输出结果如下：

可见类对象大小为8字节，4字节正好是指向虚函数表指针的大小。剩余4字节为成员变量a的大小。画个图示意虚函数表结构：

p指向的就是类对象的首地址，同时也是虚函数表指针(指向虚函数表的指针)的地址，*p指向虚函数表，

由于指针是4字节，(int *)(*p)虚函数表首地址，也是第一个函数指针的地址。

Derive类继承于Base类，但是没有覆盖(重写)Base类的虚函数，Derive d; 的虚函数表如下：

Derive类继承于Base类，并且覆盖(重写)Base类的虚函数，Derive d; 的虚函数表如下：

可以看到d的虚函数表中第一个单元为Derive::f()，覆盖了原有的Base::f()。

Derive d;

Base * p = &d;

p指向d的首地址，其实就是d的虚函数表指针的地址，p->f()实际会调用虚函数表中的Derive::f()，从而实现多态。

多重继承结构如下：

虚函数表原理后可以篡改部分程序功能，其实很多外挂就是钩子函数回调注入的。

class Baseclass { 

public:
    Baseclass():a(){}
private:
    virtual void f() { cout << "Base::f" << endl; } 

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

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

    int a;
}; 

class Deriveclass:public Baseclass{
public:
    Deriveclass():Baseclass(){}

};

由于Baseclass内部的虚函数是私有的，所以Deriveclass类变量是不能直接访问这些函数的。但是可以通过虚函数寻址，并且通过回调函数方式调用。

Deriveclass d;
    Func pFunc = (Func)*((int *)(*(int *)(&d)));
    pFunc();

结果如下：

C++类对象的大小为多大？

一个类中，虚函数、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间的。

对象大小=   vptr(可能不止一个)   +   所有非静态数据成员大小   +   Aligin字节大小（依赖于不同的编译器对齐和补齐）

定义几个类，然后输出他们大小。

class   A
{
};    

class   B
{
    char   ch;
    void   func()
    {
    }
};    

class   C
{
    char   ch1;    //占用1字节
    char   ch2;   //占用1字节
    virtual   void   func()
    {
    }
};    

class   D
{
    int   in;
    virtual   void   func()
    {
    }
};    

class E
{
    char m;
    virtual void func()
    {

    }
};

输出大小：

    A   a;
    B   b;
    C   c;
    D   d;
    E    e;

cout<<"a对象大小： "<< sizeof(a)<<endl;
      cout<<"b对象大小： "<< sizeof(b)<<endl;
      cout<<"c对象大小： " <<sizeof(c)<<endl;
      cout<<"d对象大小： "<< sizeof(d)<<endl;
      cout <<"e对象大小： " <<sizeof(e) <<endl;

结果如下：

类和结构体对象对齐和补齐原则？

 对齐：类(结构体)对象每个成员分配内存的起始地址为其所占空间的整数倍。

补齐：类(结构体)对象所占用的总大小为其内部最大成员所占空间的整数倍。

空类定义的对象a  大小为1因为每个对象是独一无二的，编译器为了标识不同对象，要分配一字节的大小作为标识码。

对象b 大小为1是因为成员函数在内存中只存储一份，不会存储在对象中。

对象c大小为8， 是因为前四个字节存储虚函数表的指针，第5个字节存储成员变量ch1，第6个字节存储成员变量ch2，这样c的大小为6，根据补齐原则，需要补充2字节，使对象大小为8，8是最大字节4的整数倍。

对象d大小为8，不需要补齐和对齐。

对象e大小为8，前四个字节存储虚函数表指针，第5个字节存储成员m，需要补齐三个字节，总共八个字节，为4字节的倍数。

看看下边这几个类

class F{
    static int num;
}; 

class G{ 

    virtual void print(){}
    virtual void  print1(){}
}; 

class H{ 

    void print(){}
    static void print1(){}
}; 

打印并输出大小：

    F f;
    cout<<"f 对象大小： "<< sizeof(f)<<endl;

    G g;
    cout<<"g 对象大小： "<< sizeof(g)<<endl;

    H h;
    cout<<"h 对象大小： "<< sizeof(h)<<endl;

结果：

静态成员变量，虚函数和static成员函数都不会占用对象的空间，f大小为1,是因为要开辟一个字节保存对象标识信息。

g大小为4是开辟四字节给虚函数表指针。h大小为1字节也是开辟一个字节保存对象标识信息

什么要采取对齐和补齐分配策略？

这个要从计算机CPU存取指令说起，

每个字节单元为8bit，从地址0到地址3总共四个字节，为32bit。

class  A{

char  m;

char  b;

};

A a;  对于a 将a.m分配在地址0开始的一个字节中，将a.b分配在地址1开始的额一个字节中。这样a的大小为2，cpu取数据可以执行一条指令就完成了。

class B{

int m;

char n;

};

B b; 对于b将b.m分配在地址为0开始的四个字节(0~3)，对于b.n分配在开始地址为4的一字节空间。如果再定一个B b2;，不采取补齐策略，b2.m将被分起始地址为5的

4字节空间(5~8)，b2.n就被分在了起始地址为9的一字节空间。cpu取数据需要分3次，先取出0~3地址空间的数据(b.m)，再取出地址4~7数据(b.n和b2.m的前三个字节)

最后取出地址为8~11的数据(b2.m的最后一个字节以及b2.n)。取出数据后还要拆分和组合，极大地降低了效率。所以需要采取补齐策略。补齐策略数据分配如下：

地址0~3存储b.m， 地址4~7存储b.n，由于b.n只占用1个字节，地址5~7不存储数据，用于补齐。

地址8~11存储b2.m，地址12~15存储b2.n，13~15同样不存储数据用于补齐。

这样cpu读取四次可以将数据读取出来，进行简单的组合不需要切割数据就可以完成快速处理。

class C{

char n;

int  m;

}

C c； c.n存储周期0开始的一个字节中，如果不采取对齐策略，那么c.m会存储在1~4字节中，这样cpu需要读去两次，并且需要进行切割(0~4地址中数据包含c.n和c.m的前三个字节)，

以及组合地址4开始的一个字节(存储c.m的最后一个字节)。如果采取对齐策略，那么地址0~3存储c.n，地址4~7存储c.m，cpu同样读取两次，但是仅需要组合就可以去除对象的所有数据。

这就是为什么存储数据需要采取对齐和补齐的策略。

到此为止C++虚函数和类成员的存储知识复习完，谢谢关注我的公众号：