c++ 虚函数多态、纯虚函数、虚函数表指针、虚基类表指针详解

静态多态、动态多态

静态多态：程序在编译阶段就可以确定调用哪个函数。这种情况叫做静态多态。比如重载，编译器根据传递给函数的参数和函数名决定具体要使用哪一个函数。
动态多态：在运行期间才可以确定最终调用的函数。需要通过虚函数+封装+继承实现。

---

虚函数

• 虚函数都必须有定义
• 虚函数一般用在继承中。多个子类继承同一基类，若在某种行为上不同的派生类有着自己的实现方式。这种情况我们就会用到多态。
  采用在基类中将此函数定义成虚函数，派生类中定义这个函数的不同实现。当我们使用基类的引用或指针调用一个虚成员函数时会执行动态绑定。因为直到运行的时候才能知道到底调用了哪个版本的虚函数，判断依据是根据引用或指针所绑定的对象的真实类型。
• 若子类中重写了父类的方法，但是父类中此方法并没有设置为虚函数。那么通过指向子类的指针或引用调用此方法的时候，调用的是父类的方法。
• 基类中某个函数一旦被声明为虚函数，则在所有派生类中它都是虚函数，不需要在派生类中再一次通过virtual关键字指出该函数的性质。
• 当且仅当通过指针或引用调用虚函数时，才会在运行时解析该调用。

---

哪些函数类型不可以被定义成虚函数？

• 内联函数
• 构造函数
• 静态成员函数：static成员函数是属于类的。不属于任何对象。
• 友元函数：不支持继承，没有实现为虚函数的必要
• 赋值运算符：赋值运算符要求形参类型与本身类型相同，基类中赋值操作符形参为基类类型，即使声明成虚函数，也不能作为子类的赋值操作符

---

内联函数为什么不能被定义成虚函数？
内联函数是为了在代码中直接展开，减少函数调用花费的代价。
inline 函数是在编译时确定的，而 virtual 属性是在运行时确定的，因此这个两个属性是不可能同时定义的。
即使虚函数被声明为内联函数，编译器遇到这种情况根本不会把这样的函数内联展开，而是当作普通函数来处理。

构造函数为什么不能被定义成虚函数？
如下：
1：继承情况下，构造函数的执行顺序时：A() B()，先执行父类的构造函数，在执行子类的构造函数
2：如果A的构造函数是虚函数，B类也定义了构造函数（即也为虚函数），则只会执行子类的构造函数。即只会执行B类的构造函数，不会再执行A类的构造函数，这样的话父类A就不能构造了。
这样的话1和2就发生了矛盾。并且 virtual 函数是在不同类型的对象产生不同的动作，现在对象还没产生，是不存在通过virtual实现不同动作的想法的。

class A
{
	A() {}
};

class B : public A
{
	B() : A() {}
};

int main()
{
	B b;
	B * pb = &b;
}

---

虚函数的访问方式

• 对象名： 通过对象名访问虚函数的时候，此时采用的是静态联编。调用哪个类的函数取决于定义对象名的类型。对象类型是基类时，就调用基类的函数；对象类型是子类时，就调用子类的函数。
• 指针： 通过指针访问虚函数的时候，编译器根据指针所指对象的类型来决定要调用哪个函数（动态联编），而与指针本身的类型无关
• 引用： 与指针访问虚函数类似。不同之处在于，引用一经声明后，引用变量本身无论如何改变，其调用的函数就不会在改变，始终指向其开始定义时的函数。引用在一定程度上提高了代码的安全性，可以将引用理解为一种“受限制的指针”。

---

析构函数中的虚函数

如 B：A，A是基类，B是子类
构造子类对象时，先运行基类构造函数初始化基类部分，再执行子类的构造函数初始化子类部分。在执行基类构造函数时，派生部分还是未初始化的。实际上，此时对象还不是一个派生类对象。即先 A 后 B
撤销子类对象时，首先撤销子类部分，然后按照与构造顺序的逆序撤销它的基类部分。即先B 后 A

下面看一个例子：

#include <iostream>
using namespace std;


