【C++】多态（一）

多态基本概念

多态也就是多种形态
对于不同对象实现相同的方法，但产生的结果是不一样的

例如，我们前边所介绍继承的例子：

class Animal {
public:
	Animal(const string& name, const string& gender, const int& age) :_name(name), _gender(gender), _age(age)
	{}
	void Sleep()
	{
		cout << _name << "在睡觉！！！" << endl;
	}
	void Eat()
	{
		cout << _name << "在吃饭····" << endl;
	}
public:
	string _name;
	string _gender;
	int _age;
};


class Dog :public Animal
{
public:
	Dog(const string& name, const string& gender, const int& age, const string& color)
		:Animal(name, gender, age), _color(color)
	{}
	
protected:
	string _color;
};


class Cat :public Animal
{
public:
	Cat(const string& name, const string& gender, const int& age, const string& temper)
		:Animal(name, gender, age), _temper(temper)
	{}
	
private:
	string _temper;
};

对于动物狗、动物猫，两种动物具有共同的特性：名称、性别、年龄，也具有类似的生活习性：睡觉、吃饭，因此我们为了避免重复的代码过多而引入了继承的概念：
将猫与狗的共有特性提取出来，形成一个动物类来实现它们共同的特征：

但是我们会发现一个问题，猫与狗类的对象都会调用基类中继承而来的方法来实现我们的需求，但是现实生活中，我们想要通过调用同一种方法来实现不同的效果，比如说狗类吃饭是啃骨头，猫类吃鱼，那要怎样才能实现这种想法？？

引入了多态的概念：

多态：在不同继承关系的类对象中，调用同一个函数产生不同的行为

那么针对上边的例子，我们来看看效果：

这就要谈到我们上次说到的 virtual 关键字

class Animal {  //基类
public:
	Animal(const string& name, const string& gender, const int& age) :_name(name), _gender(gender), _age(age)
	{}
	virtual void Sleep()
	{
		cout << _name << "在睡觉！！！" << endl;
	}
	virtual void Eat()
	{
		cout << _name << "在吃饭····" << endl;
	}
public:
	string _name;
	string _gender;
	int _age;
};

class Dog :public Animal
{
public:
	Dog(const string& name, const string& gender, const int& age, const string& color)
		:Animal(name, gender, age), _color(color)
	{}
	virtual void Sleep()
	{
		cout << _name << "睡觉打呼噜inging~~" << endl;
	}
	virtual void Eat()
	{
		cout << _name << "啃骨头inging~~" << endl;
	}
protected:
	string _color;
};

class Cat :public Animal
{
public:
	Cat(const string& name, const string& gender, const int& age, const string& temper)
		:Animal(name, gender, age), _temper(temper)
	{}
	virtual void Sleep()
	{
		cout << _name << "安安静静睡觉inging~~" << endl;
	}
	virtual void Eat()
	{
		cout << _name << "逮老鼠inginging~~" << endl;
	}
private:
	string _temper;
};

//测试代码

//基类对象的指针/引用 可以指向/引用 子类对象
void test0(Animal& animal)
{
	animal.Sleep();
	animal.Eat();
}

int main()
{
	Dog dog("金毛", "公", 3, "金黄色");
	test0(dog);

	Cat cat("咪咪", "母", 1, "温柔");
	test0(cat);

	return 0;
}

在继承模块中，我们谈到，子类与基类中若存在相同的成员变量或是成员函数，则会在调用时候产生同名隐藏 添加链接描述（继承中作用域板块）但若我们在同名的成员函数前加上 virtual 关键字，则可以实现多态

多态实现条件

1、在继承体系中，多态必须通过基类指针或引用调用虚函数（基类指针/引用可以指向/引用派生类的对象）
2、被调用的函数必须是虚函数（被 virtual 所修饰的成员函数），且派生类必须对基类的虚函数进行重写

多态是在程序运行时，根据基类指针或引用指向不同类的对象，选择对应的虚函数进行调用

再来看一个多态实现的栗子：

class Shape {          //基类：形状类
public:
	//virtual 修饰的成员函数称为虚函数
	virtual void Draw()
	{
		cout << "位置图形，无法进行绘制！" << endl;
	}
	virtual double GetGrith()
	{
		cout << "图形未知，无法获取周长！！" << endl;
		return NULL;
	}
};

class Circle :public Shape   //圆形 
{
public:
	Circle(const double& r):_r(r) {}
	virtual void Draw()
	{   //子类必须重写基类的虚函数
		cout << "圆形" << endl;
	}

	virtual double GetGrith()    //求周长----------实现与基类中同名函数的重写
	{
		return 2 * _r*3.1415926 ;
	}
private:
	double _r;
};

class Rect :public Shape    //矩形
{
public:
	Rect(const double& length,const double& width) :_length(length),_width(width) {}
	virtual void Draw()
	{   //子类必须重写基类的虚函数
		cout << "矩形" << endl;
	}
	virtual double GetGrith()
	{
		return 2 * (_length + _width) ;
	}
private:
	double _length;
	double _width;
};

class Trangle :public Shape    //三角形
{
public:
	Trangle(const double& a, const double& b,const double& c) :_a(a), _b(b),_c(c) {}
	virtual void Draw()
	{
		cout << "三角形" << endl;
	}
	virtual double GetGrith()
	{
		return _a + _b + _c;
	}
private:
	double _a;
	double _b;
	double _c;
};

