【C++】多态

大柏怎么被偷了

已于 2024-07-26 15:12:29 修改

阅读量1.8k

点赞数 125

分类专栏： C++语法详解文章标签： c++ 开发语言

于 2024-07-24 10:04:06 首次发布

本文链接：https://blog.youkuaiyun.com/dab112/article/details/140578640

版权

多态的概念

了解多态之前，我们在现实生活一定经历过这俩个例子：

在购买火车票的时候，会根据你的类型来确定你的票价：

成人：全价
学生：半价
军人：免费

而某外卖系统的红包系统，也会根据一定类型来确定红包大小：

新人：大额红包
不经常使用该外卖系统的人：中等额度
经常使用外面系统的人：小额红包

从这些例子中，可以大致对多态有一定的理解：

多态的概念：通俗来讲，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

多态的定义以及实现

虚函数

class Person
{
public:
	virtual void fare()
	{
		cout << "全价" << endl;
	}
};

虚函数：被virtual修饰的类成员函数被称为虚函数。

虚函数的重写

class Person
{
public:
	virtual void fare()
	{
		cout << "全价" << endl;
	}
};

class Student : public Person
{
public:
	virtual void fare()
	{
		cout << "半价" << endl;
	}
};

虚函数的重写（覆盖）：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值相同，函数名字，参数列表完全相同），称为子类的虚函数重写了基类的虚函数。

class Person
{
public:
	virtual void fare()
	{
		cout << "全价" << endl;
	}
};

class Student : public Person
{
public:
	void fare()
	{
		cout << "半价" << endl;
	}
};

【注意】观察上述代码，在重写基类虚函数的时候，派生类的虚函数在不加virtual关键字时，虽然也可也构成重写（因为继承后基类的虚函数被继承下来，在派生类依旧保持虚函数属性），但是这种写法不是很规范，不建议这样使用。

通过观察代码，前俩段代码是通过对象类型来调用函数，而后面俩条代码是通过看指向的对象，如果指向的对象是基类，则调用基类；如果指向的对象是派生类，则调用派生类。

虚函数重写的俩个例外：

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

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

class A{};
class B : public A{};

class Person
{
public:
	virtual A* fare()
	{
		cout << "全价" << endl;
	}
};

class Student : public Person
{
public:
	virtual B* fare()
	{
		cout << "半价" << endl;
	}
};

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

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，但是这是不对的，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称被统一处理称desructor。

观察下面这段代码：

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

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


int main()
{
	Person* p = new Person;
	delete p;

	p = new Student;
	delete p;

	return 0;
}

这段代码使用了为经过处理的析构函数，使用Person这个指针进行析构第一次p的时候，会调用Person这个析构函数，而使用p析构第二次p的时候，还是只会调用Person这个析构函数。

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

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


int main()
{
	Person* p = new Person;
	delete p;

	p = new Student;
	delete p;

	return 0;
}

将析构函数前面加上virtual，进行虚函数的重写，可以将类析构函数都被处理为destructor这个统一的名字。

这里也是由于期望p->destructor()是一个多态调用，而不是普通调用。通过多态调用，可以将第二次的p在student析构一次，在Student析构一次，在Person析构一次。

这也是为什么将析构函数统一处理称destructor这个名字的原因，为了保证函数名的统一。

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

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


int main()
{
	Person* p1 = new Person;
	delete p1;

	Person* p2 = new Student;
	delete p2;

	return 0;
}

【注意】只有派生类student的析构函数重写了person的析构函数，当p1析构时会调用person的析构函数，而p2析构的时候会调用person与student的析构函数。