class Father
{
    public:
        Father()
        {
            cout << "Father Constructor" << endl;
        }
        void calcMethod()
        {
            cout << "Father calcMethod()" << endl;
        }
        virtual void virtualMethod()
        {
            cout << "Father virtualMethod()" << endl;
        }
		virtual void virtualCommon()
        {
            cout << "Father virtualCommon()" << endl;
        }
        ~Father()
        {
            cout << "Father disConstruct" << endl;
        }
};

class Son:public Father
{
    public:
        Son()
        {
            cout << "Son Constructor" << endl;
        }
        void calcMethod()
        {
            cout << "Son calcMethod()" << endl;
        }
        void virtualMethod()
        {
            cout << "Son virtualMethod()" << endl;
        }
        ~Son()
        {
            cout << "Son disConstruct" << endl;
        }
};


int main()
{
    Father *f = new Son();          //先执行father构造函数，在执行son构造函数
    f->calcMethod();                //Father calcMethod()。父，子--->父。如果父类中的方法有自己的实现，则会去调用父类的方法。  见上述第3条。
    f->virtualMethod();             //Son virtualMethod()。父虚，子虚--->子。若把父类中的方法定义成虚函数，子类中有自己的实现，则会去调用指向的子类中对应的方法。  见上述第2条。
	f->virtualCommon();				//Father virtualCommon()。父虚，子无--->父。若把父类中的方法定义成虚函数，子类中有没有覆盖这个虚函数，则会直接调用父类的虚函数。
	
    delete f;
    return 0;
}

控制台打印：

Father Constructor
Son Constructor
Father calcMethod()
Son virtualMethod()
Father disConstruct

可以发现调用 delete 的时候只执行了父类的析构函数，没有执行子类的析构函数。因为父类的析构函数不是虚函数，这不是造成了内存泄漏？怎么解决这个问题呢？

虚析构函数

delete后面跟父类指针，则只会执行父类的析构函数。
delete后面跟子类指针，那么即会执行子类的析构函数，也会执行父类的析构函数。

可以通过在基类中把析构函数定义成虚函数来解决这个问题。因为若不定义成虚函数，通过指向子类的指针或引用调用delete的时候会默认执行父类的析构函数(可参考上述虚函数介绍的第3条)，而不会去执行子类的析构函数。

#include <iostream>
using namespace std;


class Father
{
	public:
		Father()
		{
			cout << "Father Constructor" << endl;
		}
		virtual ~Father()
		{
			cout << "Father Destruct" << endl;
		}
};

class Son:public Father
{
	public:
		Son()
		{
			cout << "Son Constructor" << endl;
		}
		~Son()
		{
			cout << "Son Destruct" << endl;
		}
	
};


int main()
{
	Father *f = new Son();			
	delete f;
	
	cout << "--------------" << endl;
	
	Son *s = new Son();
	delete s;
	
	return 0;
}

控制台打印

Father Constructor
Son Constructor
Son Destruct
Father Destruct
--------------
Father Constructor
Son Constructor
Son Destruct
Father Destruct

---

虚函数表指针 vptr

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


int main()
{
	// 函数指针
	typedef void (*Func) (void);
	
	Base b;
	
	cout << sizeof(b) << endl;				// B 函数只有一个虚函数表指针，即 4 
	cout << "虚函数表地址:" << (int*)(&b) << endl; 
	cout << "虚函数表-第一个函数地址：" << (int *)*(int *)(&b) << endl;
	
	Func pFunc = NULL;
	pFunc = (Func)*((int*)*(int*)(&b));			// 通过 Func * 把 int*强制转换成函数指针 
	pFunc();
	
	return 0;
}

多继承下的虚函数表

class A
{
	public:
		virtual void a() { cout << "a() in A" << endl; }	
		virtual void b() { cout << "b() in A" << endl; }	
		virtual void c() { cout << "c() in A" << endl; }	
		virtual void d() { cout << "d() in A" << endl; }	
};
 
class B : public A
{
	public:
		virtual void a() { cout << "a() in B" << endl; }	
		virtual void b() { cout << "b() in B" << endl; }	
};

class C : public A
{
	public:
		virtual void a() { cout << "a() in C" << endl; }	
		virtual void b() { cout << "b() in C" << endl; }	
};

