C++多态
- 多态
- 多态原理
- 动态联编和静态联编
- 纯虚函数和抽象类
- C++11的final override关键字
- 重载 隐藏 重写的区别
多态
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 ... " enG
virtual 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;//err
Circle 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修饰
