多态

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

名字粉碎技术是编译时的多态
运行时的多态：满足两个条件，把函数定义成需，用指针或者引用调用虚函数

运行时的多态：公有继承+虚函数+指针或者引用调用虚函数

当一个动物类型引用狗类型的时候，会调用狗的虚方法，不会调用动物的虚方法，

class Animal {
private:string name;
public:Animal(const string na) : name(na){ }~Animal() {}virtual void eat() { cout << "eat ... " << endl; }//virtual void walk ( { cout <<"walk ... " enGvirtual void PrintInfo() {}const string& GetName() const { return name; }
};
class Dog :public Animal {
private:string owner;
public:Dog(const string& own, const string& na) :Animal(na),owner(own) {}~Dog(){}virtual void eat() { cout << "eat :bone " << endl; }virtual void PrintInfo() {cout << "owner:  " << owner << endl;cout << "Dog name:  " << GetName() << endl;}
};
class Cat :public Animal {
private:string owner;
public:Cat(const string& own, const string& na) :Animal(na), owner(own) {}~Cat() {}virtual void eat() { cout << "eat :fish " << endl; }virtual void PrintInfo() {cout << "owner:  " << owner << endl;cout << "Cat name:  " << GetName() << endl;}
};
void funa(Animal& an) {cout << typeid(an).name() << endl;an.eat();}
void funb(Animal*p) {if (p == nullptr)return;p->eat();
}
int main() {Dog dog("yhping", "hashiqi");Cat cat("tulun", "xiaofei");funb(&dog);funb(&cat);return 0;
}

...void funa(Animal& an) {cout << typeid(an).name() << endl;an.eat();}
void funb(Animal*p) {if (p == nullptr)return;p->eat();
}
int main() {Dog dog("yhping", "hashiqi");Cat cat("tulun", "xiaofei");funa(dog);funa(cat);return 0;
}

void func(Animal an) {cout << typeid(an).name() << endl;an.eat();}
int main() {Dog dog("yhping", "hashiqi");Cat cat("tulun", "xiaofei");func(dog);func(cat);return 0;
}

多态原理

class Object
{
private:  int value;
public:Object(int x = 0) :value(x) {	}virtual void add() { cout << "0bject: :add()" << endl; }virtual void fun() { cout << "Object: :fun()" << endl; }virtual void print() const { cout << "Object : :print()" << endl; }
};
class Base : public Object {
private:int num;
public: Base(int x = 0) :Object(x), num(x + 10) {  }virtual void add() { cout << "Base: :add()" << endl; }virtual void fun() { cout << "Base: :fun()" << endl; }virtual void show() {cout << "Base: : show()" << endl;}
};class Test : public Base {
private:int count;
public:Test(int x = 0) :Base(x), count(x + 10) {}virtual void add() { cout << "Test: :add()" << endl; }virtual void print() const { cout << "Test : :print()" << endl; }virtual void show() { cout << "Test : :show()" << endl; }
};

一旦在基类中指定某成员函数为虚函数，那么，不管在派生类中是否给出virtual声明，派生类（以及派生类的派生类，…）中对其重定义的成员函数均为虚函数

Object::RTTI 运行时的类型识别信息
Object::vftable

继承虚表，需要重写，重复的虚函数更改所属类别，没有重复的继承，新的虚函数添加就行
基类和派生类有相同的函数，没有定义为虚，就是同名隐藏，
基类给一个虚函数，派生类重写虚函数，符合三同，就是同名覆盖，覆盖虚表里面函数的地址

虚表存储示意图

Object obj 定义一个对象，开辟了8个字节，一个是存储整型val，另外存储虚表指针__vfptr,首先将__vfptr指向第一个虚函数首地址，即Object::add函数的入口地址，再接着构建val的值0，由构造函数设置虚表指针
再构建Base base对象 base有一个基对象 Object,该基对象也有虚表指针
构建过程为：到达Base的构造函数，但是并不构建base，先构建公有继承的基类，到达obj的构造函数，用x初始化val值之前，使该虚表指针指向obj虚表的首地址，用x初始化val值，构建完基类型，回到base的构造函数，构造成员num之前，对base的虚表重新构建，使虚表指针指向base的地址，然后再构建num的值，obj的大小为8字节，base的大小为12字节
每个对象的虚表指针最终指向该对象的虚表
，

