C++ 由虚基类 虚继承 虚函数 到 虚函数表

//虚基类：一个类可以在一个类族中既被用作虚基类，也被用作非虚基类。
class Base1{
public:
Base1(){cout<<"Construct Base1!"<<endl;};
void foo();//普通函数
virtual void foo1(){cout<<"foo1 in Base1"<<endl;};//虚函数：可以在基类中实现(+{})或者直接定义成虚基类，\
会出现错误：undefined reference to vtable for lass
virtual void foo2() = 0;//纯虚函数:必须要在继承类中实现，类似java中的接口好处是 可以在不清楚具体构建的情况下，给派生类规定好规范
};class Base2{
public:
void foo();//普通函数
virtual void foo1();//虚函数
//virtual void foo2() = 0;//纯虚函数
};
//虚继承：继承类继承了基类多次，从而产生了多个拷贝，虚基类的基本原则是在内存中只有基类成员的一份拷贝。\
//这样，通过把基类继承声明为虚拟的，就只能继承基类的一份拷贝，从而消除歧义。
class Derived1: public virtual Base1{
public:
Derived1(){cout<<"Construct Derived1~ !"<<endl;};
void foo2(){
cout<<"foo2 in Derive1"<<endl;
}
};
//多继承
class Derived2: public virtual Base1, public virtual Base2{
void foo2(){
cout<<"foo2 in Derive1"<<endl;
}
};

