C++——继承和多态

多态：

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。
C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。

1.1两种多态：

1.1.1编译时多态（早绑定）：

编译时的多态通过函数的重载和运算符的重载来实现的。
就像是未出生的男女孩定下的娃娃亲。

1.1.2运行时多态（晚绑定）：

运行时的多态性是指在程序执行前，无法根据函数名和参数来确定该调用哪一个函数，必须在程序执行过程中，根据执行的具体情况来动态地确定。它是通过类继承关系public和虚函数来实现的。目的也是建立一种通用的程序。通用性是程序追求的主要目标之一。
就像是长大后自由恋爱的男女孩。
可总结为三点：1.public继承 2.虚函数 3.通过指针或引用调动

1.2虚函数：

1.2.1虚函数定义：

虚函数是一个类的成员函数，定义格式如下:
关键字virtual指明该成员函数为虚函数。virtual仅用于类定义中，如虚函数在类外定义，不可加virtual。

当某一个类的一个类成员函数被定义为虚函数，则由该类派生出来的所有派生类中，该函数始终保持虚函数的特征。

1.2.2那些可以做虚函数，不可做虚函数?

成员函数应尽可能地设置为虚函数，但必须注意以下几条:
1．派生类中定义虚函数必须与基类中的虚函数同名外，还必须同参数表，同返回类型。否则被认为是重载，而不是虚函数。如基类中返回基类指针，派生类中返回派生类指针是允许的，这是一个例外。
2．只有类的成员函数才能说明为虚函数。这是因为虚函数仅适用于有继承关系的类对象。
3.静态成员函数。是所有同一类对象共有，不受限于某个对象，不能作为虚函数。
4．实现动态多态性时，必须使用基类类型的指针变量或引用，使该指针指向该基类的不同派生类的对象，并通过该指针指向虚函数。才能实现动态的多态性。
5.内联函数每个对象一个拷贝。无映射关系，不能作为虚函数。
6.析构函数可定义为虚函数，构造函数不能定义虚函数，因为在调用构造函数时对象还没有完成实例化。在基类中及其派生类中都动态分配的内存空间时，必须把析构函数定义为虚函数，实现撇消对象时的多态性。
7．函数执行速度要稍慢一些。为了实现多态性，每一个派生类中均要保存相应虚函数的入口地址表，函数的调用机制也是间接宾现。所以多态性总是要付出一定代价，但通用性是一个更高的目标。
8．如果定义放在类外，virtual 只能加在函数声明前面，不能(再)加在函数定义前面。正确的定义必须不包括virtual,

构造函数时，会创建虚表指针，不能把构造函数变为虚函数（变成虚函数无法查表）。故几种构造函数均不能。下文会讲到虚表概念

1.3虚表

虚表是在继承关系中，遇到虚函数会生成一个虚表来存放指向要调用函数的指针，虚表在数据区。同时在对象里也会产生一个指向虚表的指针。

1.3.1虚表的构建：

class Object
{
private:int value;
public:
	Object(int x=0):value(x){}
	virtual void add() { cout << "Object::add" << endl; }
	virtual void fun() { cout << "Object:;fun" << endl; }
	virtual void print() const { cout << "Object::print" << endl; }
};
class Base :public Object
{
private: int sum;
public:
	Base(int x = 0) :Object(x+10),sum(x) {}
	virtual void add() { cout << "Base::add" << endl; }
	virtual void fun() { cout << "Base:;fun" << endl; }
	virtual void show()  { cout << "Base::show" << endl; }
};
class Text:public Base
{
private:int num;
public:
	Text(int x = 0) :Base(x + 10), num(x) {}
	virtual void add() { cout << "Text::add" << endl; }
	virtual void print()const{ cout << "Text:;print" << endl; }
	virtual void show() { cout << "Text::show" << endl; }
};
int main()
{
	Text t1(10);
	Object* op = &t1;
	Base* bp = &t1;
	Text* tp = &t1;
}

构建过程如图：如果虚函数同名，同参数，同返回值类型时，则会覆盖父类虚表的函数；不同名的则增加进去

op是Object类型指针，受指针类型的约束，op只能指向Text类型t1虚表的一部分。

bp是Base型，tp是Text型，在继承表是，没有虚函数的填入，两者指向的类型大小相同。

1.3.2同名覆盖：

如果虚函数同名，同参数，同返回值类型时，则会覆盖父类虚表的函数；不同名的则增加进去

class Object
{
private:int value;
public:
	Object(int x=0):value(x){}
	virtual void add() { cout << "Object::add" << endl; }
	virtual void fun() { cout << "Object:;fun" << endl; }
	virtual void print() const { cout << "Object::print" << endl; }
};
class Base :public Object
{
private: int sum;
public:
	Base(int x = 0) :Object(x+10),sum(x) {}
	virtual void add() { cout << "Base::add" << endl; }
	virtual void fun() { cout << "Base:;fun" << endl; }
	virtual void print() const { cout << "Base::print" << endl; }
};
int main()
{
	Base b(10);
	Object* op = &b;
	cout << sizeof(b) << endl;
	return 0；
}

在继承时，虚表也会被继承，子类会拷贝父类虚表，在子函数中，遵循同名覆盖规则。

1.3.2虚表访问：

虚表通过虚表指针来进行访问，才能进行运行时的多态。所以在构建对象时会构建一个虚表指针。所以图中base的大小为12字节。虚表指针只存在于根部函数（继承的最初始函数），意思就是不管是多少重继承，虚表指针只存在于最初始的父类中。

1.4动态联编和静态联编：

通过指针或引用来调动虚函数，采用的是动态联编
通过对象来调动虚函数，采用静态联编

1.4.1静态联编：

静态编联要求在编译期就确定，对象和哪个方法进行关联。
在编译期，Object类型的对象obj就和Object的方法结合。

1.4.2动态编联：

动态联编：在运行时确定和哪个方法进行关联。Op->add在运行时去查找虚表和哪个方法结合。只有指针和引用调用时才会进行查表。