C++中的多态

最新推荐文章于 2024-09-29 18:03:50 发布

加一zZ

最新推荐文章于 2024-09-29 18:03:50 发布

阅读量39

点赞数

分类专栏： C++学习之路文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/ayf9999/article/details/134549261

版权

C++学习之路专栏收录该内容

25 篇文章 0 订阅

订阅专栏

多态（polymorphism）

多态的概念

多态，就是 "多种形态" 的意思。

说具体点就是：去完成某个行为，不同的对象去做会产生不同的结果（状态）。

比如说地铁站买票这个行为，普通人、学生、军人买票是不同的。

普通人必须买全价票，学生就可以买半价票，而军人可以优先购买到预留票：

比如有一个 BuyTicket 买票的成员函数，创建普通人、学生和军人三个对象，他们调用该函数形态结果我们就要设计成不一样的。

重写（覆盖）

我们先用代码实现一下我们刚才的购票场景。

这里我们当然是用继承了，将 Student 和 Soldier 继承自 Person：

class Person {};
class Student : public Person {};
class Soldier : public Person {};

并且既然是要设计多态，我们就要为这三个身份设计不同的 BuyTicket 接口，

void BuyTicket() {...}

这里用 virtual 虚函数，并且做到函数名、参数和返回值相同，就能够达到 "重写" 的效果：

class Person {
public:
//  [virtual] + [返回值] + [函数名] + [参数] 相同 = 构成多态
        👇         👇         👇       👇
      virtual     void     BuyTicket   ()  {
          cout << "Person: 买票-全价 100￥" << endl;
      }
};
 
class Student : public Person {
public:
    // 这里也都相同
    virtual void BuyTicket() {
        cout << "Student: 买票-半价 50￥" << endl;
    }
};
 
class Soldier : public Person {
public:
    // 这里也都相同
    virtual void BuyTicket() {
        cout << "Soldier: 优先买预留票-全价 100￥" << endl;
    }
};

概念：重写也称为覆盖，重写即重新改写。

重写是为了将一个已有的事物进行某些改变以适应新的要求。

重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。即：

"外壳不变，核心重写。"

最后我们再设计一个 Pay 函数去接收不同的身份，以调用对应的 BuyTicket 函数。

这里我们可以用指针和引用，这里我们先用指针：

void Pay(Person* ptr) {
    ptr->BuyTicket();
}

代码演示：BuyTicket

#include <iostream>
using namespace std;
 
class Person {
public:
	// 虚函数
	virtual void BuyTicket() {
		cout << "Person: 买票-全价 100￥" << endl;
	}
};
class Student : public Person {
public:
	// 虚函数 + 函数名/参数/返回 -> 重写（覆盖）
	virtual void BuyTicket() {
		cout << "Student: 买票-半价 50￥" << endl;
	}
};
class Soldier : public Person {
public:
	// 虚函数 + 函数名/参数/返回 -> 重写（覆盖）
	virtual void BuyTicket() {
		cout << "Student: 优先买预留票-全价 100￥" << endl;
	}
};
 
/* 接收身份 */
void Pay(Person* ptr) {
	ptr->BuyTicket();  // 到底是谁在买票，取决于传来的是谁
}
 
int main(void)
{
	int option = 0;
	Person p;
	Student st;
	Soldier so;
 
	do {
		cout << "1.普通人  2.学生  3.军人" << endl;
		cout << "请选择身份：";
		cin >> option;
		switch (option)
		{
		case 1:
			Pay(&p);
			break;
		case 2:
			Pay(&st);
			break;
		case 3:
			Pay(&so);
			break;
		default:
			cout << "输入错误！请重新输入！" << endl;
			break;
		}
 
	} while (option != -1);
 
	return 0;
}

运行结果：

我们现在就做到了不同类型的对象做不同的事情，这就是用多态实现出来的效果。

多态构成的条件

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

比如我们刚才的 Student 继承了 Person，Person 买票是全价，但 Student 买票却是半价：

注意：继承中想要构成多态，必须满足以下两个条件：