错误解决：在使用虚函数的程序中，编译时会出现 undefined reference to `vtable for Class 或 undefined reference to typeinfo for Class 的情况其解决方案就是将类似于virtual void foo();
Should be defined (inline or in a linked source file):virtual void foo() {}
Or declared pure virtual:virtual void foo() = 0;
 

基类指针指向派生类

基类指针可以指向派生类，但是无法使用不存在于基类只存在于派生类的元素。（所以我们需要虚函数和纯虚函数）

派生类指针不能指向基类

虚函数表

本文部分内容参考了 陈皓专栏的内容.

对c++了解的人都应该知道虚函数是通过一张虚函数表实现的。简称V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了 继承、覆盖的问题，保证内容真实反映实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子 类的时候，这张虚函数表就显得尤为重要了，它就像一个地图一样，指明了实际所应该调用的函数。C++的编译器保证虚函数表的指针存在与对象实例中的最前面 的位置（这是为了保证取道虚表函数的高性能）。

在每一个包含虚函数的类中，都存在一张虚函数表，用来记录虚函数真正的地址。当派生类继承于基类时，将基类的虚函数表也一同继承，然后根据自己是否覆盖基类的函数，来修改虚函数表。具体看这个：讲的很详细。实际上是每一个类都会创建一张虚表,每一个类的实例也就从类中得到了一张虚表.

一般: 无覆盖

一般继承: 虚函数覆盖

多重继承:无覆盖

可以看到子类函数的虚表就接在第一个基类虚表的后面

多重继承: 有虚函数覆盖

需要注意的问题：

不能通过父类型的指针访问子类自己的函数。即使这种目的可以使用指针的方式访问来达到

包含任一纯虚函数的类 为 抽象类。抽象类是不能够实例化的。

#include <iostream>
#include <cstdio>
using namespace std;class Base{
public:
virtual void f(){ cout<<" Base::f "<<endl; }
virtual void g(){ cout<<" Base::g "<<endl; }
virtual void h(){ cout<<" Base::h "<<endl; }
};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 Base{
public:
virtual void f1(){ cout<<" Derive::f1 "<<endl; }
virtual void g1(){ cout<<" Derive::g1 "<<endl; }
virtual void h1(){ cout<<" Derive::h1"<<endl; }
};class Derive1 : public Base{
public:
virtual void f(){ cout<<" Derive1::f"<<endl; }
virtual void g1(){ cout<<" Derive1::g1 "<<endl; }
virtual void h1(){ cout<<" Derive1::h1"<<endl; }
};class Derive2 : public Base1, public Base2, public Base3{
public:
virtual void f1(){ cout<<" Derive2::f1"<<endl; }
virtual void g1(){ cout<<" Derive2::g1 "<<endl; }
};class Derive3: public Base1, public Base2, public Base3{
public:
virtual void f(){ cout<<" Derive3::f"<<endl; }
virtual void g1(){ cout<<" Derive3::g1 "<<endl; }
};typedef void(*Fun)(void);
//作为函数指针 你得规定好指向的函数的参数类型,返回值类型.int main(void)
{
Base b;
Fun pFun = NULL;
cout<<"虚函数表地址: "<<&b<<endl;
cout<<"虚函数表地址: "<<(void *)&b<<endl;
cout<<"虚函数表地址: "<<(int*)&b<<endl;
cout<<"虚函数表地址: "<<(long*)&b<<endl;
/*上面四种输出结果一致 , b的地址转换成何种类型的指针看似是无所谓*/
cout<<"虚函数表---第一个函数地址: "<<(int *)*(int *)(&b)<<endl;
cout<<"虚函数表---第一个函数地址: "<<(void *)*(int*)(&b)<<endl;
/*
* long：在32位系统是32位整型,取值范围为-2^31 ~ (2^31 - 1)；在64位系统是64位整型,取值范围为-2^63 ~ (2^63 - 1)
* 为了能在64位机器上运行,这里要用 long 而不是int
*/
pFun = (Fun)*((long *)*(long*)(&b)); //Base::f
pFun = (Fun)*((long *)*(long*)(&b) + ); //Base::g
pFun = (Fun)*((long *)*(long*)(&b) + ); //Base::h
/* 我们就可以通过上面的方法调用函数 */ /*
*虚函数表明明显是在子类继承父类的时候能够发挥作用, 这里继承可以分为两类:
* 一般继承(无虚函数覆盖 & 有虚函数覆盖) 和 多重继承(有 & 无 虚函数覆盖)
*/ /* 一般: 无覆盖*/
Derive d;
pFun = (Fun)*((long *)*(long*)(&d) + ); //Derive::f1 /*
* 1）虚函数按照其声明顺序放于表中。
* 2）父类的虚函数在子类的虚函数前面。
*/ /* 一般继承: 有虚函数覆盖 */
Derive1 d1;
pFun = (Fun)*((long *)*(long*)(&d1)); //Derive::1
pFun = (Fun)*((long *)*(long*)(&d1) + ); //Base::g
/*
* 1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
* 2）没有被覆盖的函数依旧。
*/ /* 多重继承: 无覆盖*/
Derive2 d2;
pFun = (Fun)*((long *)*(long *)(&d2)); //Base::f
pFun = (Fun)*((long *)*(long *)(&d2) + ); //Derive2::f
pFun = (Fun)*((long *)*( (long *)(&d2) + )); // Base2: f 这里*是取地址得到了虚表上第一个虚函数表Base1中第一个函数的地址 ; + 1 得到第二个虚函数表Base2中第一个函数的地址;
/*
*1） 每个父类都有自己的虚表。
*2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）
*/ /* 多重继承: 有虚函数覆盖*/
Derive3 d3;
pFun = (Fun)*((long *)*( (long *)(&d3) ) ); //Derive3: f
pFun = (Fun)*((long *)*( (long *)(&d3) + )); // Derive3: f
pFun = (Fun)*((long *)*( (long *)(&d3) + )); // Derive3: f 这里*是取地址得到了虚表上第一个虚函数表Base1中第一个函数的地址 ; + 1 得到第二个虚函数表Base2中第一个函数的地址;
/*这里设计到了虚表的概念,也就是每一个基类在子类的虚表中都占有一席 , 我们当然可以通过上面这行code来访问其他虚表,
*但是还可以用二维数组来访问,更加便捷
*/
long **pVtab = (long **)&d3;
//Base1 's vtable
pFun = (Fun)pVtab[][];//Derive3::f
pFun = (Fun)pVtab[][];//Base::g
//Derive's vtable
pFun = (Fun)pVtab[][]; //Derive3::g1
//The tail of the vtable
pFun = (Fun)pVtab[][]; /*
*三个父类虚函数表中的f()的位置被替换成了子类的函数指针。
*我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。
*这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：
*/
Base1 *b1 = &d3;
Base2 *b2 = &d3;
Base3 *b3 = &d3;
b1->f(); //Derive3::f()
b2->f(); //Derive3::f()
b3->f(); //Derive3::f()
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()
/* 当然,父类指针只能指向子类中覆盖的父类中的虚函数, 如下,尝试访问子类中自有的函数 会报错*/
Base1 *b4 = new Derive3();
//b4 -> g1();///error: ‘class Base1’ has no member named ‘g1’| /* 但是并不安全:
* 1) 通过父类型的指针访问子类自己的虚函数: 在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。
* 2) 访问non-public的虚函数:
*/ return ;
}