继承的方式主要分为单继承、多继承、菱形继承。
普通单继承:
指向派生类的基类指针或者引用,其类型仍然属于基类类型,而不是派生类类型
#include<iostream>
using namespace std;
class Base
{
public:
void fun()
{
cout << "Base->fun()" << endl;
}
void foo()
{
cout << "Base->foo()" << endl;
}
};
class Derived :public Base
{
public:
void fun()
{
cout << "Deriver->fun()" << endl;
}
void foo()
{
cout << "Derived->foo()" << endl;
}
};
void TestOnlyInherit()
{
Base b;
Derived d;
Base *p = &b;
p->foo();
p->fun();
p = &d;
p->foo();
p->fun();
}
带有虚函数的单继承:
#include<iostream>
using namespace std;
class Base
{
public:
virtual void fun()
{
cout << "Base->fun()" << endl;
}
void foo()
{
cout << "Base->foo()" << endl;
}
int a;
};
class Derived :public Base
{
public:
virtual void fun()
{
cout << "Deriver->fun()" << endl;
}
void foo()
{
cout << "Derived->foo()" << endl;
}
int b;
};
void TestOnlyInherit()
{
Base b;
Derived d;
Base *p = &b;
p->foo();
p->fun();
p = &d;
p->foo();
p->fun();
}
Base->foo()--------基类指针指向一个派生类对象,指针p指向固定偏移量的函数。
Derived->fun()-------基类指针指向派生类对象,此时,指针p通过调用一个派生类对象来调用一个虚函数, p通过虚函数表来找到相应的函数的地址。
带虚继承的多继承:
#include<iostream>
using namespace std;
class Base1
{
public:
virtual void A()
{}
virtual void B()
{}
int a;
};
class Base2
{
virtual void C()
{}
virtual void D()
{}
int b;
};
class Derived1 :public Base1, public Base2
{
public:
virtual void E()
{}
virtual void F()
{}
int c;
};
void Printf(int* VTable)
{
cout << "虚表地址:" << VTable << endl;
for (int i = 0; VTable[i] != 0; ++i)
{
cout << "第%d个虚表地址:0x%x,->" << i << VTable[i] << endl;
}
}
void TestMoreInherit()
{
Base1 b1;
Base2 b2;
Derived1 d1;
int* VTable1 = (int*)(*(int*)&b1);
int* VTable2 = (int*)(*(int*)&b2);
int* VTable3 = (int*)(*(int*)&d1);
Printf(VTable1);
Printf(VTable2);
Printf(VTable3);
}
我们可以很明显的看出,基类Base1和Base2的虚函数地址不同,也就是说他们没有共用一张虚表。
而Base1和Derived的虚函数收地址相同,所以我们可以大胆假设,Base1和Derived共用了同一张虚函数表。并且,Derived的虚函数地址被放在了Base1的虚函数表的后面。
带虚继承的菱形继承:
#include<iostream>
using namespace std;
class A
{
public:
virtual void fun1()
{
cout << "A->fun1" << endl;
}
virtual void fun2()
{
cout << "A->fun2" << endl;
}
int a;
};
class B1:public A
{
public:
virtual void fun1()
{
cout << "B1->fun1" << endl;
}
virtual void fun3()
{
cout << "B1->fun3" << endl;
}
int b1;
};
class B2 :public A
{
public:
virtual void fun2()
{
cout << "B2->fun2" << endl;
}
virtual void fun4()
{
cout << "B2->fun4" << endl;
}
int b2;
};
class C :public B1, public B2
{
public:
virtual void fun3()
{
cout << "C->fun3" << endl;
}
virtual void fun4()
{
cout << "C->fun4" << endl;
}
virtual void fun5()
{
cout << "C->fun5" << endl;
}
int c;
};
void Printf(int* VTable)
{
cout << "虚表地址:" << VTable << endl;
for (int i = 0; VTable[i] != 0; ++i)
{
cout << "第%d个虚表地址:0x%x,->" << i << VTable[i] << endl;
}
}
void Test()
{
A a;
B1 b1;
B2 b2;
C c;
int* VTable1 = (int*)(*(int*)&a);
int* VTable2 = (int*)(*(int*)&b1);
int* VTable3 = (int*)(*(int*)&b2);
int* VTable4 = (int*)(*(int*)&c);
Printf(VTable1);
Printf(VTable2);
Printf(VTable3);
Printf(VTable4);
}
由图可见,菱形继承与多继承很相似。