c++继承下

继承的方式主要分为单继承、多继承、菱形继承。

普通单继承：

指向派生类的基类指针或者引用，其类型仍然属于基类类型，而不是派生类类型

#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);
}

由图可见，菱形继承与多继承很相似。