① 必须是子类的虚函数重写成父类函数（重写：三同 + 虚函数）
② 必须是父类的指针或者引用去调用虚函数。

* 三同指的是：同函数名、同参数、同返回值。

* 虚函数：即被 virtual 修饰的类成员函数。

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

虚函数的重写 ( 覆盖 ) ： 派生类中有一个跟基类完全相同的虚函数 ( 即派生类虚函数与基类虚函数的

返回值类型、函数名字、参数列表完全相同 ) ，称子类的虚函数重写了基类的虚函数。

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
 virtual void BuyTicket() { cout << "买票-半价" << endl; }
/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
这样使用*/
/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{ p.BuyTicket(); }
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
 return 0;
}

虚函数重写的两个例外：

1. 协变 ( 基类与派生类虚函数返回值类型不同 )

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指

针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）

class A{};
class B : public A {};
class Person {
public:
 virtual A* f() {return new A;}
};
class Student : public Person {
public:
 virtual B* f() {return new B;}
};

2. 析构函数的重写 ( 基类与派生类析构函数的名字不同 )

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，

都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，

看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处

理，编译后析构函数的名称统一处理成 destructor 。

class Person {
public:
 virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
 virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
 Person* p1 = new Person;
 Person* p2 = new Student;
 delete p1;
 delete p2;
 return 0;
}

析构函数的重写

观察下列代码：

class Person {
public:
	~Person() {
		cout << "~Person()" << endl;
	}
};
 
class Student : public Person {
public:
	~Student() {
		cout << "~Student()" << endl;
	}
};
 
int main(void)
{
	Person p;
	Student s;
 
	return 0;
}

运行结果：

思考：这三行分别是谁的？

解读：第一行和第二行是 Student s 的，第三行是 Person p 的。我们来看看析构顺序，Student s 是后定义的，析构顺序是后定义先析构。根据子类对象析构先子后父，调用子类的析构函数结束后自动调用父类的析构函数，所以第一行的 ~Student() 和第二行的 ~Person() 都是 Student 的，随后第三行的 ~Person() 是 Person p 自己调的。

现在这两个析构函数默认是隐藏关系，

因为它们的函数名会被同一处理修改成 destructor：

但是如果我用 virtual 修饰 ~Person，我们知道，如果这加了不管 ~Student 加不加 virtual，

子类都会跟着父类变身成 virtual，那么现在这两个析构函数还是隐藏关系吗？

如果 Person 的析构函数加了 virtual，它们的关系就变了：

然并卵，对普通对象来说，这里加 virtual 并不会带来什么改变，对于普通对象是没有影响的：

class Person {
public:
	virtual ~Person() {
		cout << "~Person()" << endl;
	}
};
 
class Student : public Person {
public:
	// 隐藏（重定义）关系 -> 重写（覆盖） 关系
	~Student() {
		cout << "~Student()" << endl;
	}
};
 
int main(void)
{
	// delete 调用 Person 的析构，对这个也没有影响
	Person* ptr1 = new Person;
	delete ptr1;
 
	// 但是对这样的场景会产生影响
	Person* ptr2 = new Student;
	delete ptr2;
 
	return 0;
}

运行结果：

干脆直接用一个 ptr 去演示好了：

	Person* ptr = new Person;
	delete ptr;   // ptr->destructor() + operator delete(ptr)
 
	ptr = new Student;  
	delete ptr;   // ptr->destructor() + operator delete(ptr)

刚才我们看到了，如果这里不加 virtual，~Student 是没有调用析构的。

你可能会想这有啥，那是因为这里没场景，这其实是非常致命的，是不经意间会发生的内存泄露。

💬 比如下面这个场景，我们是希望 delete 谁调用的就是谁的析构：

class Person {
public:
	~Person() {
		cout << "~Person()" << endl;
	}
};
 
class Student : public Person {
public:
	// 隐藏（重定义）关系 -> 重写（覆盖） 关系
	~Student() {
		cout << "~Student()" << endl;
		delete[] _name;
		cout << "delete: " << (void*)_name << endl;
	}
 
private:
	char* _name = new char[10]{ 'h', 'e', 'l', 'l', 'o' };
};
 