int main() {Object* op = nullptr; Test test;Base base;op = &test;op->add(); op->fun(); op->print();op = &base; op->add(); op->fun(); op->print();return 0;
}

这里op指向test的地址，调用函数的话，就查该对象自己的虚表，即调用
Test::add Base::fun Test::print
拿指针或者引用来调用虚函数时，需要查虚表
指针指向哪个对象，调用虚方法的时候，就查哪个对象的虚表
虚表只有一份，同类型的对象共享一份，虚表存放在代码区或者数据区

如果对虚函数表理解不到位，可以看这一篇博客
链接: 虚函数表

动态联编和静态联编

比较清楚的一片博客：动态联编和静态联编
静态联编（static binding)早期绑定:静态联编是指在编译和链接阶段，就将函数实现和函数调用关联起来。
C语言中，所有的联编都是静态联编,并且任何一种编译器都支持静态联编。C++语言中，函数重载和函数模板也是静态联编。
C++语言中，使用对象名加点".“成员选择运算符，去调用对象虚函数，则被调用的虚函数是在编译和链接时确定。(称为静态联编)。
动态联编(dynamic binding)亦称滞后联编（late binding）或晚期绑定:动态联编是指在程序执行的时候才将函数实现和函数调用关联起来。
C++语言中，使用类类型的引用或指针调用虚函数(成员选择符”>")，则程序在运行时选择虚函数的过程，称为动态联编。

class Object {
private:
int value; public:Object(int x = 0) : value(x) {memset(this,0, sizeof(Object));}void func() { cout << "Object : : func: " << value << endl; }virtual void add(int x) { cout << "0bject::add: " << x << endl; }
};
int main() {Object obj;Object* op = &obj;obj.add(1); //这里可以op->add(2);
}

memset(this,0, sizeof(Object)) 在虚表构建完成后，初始化x的值后，又将this指针指向的对象的所有值都置为0，即__vfptr和val都置为了0
obj.add(1);这里是静态联编，op->add(2);这里需要查表，此时虚表指针已经变成了nullptr，程序会崩溃

拿指针或者引用调用虚函数是动态联编，和拿对象调用虚函数是静态联编，
add(1); //this->add(1);add(this,1) 类的成员函数调用其他成员函数，都有一个this指针,所以需要查虚表

class Object{
private:
int value; 
public:Object(int x = 0) : value(x) {}
void print()
{cout << "Object : : print" << endl; add(1);
}
virtual void add(int x)
{cout << "0bject: :add: " << x << endl;
}
};
class Base : public Object {
private: int num; public:Base(int x = 0) :Object(x + 10),num(x) { }void show()//Base*const this{cout << "Base : : show" << endl; print();//this->print() }virtual void add(int x){cout << "Base: :add: " << x << endl;}
};
int main() {Base base; base.show();return 0;
}

class Object {
private:
int value; public:Object(int x = 0) : value(x) {cout << "Create Object: " << endl; add(11);}~Object() {cout << "Destory 0bject" << endl; add(12);}virtual void add(int x){cout << "Object: : add: " << x << endl;}
};
class Base : public Object{
private: int num; public:
Base(int x = 0) : Object(x + 10),num(x) {
cout << "Create Base " << endl; 
add(21);
}
~Base() {
cout << "Destroy Base" << endl; 
add(22);
}
virtual void add(int x)
{cout << "Base: :add: " << x << endl;
} };
int main() {Base base; return 0;
}

凡是在构造函数和析构函数调用虚函数，都是静态联编

指针加一，跟指向对象没有关系，只跟自己的类型有关系

class Object{
private:
int value; public:Object(int x = 0) : value(x) {cout << "Create Object: " << endl;}~Object() {cout << "Destory 0bject" << endl;}virtual void Print()const{cout << "value:"<<value << endl;}
};
class Base : public Object {
private: int num; public:Base(int x = 0) : Object(x + 10), num(x) {cout << "Create Base " << endl;}~Base() {cout << "Destroy Base" << endl;}virtual void Print()const {cout << "num" << num << endl;}
};int main() {Object* op = new Base(10);op->Print();delete op;return 0;
}

delete op; 这里派生类对象没有调用析构函数，所以将基类析构函数定义为虚

class Object{
private:
int value; public:Object(int x = 0) : value(x) {cout << "Create Object: " << endl;}virtual ~Object() {cout << "Destory 0bject" << endl;}virtual void Print()const{cout << "value:"<<value << endl;}
};
class Base : public Object {
private: int num; public:Base(int x = 0) : Object(x + 10), num(x) {cout << "Create Base " << endl;}virtual ~Base() {cout << "Destroy Base" << endl;}virtual void Print()const {cout << "num" << num << endl;}
};int main() {Object* op = new Base(10);op->Print();delete op;return 0;
}

析构函数可以定义成虚，构造函数和拷贝构造函数不能定义为虚
如果一个类型不具备派生对象，将析构函数定义为虚就没有意义
在继承关系，并且基类有虚方法，就要把基类析构函数定义为虚，
如果对为什么基类析构函数定义为虚不理解，可以看看这一篇博客
链接: C++中虚析构函数的作用及其原理分析

纯虚函数和抽象类

抽象类的概念:含有纯虚函数的类是抽象类。
抽象类是一种特殊的类，它是为抽象的目而建立的，它处于继承层次结构的较上层。
抽象类不能实例化对象，因为纯虚函数没有实现部分，所以含有纯虚函数类型不能实例化对象;

虚函数实现依赖派生类，基类就是抽象类，析构函数定义为虚函数
无法定义对象，但是可定义指针，定义指针的时候不用实例化对象

抽象类只能用作其他类的基类，不能创建抽象类的对象。
抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出。如果派生类没有重新定义纯虚函数，而派生类只是继承基类的纯虚函数，则这个派生类仍然还是一个抽象类。如果派生类中给出了基类纯虚函数的实现，则该派生类就不再是抽象类了，它是一个可以建立对象的具体类型。

class Shape {
private:std::string _sname;
public:Shape(const std::string& name) : _sname(name) {}virtual ~Shape() {}
public:virtual void draw() const = 0;virtual void area() const = 0;
};
class Circle : public Shape {
private:static const float pi;float _radius;
public:Circle(const string& name, float r = 0) :Shape(name), _radius(r) {}~Circle(){}virtual void draw() const {}virtual void area() const {}
};
const float Circle::pi = 3.14;
int main() {//Shape a;//errCircle cir("ddd", 2);return 0;
}

如果没有将继承的纯虚函数给出具体的实现，那么继承的派生类也是抽象类，所以继承的派生类需要将基类的纯虚函数给出具体的实现，否则无法定义对象
接口就是 函数的返回类型 函数名 形参列表
//应用类型，不提供派生，也不继承;

class cDateTime
{};

//节点类型，提供了继承和多态的基础，但没有纯虚函数，

class shape
{
string sname;
public:
virtual float area() const { return 0.0f;}
string getName() const;
};

抽象类型;抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出;

class Shape{string sname;public:virtual float area()const=0;string getName()const;
};

//接口类;没有属性，所以的函数都是纯虚函数;

class Shape{
public:
virtual void draw() const = 0;
virtual float area() const = 0;
};

//实现类﹔是继承了接口或抽象类型，定义了纯虚函数的实现;

class circle : public Ishape
{
public:
virtual void draw() const 
virtual void erea() const { return 0;}
}

有时希望派生类只继承成员函数的接口(声明)，纯虚函数;
有时希望派生类同时继承函数的接口和实现，但允许派生类改写实现，虚函数。
有时则希望同时继承接口和实现，并且不允许派生类改写任何东西，非虚函数。

C++11的final override关键字

C++11中增加了final关键字来限制某个类不能被继承，或者某个虚函数不能被重写。如果修饰函数，final只能修饰虚函数，并且要放到类或者函数的后面。

virtual void fun() final =0;

这是矛盾冲突的，=0说明是纯虚函数，就是等着重写，而final后面不准重写

重载 隐藏 重写的区别

重载：是指同一可访问区内被声明的几个具有不同参数列（参数的类型，个数，顺序不同）的同名函数，根据参数列表确定调用哪个函数，重载不关心函数返回类型

隐藏：是指派生类的函数屏蔽了与其同名的基类函数，注意只要同名函数，不管参数列表是否相同，基类函数都会被隐藏。

重写(覆盖)：是指派生类中存在重新定义的函数。其函数名，参数列表，返回值类型，所有都必须同基类中被重写的函数一致。只有函数体不同（花括号内），派生类调用时会调用派生类的重写函数，不会调用被重写函数。重写的基类中被重写的函数必须有virtual修饰