class D : public B, public C
{
	public:
		virtual void a() { cout << "a() in D" << endl; }	
		virtual void d() { cout << "d() in D" << endl; }	
};

每个类的虚函数表结构如下：

B ：public A 重写了 a() b()

C ：public A 重写了 a() b()

D ：public B , public C 重写了 a() d()

可见，多继承时，有几个基类就有几个vptr。D类中的函数 a与d 覆盖了B类中的同名函数

---

虚基类表指针 bptr

菱形继承即如下图继承方式：B、C 虚拟继承A，D普通继承B，C

B : virtual public A
C : virtual public A
D : public B, public C

在虚拟继承情况下，基类不管在继承串链中被派生多少次，永远只会存在一个实体。
在虚拟继承基类的子类中，子类会增加某种形式的指针，指向虚基类子对象或指向相关表格（表格中存放的不是虚基类子对象的地址，就是其偏移量），此指针被称为 bptr

菱形继承时的对象布局：

// 菱形继承
class A {};
 
class B : virtual public A {};
class C : virtual public A {};

class D : public B, public C {};


int main()
{
	cout << "sizeof(A) : " << sizeof(A) << endl;	// 1 空类，编译器会为空类安插一个字节
	cout << "sizeof(B) : " << sizeof(B) << endl;	// 4 bptr指针
	cout << "sizeof(C) : " << sizeof(C) << endl;	// 4 bptr指针
	cout << "sizeof(D) : " << sizeof(D) << endl;	// 8 一个虚基类子对象只会在继承类中存在一份实体，即A占用1B（现在编译器做了优化，可以为0），0 + 4 + 4 = 8
}

---

纯虚函数

纯虚函数相当于定义了一个接口，不同的子类必须定义自己的实现。

#include <iostream>
using namespace std;


//抽象类
class Father
{
    public:
        virtual void calcMem() = 0;         //=0表示这是个纯虚函数。纯虚函数不需要定义，没有方法体。
		virtual void anotherMethod() = 0;	//纯虚函数，也可以定义。
};

void Father::anotherMethod()
{
	cout << "Father anotherMethod" << endl;
}

class Son:public Father
{
    public:
        virtual void calcMem()				//这里的virtual也可以不显示声明。
        {
            cout << "son calcMem" << endl;
        }
		
		void anotherMethod()
		{
			cout << "Son anotherMethod" << endl;
		}
};

int main()
{
    Son *s = new Son();
    s->calcMem();				//son calcMem
	s->anotherMethod();			//Son anotherMethod

    Father *f = new Son();
    f->calcMem();				//son calcMem
	f->anotherMethod();			//Son anotherMethod
	f->Father::anotherMethod();	//Father anotherMethod。也可以显示的调用父类的方法

   
    return 0;
}

控制台打印：

son calcMem
Son anotherMethod
son calcMem
Son anotherMethod
Father anotherMethod

---

抽象类

抽象类不能声明对象，只是作为基类的派生类服务。
抽象类不能定义对象，但是可以作为指针或者引用类型使用。

1：含有纯虚函数的类成为抽象类。
      除非派生类中完全实现基类中所有的纯虚函数，否则，派生类也是抽象类，不能实例化对象。

2：只定义了protected型构造函数的类也是抽象类。因为无论是在外部还是派生类中都不能创建该对象。但是可以由其派生出新的类。
      这种能派生出新类，但是不能创建自己对象的类时另一种形式的抽象类。

抽象类为什么不能实例化？
因为抽象类中的纯虚函数没有具体的实现，所以没办法实例化。

---

虚函数和纯虚函数的比较

（1）如果基类中定义了虚函数AF，派生类中对于这个虚函数可以覆盖也可以不覆盖。
派生类中如果覆盖了这个虚函数AZ，则通过指向子类的指针或引用调用的就是派生类中AZ
如果派生类中没有对这个AF进行覆盖，那么通过指向子类的指针或引用调用的就是基类中AF
（2）如果基类中定义了纯虚函数AAF，相当于是个接口。那么在派生类中就必须覆盖基类的这个纯虚函数。