int main(void)
{
	// 我们期望 delete ptr 调用析构函数是一个多态调用
	Person* ptr = new Person;
	delete ptr;   // ptr->destructor() + operator delete(ptr)
 
	ptr = new Student;  
	delete ptr;   // ptr->destructor() + operator delete(ptr)
 
	return 0;
}

运行结果：

我们加上 virtual 再试试：

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

完美！！！！

结论：如果设计的类可能会作为父类，析构函数最好设计成虚函数，即加上 virtual。

C++11 override 和 final

从上面可以看出， C++ 对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数

名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有

得到预期结果才来 debug 会得不偿失，因此： C++11 提供了 override 和 final 两个关键字，可以帮

助用户检测是否重写。

1. final ：修饰虚函数，表示该虚函数不能再被重写

class Car
{
public:
 virtual void Drive() final {}
};
class Benz :public Car
{
public:
 virtual void Drive() {cout << "Benz-舒适" << endl;}
};

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car{
public:
 virtual void Drive(){}
};
class Benz :public Car {
public:
 virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

重载、覆盖、隐藏的对比

抽象类（Abstract Class）

纯虚函数和抽象类

在虚函数的后面写上 =0，则我们称这个函数为 "纯虚函数"。

包含纯虚函数的类，就是 抽象类（abstract class），也叫接口类。

/* 抽象类 */
class Car {
public:
	virtual void Drive() = 0;  // 纯虚函数
};

抽象类不能实例化出对象，子类即使在继承后也不能实例化出对象：

只有重写纯虚函数，子类才能实例化出对象：

/* 抽象类 */
class Car {
public:
	virtual void Drive() = 0;
};
 
// 如果父类是抽象类，子类必须重写才能实例化
class BMW : public Car {
public:
	virtual void Drive() {   // 重写
		cout << "BMW-操控性" << endl;
	}
};
 
int main(void)
{
	BMW b;
	b.Drive();
 
	return 0;
}

运行结果：

如果 override 是直接要求你重写，那设计成抽象类就是间接要求你重写。

override 是放在子类虚函数，检查重写，它们的功能其实是有一些重叠和相似的。

纯虚函数规范了子类必须重写，另外虚函数更体现出了接口继承。

总结：抽象类不能实例化出对象，子类即使在继承后也不能实例化出对象，除非子类重写。

抽象类为什么叫抽象类？

抽象在现实一般没有具体对应的实体，而不能实例化对象也就是没有实体，所以叫抽象类。

抽象类指针

虽然父类是抽象类不能定义对象，但是可以定义指针。

定义指针时如果 new 父类对象因为是纯虚函数，自然是 new 不出来的，但是可以 new 子类对象：

/* 抽象类 */
class Car {
public:
	virtual void Drive() = 0;
};
 
class Benz : public Car {
public:
	virtual void Drive() {
		cout << "Benz-舒适" << endl;
	}
};
 
int main(void)
{
	Car* pBenz1 = new Benz;
	pBenz1->Drive();
 
	Benz* pBenz2 = new Benz;
	pBenz2->Drive();
 
	return 0;
}

运行结果：

纯虚函数的实现问题

纯虚函数也是可以实现的：

/* 抽象类 */
class Car {
public:
    // 实现没有价值，因为压根没有对象会调用它
	virtual void Drive() = 0 {      // 纯虚函数
		cout << "Drive()" << endl;   
	}
};

但是，纯虚函数的实现没有什么太大意义，因为根本就没人能用它。

你实现一个东西是为了让人能调用你，纯虚函数谁能调用？根本没有人能调用它。

所以纯虚函数一般给个声明就可以了，它本身就是一个接口继承。

关于接口继承和实现继承（补充说明）

普通函数的继承是一种实现继承，子类继承了父类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，子类继承的是父类虚函数的接口，目的是为了重写，

达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

出现虚函数就是为了提醒你重写的，以实现多态。如果虚函数不重写，那写成虚函数就没价值了。

加一zZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录