void Test(Shape& s)
{
	s.Draw();
	cout << s.GetGrith() << endl;;
}
int main()
{
	Circle c(2);
	Test(c);

	Rect L(2, 4);
	Test(L);

	Trangle t(3, 4, 5);
	Test(t);

	return 0;
}

虚函数重写

虚函数重写定义

虚函数重写：
（1）派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型，参数列表，函数名字完全相同），称子类的虚函数重写了基类的虚函数
（2）派生类虚函数前不加 virtual 也可以构成重写，但写法不规范，建议添加 virtual
（3）派生类虚函数与基类虚函数的访问权限可以不同

虚函数重写的两个例外

析构函数重写

（基类与派生类析构函数名称不同）

（一般情况下在继承体系中建议将基类的析构函数设置为虚函数）

若基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写，虽然基类与子类析构函数名不同，看起来违背了重写规则，但可以看作是编译器对析构函数名称做了特殊处理

class A {
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};

class B :public A
{
private:
	virtual ~B()    //与基类中析构函数构成重写
	{
		cout << "~B()" << endl;
	}
};

协变

（基类与派生类虚函数的返回值类型不同）

派生类重写基类虚函数时，与基类虚函数的返回值类型不同。
即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用，称为协变。

//测试代码一：

class A {
public:
	virtual A* GetObj()      //返回基类虚函数的指针
	{
		return this;
	}
};

class B :public A 
{
private:
	virtual B* GetObj()     //返回子类虚函数的指针
	{
		return this;
	}
};

void GetObj(A* pa)       //基类指针可以指向子类对象
{
	if (pa) {
		pa->GetObj();
	}
}

int main()
{
	A a;
	GetObj(&a);

	B b;
	GetObj(&b);

	return 0;
}

//测试代码二：

class AA {};   //基类
class BB :public AA {};   //子类

//创建不同类的对象
AA aa;
BB bb;


class A {
public:
	virtual AA& GetObj()
	{
		return aa;    //基类 A 中返回 基类 AA 对象的引用
	}
};

class B :public A
{
private:
	virtual BB& GetObj()     //与基类中同名函数引用形成重写
	{
		return bb;    //子类 B 中返回子类 BB 对象的引用
	}
};

void GetObj(A& pa)    //基类引用可以引用子类对象
{
	pa.GetObj();
}

int main()
{
	A pa;
	GetObj(pa);

	B pb;
	GetObj(pb);
	return 0;
}

注意区别 同名隐藏、函数重载、虚函数重写

override 修饰子类虚函数

override 只能用来修饰子类的虚函数
作用：让编译器在编译代码时，帮助检测是否重写了基类中某个函数，若重写则编译通过，否则编译失败

class B {
public:
	virtual void Func1()
	{
		cout << "B::Func1()" << endl;
	}
};

class D :public B
{
public:
	virtual void Func1()override         //override 只能用来修饰子类的虚函数-----检测是否构成重写
	{
		cout << "D::Func1()" << endl;
	}
};

final 关键字

1、final 修饰类：表明该类不能被继承

2、final 修饰虚函数：表明该虚函数不想被继承

（final 只能修饰子类虚函数）

抽象类

在虚函数后面加上 “=0” ，则这个函数称为纯虚函数。
包含纯虚函数的类称为抽象类或接口类（不能创建实例化对象的类）

举个栗子来理解一下吧：

对于我们前边所介绍的 图形类 Shape ，由于图形可能是 圆形、正方形、长发形、三角形…，所以 Shape 并不具体，我们不能实例化一个图形对象：

class Shape {
public:
	virtual void Draw()
	{
		cout << "图形不具体，不能够进行绘制！" << endl;
	}
	virtual double GetPer()
	{
		return 0;
	}
};
int main()
{
	Shape a;         //创建一个图形类的对象
	a.Draw();
	a.GetPer();      //显然是不成立的，图形未知是不能计算它的周长的

	return 0;
}

显然，上述例子是不合理的，我们无法创建一个未知图形的对象，更不能计算出未知图形的周长信息
由此可见，当前的 Shape 类是不能够实例化出对象的，因此称之为抽象类

抽象类：包含纯虚函数的类
不能创建实例化对象

//抽象类
class Shape {
public:
	virtual void Draw() = 0;   // =0 纯虚函数
//纯虚函数不能被调用------因此可以不实现其方法体
	virtual double GetPer() = 0;     // =0 纯虚函数

};

抽象类一定要被继承，并在子类中一定要对抽象类中的纯虚函数进行重写，否则该子类也是抽象类
即：子类一定要对抽象类中的纯虚函数 全部 进行重写，否则子类也是抽象类

//抽象类

class Shape {
public:
	virtual void Draw() = 0;   // =0 纯虚函数

	virtual double GetPer() = 0;     // =0 纯虚函数

};


class Circle:public Shape
{
public:
	Circle(const double r = 1) :_r(r)      //重写
	{}
	virtual void Draw()
	{
		cout << "圆形" << endl;
	}

	virtual double GetPer()    //重写
	{
		return 2 * 3.1415 * _r;
	}
private:
	double _r;
};

抽象类不能创建实例化对象，但是可以创建其指针 / 引用

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口