c++多态

bhbca

已于 2024-02-14 14:07:35 修改

阅读量41

点赞数

分类专栏： c++ 文章标签： c++

于 2023-07-21 19:24:01 首次发布

本文链接：https://blog.csdn.net/bhbca/article/details/131858644

版权

c++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

多态的概念
抽象类
多态的底层实现原理

一.多态的概念

为什么要引入多态呢？

class person
{
public:
	~person()
	{
        
    }
};
class student:public person
{
public:
	~student()
	{
        
    }
}

int main()
{
    person* p1 = new person;
    person* p2 = new student;

    delete p1;
    delete p2;
	return 0;
}

我们知道delete会调用有关对象的析构函数，根据p2的类型，delete p2会调用基类的析构函数，但实际它应该调用派生类的析构函数才对，如果要实现这一操作，必须使用多态机制。

1.定义

多态是指不同的对象完成某个动作产生不同的状态。比如买车票，普通人买不打折，学生买有折扣。

多态是建立在继承上的
虚函数：被virtual修饰的函数叫做虚函数，（这里的virtual和菱形虚拟继承中的virtual没有关系）

2.构造多态的条件

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

3.虚函数重写

派生类中有一个和基类相同的虚函数(函数名，参数，返回类型都相同)，称派生类重写了基类的虚函数。
虚函数的重写是指重写实现，复用基类中的虚函数接口。也就是说如果构成了多态，基类的指针/引用指向的是基类对象，那么调用基类的接口与实现，基类的指针/引用指向的是派生类的对象，那么调用的是基类的接口和派生类中虚函数的实现。

class person
{
public:
	virtual void BuyTicket()
	{
        cout << "没有折扣" << endl;
    }
};
class student:public person
{
public:
	virtual void BuyTicket()
	{
        cout << "半价" << endl;
    }
};
void func(person& p)
{p.BuyTicke();}
int main()
{
    person p1;
    student s1;
    func(p1);
    func(s1);
	return 0;
}

虚函数的重写有三个例外：析构函数，协变，派生类中可以不写virtual

3.1派生类中可以不写virtual

基类中写了virtual，那么派生类中可以不写virtual，编译器会认为满足重写
基类中不写virtual，那么不满足重写，因为该函数不是虚函数

class person
{
public:
	virtual void BuyTicket()
	{
        cout << "没有折扣" << endl;
    }
};
class student:public person
{
public:
	//virtual void BuyTicket()     写不写都可以，但是推荐写virtual
	void BuyTicket()
	{
        cout << "半价" << endl;
    }
};

3.2析构函数

如果基类的析构函数为虚函数，那么不管派生类中的析构函数写不写virtual都构成重写，这里可以理解为编译器对析构函数名进行了特殊处理，编译后析构函数名统一处理为destructor


class person
{
public:
	virtual ~person()
	{
        
    }
};
class student:public person
{
public:
	// ~student()
	virtual ~student()
	{
        
    }
};

3.3协变

如果虚函数的返回值类型是基类和其派生类关系的指针/引用也算是构成重写。这种情况称为协变。
这里的基类和派生类不仅仅是当前的基类与派生类，还可以是其他

class person
{
public:
	virtual person& func()
	{}
};
class student:public person
{
public:
	virtual student& func()
	{}
};

4.override和final（c++11）

4.1override

override：检查派生类虚函数是否重写了某个基类的虚函数，没有重写直接编译报错

class person
{
public:
	virtual person& func()
	{}
};
class student:public person
{
public:
	virtual student& func () override
	{}
};

4.2final

final：修饰基类虚函数，表示该虚函数不能被重写。

class person
{
public:
	virtual person& func() final
	{}
};
class student:public person
{
public:
	virtual student& func ()
	{}
};

5.重载，覆盖(重写)，隐藏（重定义）对比

重载：两个函数必须在相同作用域，且函数名相同，参数不同
覆盖(重写)：两个函数分别在基类和派生类作用域中，且满足返回值，参数，函数名都相同（协变，析构函数是例外），两个函数必须是虚函数
隐藏(重定义)：两个函数分别在基类和派生类作用域中，且只要满足函数名相同即可，，只要不是重写，就是隐藏

二.抽象类

2.1纯虚函数

在虚函数后面加=0该函数就是纯虚函数，包含纯虚函数的类叫做抽象类，也叫做接口类。抽象类不能实例化对象，其继承的派生类也不能实例化对象，只有对纯虚函数进行重写，派生类才能实例化对象

纯虚函数间接规定了派生类对虚函数进行重写，因为不重写就不能实例化对象。
override是直接规定了派生类必须对虚函数进行重写，否则会报错

class person
{
public:
	virtual person& func() = 0;
	
};
class student:public person
{
public:
	virtual student& func () override
	{}
};

2.2接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承了基类虚函数的接口，目的是为了重写虚函数，达到多态，继承的是接口。如果不实现多态，也就没必要定义虚函数。

三.多态的底层原理

调试环境：visual stdio 2019 ，32位
测试代码：

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 6;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 5;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

在监视窗口可以看到，每个对象模型中，不仅仅有数据成员，还有一个__vfptr,这里的v是virtual，f是function，ptr是指针。这个指针我们叫做虚函数表指针(虚表指针)，指向的是虚函数表(虚表)，虚表存放的是虚函数的地址。一个含有虚函数的类，至少有一个虚表指针。

为什么要在对象模型中，存放虚函数指针？

多态的构成条件之一是：由基类的指针/引用来调用虚函数，那么如何根据指针/引用指向的不同来确定到底调用的是基类的虚函数还是派生类的虚函数呢，下图是基类指针/引用指向派生类对象和基类对象的逻辑结构图。如果在对象模型中存放了虚表指针，那么我们就可以通过指针来访问虚表，进而确定访问哪个虚函数。如果对象模型中没有虚表指针，那么编译器就无法根据基类指针/引用指向的类型来确定调用虚函数。