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

先看Base基类

class Base {private:    virtual void display() { cout<<"Base display()"<

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

下面是DeriveA类，继承于Base类

class DeriveA:public Base{public:    void display() { cout<<"DeriveA display()"<

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

下面是基础的几个测试

     DeriveA a;

     Base *b=&a;

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

 输出结果：

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()"<

打印输出

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()"<

 执行下边代码，

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(1024){}    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+1 << endl;    cout <<"成员a的数值" << *(p + 1) << endl;    cout << "虚函数表首地址" <<(int *)(*p)  << endl;    Func pFun =(Func) *(int *)(*p);    pFun();      pFun =(Func) *((int *)(*p) + 1);    pFun();     pFun =(Func) *((int *)(*p) + 2);    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(1024){}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)<

 

 结果：

静态成员变量，虚函数和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++虚函数和类成员的存储知识复习完，谢谢关注我的公众号：