C++多态用法

最新推荐文章于 2024-08-02 23:45:14 发布

Obto-

最新推荐文章于 2024-08-02 23:45:14 发布

阅读量233

点赞数 2

分类专栏： c++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/Obto_/article/details/127777896

版权

c++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

目录：

c++11 override 和 final

重载，覆盖（重写），隐藏（重定义）的对比

抽象类

总结

多态的概念

通俗的来讲，就是一个事件的多种形态，具体就是去完成某个行为时，不同的对象去完成时会产生不同的状态。

比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

多态的分类

--> 静态多态

静态多态就是指在 编译时 实现的多态，比如：函数重载 看似调用同一个函数，实则不然

int i = 1;
int j = 1.1;
cout << i << endl;
cout << j << endl;

虽然调用的都是<< ，但其实是调用不同形参的重载之后的函数

-->动态多态

动态多态实在运行时多态，当一个父类对象的引用或者指针接收子类或者父类的对象后，调用相同的函数会导致实际调用不同的函数。

构成多态的条件

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

-->被virtual修饰的函数叫做虚函数

虚函数的重写

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

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

class Student:public Person
{
public:
	virtual void BuyTicket()  //这里的virtual写不写都可以 但强烈建议写上更规范
	{
		cout << "买票半价" << endl;
	}
};

-->在重写基类虚函数时，派生类(子类)即使不加virtual也可以构成重写，因为继承后基类的虚函数被继承下来了在派生类中依旧保持原虚函数的属性，但强烈建议在派生类中也写上关键字virtual。

虚函数重写的两个例外 :
--> 协变(基类与派生类虚函数返回值类型不同):派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变

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;}
};

-->析构函数的重写：如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加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;
}

--> 析构派生类p1 会自动调用基类的析构函数

-->如果基类的析构没有加virtual那么就会对基类连续析构两次

c++11 override 和 final

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

-->final: 修饰虚函数，表示该虚函数不能被重写

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

-->override:检查是否重写，如果没有就报错

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

-->注意：final关键字放在父类，override关键字放子类

重载，覆盖（重写），隐藏（重定义）的对比

抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口
类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生
类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承

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

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

class BMW :public Car
{
public:
    virtual void Drive()
    {
        cout << "BMW-操控" << endl;
    }
};

void Test()
{
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;
    pBMW->Drive();
}
//输出Benz-舒适 \n BMW-操控

-->接口继承和实现继承：普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数.