C++多态 动态联编 静态联编 虚函数 抽象类 final override关键字

注意点汇总

清楚的一篇博客

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

虚函数与虚函数表

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
拿指针或者引用来调用虚函数时，需要查虚表
指针指向哪个对象，调用虚方法的时候，就查哪个对象的虚表
一个类虚表只有一份，同类型的对象共享一份，虚表存放在代码区或者数据区

虚析构函数

防止内存泄漏

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++中虚析构函数的作用及其原理分析

用虚继承解决菱形继承问题

如果对虚函数表理解不到位，可以看这一篇博客
用虚继承解决菱形继承问题
链接: 虚函数表

多态(动态联编和静态联编 )

比较清楚的一片博客：动态联编和静态联编

多态实现机制

C++的多态就是基于继承的，多态的实现就是调用虚函数时发生的同名覆盖。当用基类的指针（或引用）指向派生类的对象时，通过该指针（或引用）调用虚方法是动态联编的过程。先找到对象前4个字节的虚函数指针（vbptr），通过vbptr找到虚函数表，虚函数表里有函数的入口地址

多态的一个例子

当用基类的指针（或引用）指向派生类的对象时，通过该指针（或引用）调用虚方法是动态联编的过程。先找到对象前4个字节的虚函数指针（vbptr），通过vbptr找到虚函数表，虚函数表里有函数的入口地址
名字粉碎技术是编译时的多态
运行时的多态：满足两个条件，把函数定义成需，用指针或者引用调用虚函数
运行时的多态：公有继承+虚函数+指针或者引用调用虚函数

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

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

C++静态多态和动态多态

静态联编（static binding)早期绑定:静态联编是指在编译和链接阶段，就将函数实现和函数调用关联起来。
C语言中，所有的联编都是静态联编,并且任何一种编译器都支持静态联编。C++语言中，函数重载和函数模板也是静态联编。
C++语言中，使用对象名加点"."成员选择运算符，去调用对象虚函数，则被调用的虚函数是在编译和链接时确定。(称为静态联编)。

动态联编(dynamic binding)亦称滞后联编（late binding）或晚期绑定:动态联编是指在程序执行的时候才将函数实现和函数调用关联起来。
C++语言中，使用类类型的引用或指针调用虚函数(成员选择符">")，则程序在运行时选择虚函数的过程，称为动态联编。
当用基类的指针（或引用）指向派生类的对象时，通过该指针（或引用）调用虚方法是动态联编的过程。先找到对象前4个字节的虚函数指针（vbptr），通过vbptr找到虚函数表，虚函数表里有函数的入口地址

实例说明

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 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后面不准重写
final override关键字
总结：
override两个作用，一个是检查重新的函数时候和被重新函数一模一样，一个是重写函数可以不用加virtual
final 可以作用虚函数，阻止重写可以作用类，阻止继承

重载 隐藏 重写的区别

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

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

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