C++ 学习笔记（22）多态与虚函数的使用

复习赋值兼容规则三种情况

#include<iostream>
using namespace std;

class Base{
public:
	void show(){
		cout<<"This is Base show()"<<endl;
	}
};

class D : public Base{
public:

};

void main(){
	D d;
	//1:对象给对象赋值
	Base b;
	b = d;

	//2:子类的地址给父类的指针赋值
	Base *pb = &d;

	//3:子类对象初始化父类的引用
	Base &bf = d;
}

一次为贼，终身为贼。

#include<iostream>
using namespace std;

class Base{
public:
	virtual void show(){
		cout<<"This is Base show()"<<endl;
	}
};

/*
//virtual只用在函数声明
class Base{
public:
	virtual void show();
};

void Base::show(){
	cout<<"This is Base show()"<<endl;
}
*/

class D : public Base{
public:
	void show(){  //父类的show是虚函数,那么子类的show也是虚函数(函数名相同,返回值相同,参数列表相同)
		cout<<"This is D show()"<<endl;
	}
	void show(int){
		cout<<"This is D show(int)"<<endl;
	}
	void print(){
		cout<<"This is D print()"<<endl;
	}
};

class C : public D{
public:
	void show(){
		cout<<"This is C show()"<<endl;
	}
	void show(int){
		cout<<"This is C show(int)"<<endl;
	}
};

void main(){
	C c;
	D *pd = &c;
	pd->show();  //调用的是C的show函数
	pd->show(0);  //调用的是父类D的show(int)
}

多态：相同的函数达到不同的功能。

#include<iostream>
using namespace std;

class A{
public:
	virtual void Eat(){
		cout<<"A Eat()"<<endl;
	}
	virtual void Sleep(){
		cout<<"A Sleep()"<<endl;
	}
};

class P : public A{
public:
	void Eat(){
		cout<<"P Eat()"<<endl;
	}
	void Sleep(){
		cout<<"P Sleep()"<<endl;
	}
};

class Dog : public A{
public:
	void Eat(){
		cout<<"Dog Eat()"<<endl;
	}
	void Sleep(){
		cout<<"Dog Sleep()"<<endl;
	}
};

class Pig : public A{
public:
	void Eat(){
		cout<<"Pig Eat()"<<endl;
	}
	void Sleep(){
		cout<<"Pig Sleep()"<<endl;
	}	
};

//接口
void fun(A *pa){
	pa->Eat();
	pa->Sleep();
}

void main(){
	P p;
	Dog dog;
	Pig pig;

	fun(&p);
	fun(&dog);
	fun(&pig);
}

举例：鸟类继承动物类，但是多了一个飞的功能，鸵鸟继承鸟类，但是不会飞。

#include<iostream>
using namespace std;

class A{
public:
	virtual void Eat(){
		cout<<"A Eat()"<<endl;
	}
	virtual void Sleep(){
		cout<<"A Sleep()"<<endl;
	}
};

class P : public A{
public:
	void Eat(){
		cout<<"P Eat()"<<endl;
	}
	void Sleep(){
		cout<<"P Sleep()"<<endl;
	}
};

class Dog : public A{
public:
	void Eat(){
		cout<<"Dog Eat()"<<endl;
	}
	void Sleep(){
		cout<<"Dog Sleep()"<<endl;
	}
};

class Pig : public A{
public:
	void Eat(){
		cout<<"Pig Eat()"<<endl;
	}
	void Sleep(){
		cout<<"Pig Sleep()"<<endl;
	}	
};

class Bird : public A{
public:
	void Eat(){
		cout<<"Bird Eat()"<<endl;
	}
	void Sleep(){
		cout<<"Bird Sleep()"<<endl;
	}
public:  //鸟类还会飞
	void Fly(){
		cout<<"Bird Fly()"<<endl;
	}
};

class TN : public Bird{
private:  //设为private,就表示鸵鸟不会飞
	void Fly();
};

//接口
void fun(A *pa){
	pa->Eat();
	pa->Sleep();
}

void main(){
	P p;
	Dog dog;
	Pig pig;

	fun(&p);
	fun(&dog);
	fun(&pig);

	TN tn;
	//tn.Fly();  //鸵鸟不会飞
	fun(&tn);
}

虚函数

成员函数应尽可能地设置为虚函数，但必须注意以下几点：

1. 派生类中定义虚函数必须与基类中的虚函数同名外，还必须同参数表，同返回类型。否则被认为是重载，而不是虚函数。如基类中返回基类指针，派生类中返回派生类指针是允许的，这是一个例外。

#include<iostream>
using namespace std;

//一般都要同名,同参数表,同返回类型
//例外:基类中返回基类指针,派生类中返回派生类指针
class Base{
public:
	virtual Base* show(){
		cout<<"This is Base show()"<<endl;
		return this;
	}
};

class D : public Base{
public:
	D* show(){  //父类的show是虚函数,那么子类的show也是虚函数(函数名相同,返回值相同,参数列表相同)
		cout<<"This is D show()"<<endl;
		return this;
	}
};

int main(){
	D d;
	Base *pb = &d;
	pb->show();  //调用子类D的show,返回值类型不一样,但是可以执行
	return 0;
}

2. 只有类的成员函数才能说明为虚函数。这是因为虚函数仅适用于有继承关系的类对象。

例如：全局的方法不能作为虚函数。

3. 静态成员函数，是所有同一类对象共有，不受限于某个对象，不能作为虚函数。

4. 一个类对象的静态和动态类型是相同的，实现动态多态性时，必须使用基类类型的指针变量或引用，使该指针指向该基类的不同派生类的对象，并通过该指针指向虚函数，才能实现动态的多态性。

5. 内联函数每个对象一个拷贝，无映射关系，不能作为虚函数。

6. 析构函数可定义为虚函数，构造函数不能定义虚函数，因为在调用构造函数时对象还没有完成实例化。在基类中及其派生类中都动态分配的内存空间时，必须把析构函数定义为虚函数，实现撤消对象时的多态性。

#include<iostream>
using namespace std;

class Base{
public:
	virtual void show(){
		cout<<"This is Base show()"<<endl;
	}
public:
	Base(){
		cout<<"Create Base"<<endl;
	}
	virtual ~Base(){
		cout<<"Free Base"<<endl;
	}
};

class D : public Base{
public:
	void show(){  //父类的show是虚函数,那么子类的show也是虚函数(函数名相同,返回值相同,参数列表相同)
		cout<<"This is D show()"<<endl;
	}
public:
	D(){
		cout<<"Create D"<<endl;
	}
	~D(){
		cout<<"Free D"<<endl;
	}
};

void main(){
	Base *pb = new D;
	delete pb;
}

7. 函数执行速度要稍慢一些。为了实现多态性，每一个派生类中均要保存相应虚函数的入口地址表，函数的调用机制也是间接实现。所以多态性总是要付出一定代价，但通用性是一个更高的目标。

8. 如果定义放在类外，virtual只能加在函数声明前面，不能（再）加在函数定义前面。正确的定义必须不包括virtual。