[C++进阶]多态的概念、定义与实现

Dream_Snowar

已于 2024-07-27 17:59:50 修改

阅读量925

点赞数 16

文章标签： c++ 开发语言

于 2024-07-26 01:11:34 首次发布

本文链接：https://blog.csdn.net/2301_80017277/article/details/140648417

版权

多态，顾名思义，即多种形态。具体来说，就是不同对象执行同一行为而产生不同的结果。

一、多态的概念

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

比如说买票:普通人买的就是成人票,全价,学生呢?一般买的是学生票这个就是半价,二种票价的体现,就是说为的多态。

二、多态的定义与实现

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

1.虚函数

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

如下：

class A
{
public:
	virtual viod func()
	{

	}
};

2.虚函数重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
注意:这里是重写/覆盖，不是重定义/隐藏，重定义/隐藏是继承中的，子类的成员名与父类的成员名相同的时候，子类会覆盖掉父类，只需要名字相同即可而这里是都要相同如下所示，就是重写

class Person {
public:
	virtual void BuyTicket() const { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() const { cout << "买票-半价" << endl; }
};
void Func(const Person& p)
{
	p.BuyTicket();
}
int main()
{
	Student s;
	Person p;
	Func(p);
	Func(s);
	return 0;
}

运行结果:

这就是多态，不同的对象执行的结果不一样

但看代码，还是会觉得很神奇的，因为毕竟形参是一个Person类型的对象，居然能调用Student里面的函数。

其实虽然形参是Person类型的，这里的引用切割以后，只是让p指向了s中的Person的那一部分
多态调用看的是指向的对象的类型,普通对象看的是当前者的类型

3.多态的两个条件

多态有两个很重要的条件

调用函数是重写的虚函数（注意重写的条件是虚函数+三同）
基类指针或者引用

当我们将引用去掉以后，这里其实就变成了一个对象的切割/切片了。那么此时这个p就只能调用自己里面的函数了，不构成多态了。多态的两个重要条件里面的第二个就不满足了

class Person {
public:
	virtual void BuyTicket() const { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() const { cout << "买票-半价" << endl; }
};
void Func(const Person p)
{
	p.BuyTicket();
}
int main()
{
	Student s;
	Person p;
	Func(p);
	Func(s);
	return 0;
}

运行结果:

如果将父类的virtual给去掉了，那么最终也是不构成多态的，不满足第一个多态的条件

class Person {
public:
	void BuyTicket() const { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() const { cout << "买票-半价" << endl; }
};
void Func(const Person& p)
{
	p.BuyTicket();
}
int main()
{
	Student s;
	Person p;
	Func(p);
	Func(s);
	return 0;
}

运行结果:

总之必须得遵循以上两个条件

除此之外，我们调用的时候是正常的调用，不能是指定调用。如果是指定调用的话，那当然不会触发多态了

上面的例子都是引用的例子，下面来一个指针的例子

如下所示，指针或引用都是可以触发多态的

class Person {
public:
	virtual void BuyTicket() const { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() const { cout << "买票-半价" << endl; }
};
void Func(const Person* p)
{
	p->BuyTicket();
}
int main()
{
	Student s;
	Person p;
	Func(&p);
	Func(&s);
	return 0;
}

运行结果:

4.虚函数重写的两个例外

重写的条件本来是虚函数加三同，但是有一些例外

子类可以不加virtual，但是父类必须加上去

如下所示，是第一种情况的例子，子类可以不加virtual。但是父类必须加上去。

class Person {
public:
	virtual void BuyTicket() const { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	void BuyTicket() const { cout << "买票-半价" << endl; }
};
void Func(const Person* p)
{
	p->BuyTicket();
}
int main()
{
	Student s;
	Person p;
	Func(&p);
	Func(&s);
	return 0;
}

运行结果:

原因其实也是比较好想的，因为父类已经加上了virtual，这里的派生类继承了父类以后，里面是有virtual的，这里的多态其实只是改变的函数的实现。

关于这一个例外，建议全部加上virtual，但是实际上子类不加上virtual也是可以的。

2.协变（返回的值可以不同，但是要求返回值必须是父子关系的指针或者引用）
注意，这一点例外，是C++的大坑之一。

首先正常的返回值不同是会报错的。如下所示，显示重写的虚函数返回值有差异，且不是协变

也就是说，返回值不同的时候，必须满足协变，否则报错

如下就是满足了协变的条件，可以正常实现多态

class Person {
public:
	virtual Person* BuyTicket() const { cout << "买票-全价" << endl; return 0; }
};
class Student : public Person {
public:
	virtual Student* BuyTicket() const { cout << "买票-半价" << endl; return 0;}
};
void Func(const Person* p)
{
	p->BuyTicket();
}
int main()
{
	Student s;
	Person p;
	Func(&p);
	Func(&s);
	return 0;
}

运行结果:

注意，这里的父子类关系的指针，不是必须是自己的，也可以是其他类的，只要满足是父子类关系的指针或引用都是可以的。还有一点要注意的是，不可以一个是指针，一个是引用，必须同时是指针，或者同时是引用。以及，必须父类中的返回值是父类的指针或者引用，子类的返回值是子类的指针或者引用。不可以反过来

5.总结

多态的实现有两个条件

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（也就是要调用重写的虚函数）

6.析构函数的重写（虚函数重写的第三个例外）

首先我们思考以下问题:

析构函数可以是虚函数吗？为什么要是虚函数？

析构函数加上virtual是不是虚函数重写呢？

其实类析构函数都被处理成了destructor这个统一的名字。
那么为什么要这么处理呢？其实也很简单，因为要让他们构成重写（重写的条件无论是三同还是例外，都需要让函数名相同的）
那么为什么要让他们构成重写呢？我们看到如下代码:

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

int main()
{
	Person p;
	Student s;
	return 0;
}

运行结果如下所示，符合我们的预期（子类里面有一个父类，它会像栈一样，先析构后面生成的，在析构前面的。所以先析构子类，然后析构子类中的父类，最后析构父类）

但是如果我们不加virtual

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

int main()
{
	Person p;
	Student s;
	return 0;
}

运行结果:

我们不加virtual好像也没什么问题,

好像似乎我们不需要让析构函数进行重写也是没有任何问题的？编译器还让这个函数名处理成了destructor，同名了，似乎也还构成了隐藏/重定义的关系。因为隐藏/重定义只需要在继承关系中，成员名相同即可。就可以使得子类可以隐藏父类的成员。

所以C++即便不重写析构函数也是没有任何问题的吧?

其实如果不重写的话，有一个场景是过不去的,这属于一个特例:

class Person {
public:
	~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	~Student() 
	{ 
		cout << "~Student()" << endl;
		delete[] _ptr;
	}
protected:
	int* _ptr = new int[10];
};

int main()
{
	Person* p = new Person;
	delete p;
	p = new Student;
	delete p;
	return 0;
}

运行结果:

诶,我们析构的两次都是person,这会导致什么问题呢?对,聪明的同学肯定猜到了,没错就是内存泄漏,student中开辟的空间并没有被释放。Student中int*所指向的那块空间已经被泄露出去了。

那么为什么会发生内存泄漏呢？其实是因为没有调用到派生类的析构函数。

那么为什么又调不到派生类的析构函数呢？

我们在前面说过，类的析构函数都被处理成了destructor这个函数。

而delete p的本质其实也可以分为两部分，一部分是调用析构函数，即p->destructor()，另外一部分是调用operator delete§。

而这里就恰好编译器处理成一样的函数名了，加之这里并没有virtual构成重写/覆盖，反而是构成了隐藏/重定义了。而且p刚好是Person类型的指针，是一个普通的调用，不是多态调用。而在前文中也说过：普通调用，看的是当前者的类型。多态调用，看的是其指向的类型，编译器就以为调用的是Person的析构函数了。

但是我们肯定调用的不是Person的析构啊。虽然p这个指针的类型是Person*,但是它是一个基类，它有可能指向一个基类，也有可能指向一个派生类对象。我们希望它指向什么类型，就调用什么类型的析构函数，这样才可以保证不会产生内存泄漏。

而指向什么类型，调用什么类型，这不就正好符合多态调用吗?

那么我们就得知了，加上一个virtual进行修饰，刚好就是满足虚函数+三同，正好满足了成为多态的第一个条件，并且这里的p就是基类的指针，这也满足了成为多态的第二个条件，必须是基类的指针或者引用去调用这个重写的虚函数。刚好满足多态的条件。

满足了多态的条件，就可以解决这里的问题了。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student()
	{
		cout << "~Student()" << endl;
		delete[] _ptr;
	}
protected:
	int* _ptr = new int[10];
};

int main()
{
	Person* p = new Person;
	delete p;
	p = new Student;
	delete p;
	return 0;
}

运行结果：

其实一切的源头还是在于，C++允许了切片的行为。才导致父类指针可以指向一个子类对象，造成的一系列问题。而C++允许切片的行为，也是由于要实现多态，必须要使用切片。如下所示：

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
	virtual Person* BuyTicket() const { cout << "买票-全价" << endl; return 0; }

};
class Student : public Person {
public:
	virtual ~Student()
	{
		cout << "~Student()" << endl;
		delete[] _ptr;
	}
	virtual Student* BuyTicket() const { cout << "买票-半价" << endl; return 0; }

protected:
	int* _ptr = new int[10];
};

int main()
{
	Person* p = new Person;
	p->BuyTicket();
	delete p;
	p = new Student;
	p->BuyTicket();
	delete p;
	return 0;
}

运行结果：

这样一来，我们知道了,为了实现多态搞出来的切片和虚函数，但又由于切片导致了析构函数存在内存泄漏的问题，所以便通过多态去解决了这个内存泄漏问题。

这里我们也可以称之为虚函数重写的第三个例外，即析构函数的重写。从形式上来看他们的函数名是不一样的，不满足三同，但是由于编译器对函数名进行了处理，导致满足了三同，构成了虚函数的重写。从而解决了一类问题。

而虚函数重写的第一个例外是，基类必须加上virtual，但是子类可以不用加。我们可以这样理解，这个例外正好可以为析构函数服务。因为析构函数正常来说是没有返回值的，加上一个virtual其实挺奇怪的。于是我们可以默认说，基类的析构函数最好加上virtual,其他的照常即可。这样也正好就没有这个问题了。

加上了virtual的话，会建立一张虚表，它可能会造成一定的伤害，但是从总体上来看，还是很有必要的，利远大于弊！如果我们对库进行查看，有不少析构函数都加上了virtual。

7. C++11之override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

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

final：可以修饰变量、函数和类。
对于变量，确保初始化后不能被修改
对于函数，确保不能被子类重写
对于类，确保不能被继承

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

如上所示，当我们想要运行的时候，会报错的，因为声明为final的函数是无法被重写的。需要注意的是虚函数重写的第一个例外，子类可以不加virtual，因为下面也是构成重写的，所以也会报错。

但是如果我们直接改变了虚函数使它不会构成重写了，自然也不会报错了，注意这，我们加上了virtual，但是并不满足多态，不构成重写，但是满足函数名相同，满足了隐藏/重定义。这里的virtual的功能虽然不构成重写，但是万一以后有其他类要继承它的时候，就有可能会存在这两个构成重写的。

#include<iostream>
using namespace std;
class Car
{
public:
	virtual void Drive() final {};
};
class Benz : public Car
{
public:
	virtual void Drive(int i)
	{
		cout << "123456" << endl;
	}
};

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

class Car
{
public:
	virtual void Drive() {}
};

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

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

int main()
{
	return 0;
}

比较我们的上面的两段代码,第一段构成重写,我们运行最后会返回0,第二段我们基类没有加上virtual，就会报错了。这里只是构成了隐藏/重定义。

这些都讲完了现在我来问问大家如何设计一个类，使得这个类不会被继承

这个很简单吧!

肯定有人会这么想把基类构造函数私有化

class A
{
private:
	A() {};
};
class B : public A
{};
int main()
{
	B b;
	return 0;
}

我们将基类的构造函数给私有化，B自然就无法继承A了，B在定义对象的时候，会有一个构造函数，这个构造函数无论如何都会默认先走A的构造函数，但是这里我们将构造函数给屏蔽了。没法继承了。所以我们定义的对象b也就无法通过编译了

但是如果我们这么做了A类型的对象不是也创建不了吗?

为了解决这个问题，我们可以使用一个函数来返回这个A的匿名对象，这个是传值返回，所以A的匿名对象会先拷贝构造给临时变量，这个临时变量具有常性，然后我们这里看似是一个=,实际上是一个拷贝构造。利用这个临时对象去拷贝构造给这个a对象。不过上面只是我们的分析过程，我们讲过这种情况编译器会对这个过程进行优化处理，即拷贝构造+拷贝构造->拷贝构造。

这里我们还需要加上一个static将其变为静态的成员函数，这是为了避免调用这个函数还需要先创建一个对象去调用，而这个对象本身就是为了创建一个对象的，陷入了先有鸡还是先有蛋的纠缠。而我们加上了static以后，就没有了this指针，自然就可以直接使用类域去访问这个函数了。

class A
{
public :
	static A Creatobj()
	{
		return A();
	}
private:
	A() {};
};
class B : public A
{};
int main()
{
	A a = A::Creatobj();
	return 0;
}

第二个方案是析构函数私有化

class A
{
public:
private:
	~A() {};
};
class B : public A
{};
int main()
{
	A a;
	B b;
	return 0;
}

这个代码也是会报错的，我们使用的方案是析构函数私有化。这样一来也是可以的。但是我们又创建不了A类型的对象了

我们可以使用new来解决这个问题，我们的问题就是这个对象在栈区，它生命周期结束后会自动调用析构函数，但是析构函数被封锁了，无法调用，那我们直接将这个对象放在堆区的话，不就可以解决这个问题了吗。不过这样，我们释放不了这个内存了。所以我们可以和构造函数一样的方法，写一个静态的函数destroy去释放这些资源即可。

class A
{
public:
private:
	~A() {};
};
class B : public A
{};
int main()
{
	A *pa=new A;
	return 0;
}

第三种方案是基类使用final

前两种方案能用打架闹事未免显得太过于繁琐了，上面我们说过C++11的final的作用，所以我们可以直接用final修饰

class A final
{};
class B : public A
{};
int main()
{
	return 0;
}

8.重载、重写(覆盖)、重定义(隐藏)的对比

这里重载写的有错误,函数名相同,参数不同

Dream_Snowar

关注

16
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
[C++进阶]多态的概念、定义与实现

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。那么在继承中要构成多态还有两个条件：必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。多态的实现有两个条件必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（也就是要调用重写的虚函数）。
复制链接

扫一扫