【C++】多态

蒋灵瑜

已于 2023-08-30 20:30:04 修改

阅读量2.1k

点赞数 30

分类专栏： C++ 文章标签： c++ 算法开发语言多态

于 2023-01-18 18:08:06 首次发布

本文链接：https://blog.csdn.net/gfdxx/article/details/128728928

版权

C++ 专栏收录该内容

22 篇文章 26 订阅

订阅专栏

需要云服务器等云产品来学习Linux的同学可以移步/-->腾讯云<--/-->阿里云<--/-->华为云<--/官网，轻量型云服务器低至112元/年，新用户首次下单享超低折扣。

4.1协变（返回值分别为构成父子关系的指针或引用，也构成重写）

4.2析构函数是虚函数的场景（动态申请的子类对象，交给父类指针管理，需要virtual修饰析构函数）

四、C++11中的final和override

1、C++98防止一个类被继承的方法

2、C++11的final关键字

2.1final修饰类，防止该类被继承

2.2final修饰虚函数，防止该虚函数被重写

3、C++11的override关键字

override修饰子类重写的虚函数，检查是否完成重写

2.2为什么一定要传入从子类对象切片而来的父类对象的指针/引用才能引发多态？为什么不能直接传入切片的父类对象？

2、重载、重写（覆盖）、重定义（隐藏）的区别？

一、多态的概念

多态指多种形态。不同的对象完成同一件事情，但是结果不同。例如公交刷卡行为：成人刷卡全价，学生刷卡半价。亦或是不同的客户来消费，金卡会员8折，银卡会员9折，普通会员无折扣。

二、静态的多态

静态的多态是在编译时产生不同。例如函数重载就是一种静态的多态行为。看上去是在调用同一个函数，但是会产生不同的行为。

int main()
{
    int a=1;
    double b=2.3;
    std::cout<<a<<std::endl;
    std::cout<<b<<std::endl;
    return 0;
}

三、动态的多态

动态的多态是在运行时产生不同。

构成多态的条件：缺一不可，否则就不构成多态。

1、必须通过父类对象的引用或指针当做形参调用虚函数。（仅限引用和指针是原因见下文）

2、子类必须完成对父类虚函数的重写且被调用的函数是虚函数。

1、虚函数

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

被virtual关键字修饰的类的非静态成员函数称为虚函数。

注意虚函数和虚继承虽然都使用了virtual关键字，但是它们没有关系。

1、子类重写父类虚函数时，子类“三同”函数不写virtual也构成重写，但是不规范。C++设计者的初衷是父类写了virtual，即使子类不写，也构成多态，那就不会出现内存泄漏的情况了。（设计项目时可能父类和子类并不是同一个人写的，那么子类程序员没写virtual的概率极大）

2、可以这样理解：虽然子类对应函数没写virtual，但他先继承了父类中虚函数的“虚”属性，再完成重写。注意：类作用限定符也会被子类继承，如果父类虚函数是public，即使子类重写函数是private，也会变成public

2、虚函数的重写（覆盖）

如果父类中存在虚函数，并且子类拥有“三同”成员函数：返回值类型、函数名称、参数列表均相同。那么子类的虚函数就是对父类虚函数的重写。例如上面例子中Student::BuyTicket()是Person::BuyTicket() ，它们构成重写，而不是构成隐藏。

重写还有一个叫法是覆盖。子类重写父类的虚函数意为子类重写的函数会覆盖父类的这个虚函数。（下文会细讲）

3、利用虚函数的重写实现多态

class Person 
{
public:
    virtual void BuyTicket() 
    { 
        cout << "买票-全价" << endl;
    }
};
class Student : public Person
{
public:
    virtual void BuyTicket()
    {
        cout<<"买票-半价"<<endl;
    }
};
void Func(Person& p)//子类传入会被切片，所以可以不用const/构成多态，跟p类型无关，传子调子，传父调父
{
    p.BuyTicket();
}
int main()
{
    Person p;
    Student s;
    //传入父类对象，调用父类的BuyTicket();传入子类对象将调用子类的BuyTicket();
    Func(p);
    Func(s);//这里的s会被切片传参
}

先看构不构成多态，构成多态，那么和对象类型无关，传入哪个对象的引用/指针就使用谁的虚函数。

如果不构成多态，均调用p类型的函数。

4、虚函数重写的例外

4.1协变（返回值分别为构成父子关系的指针或引用，也构成重写）

构成重写需要成员函数返回值相同，但是存在例外，当返回值是构成父子关系的指针或引用时，它们也构成重写。这种重写叫做协变。不过父类返回值一定要用父指针/父引用，子必须用子指针/子引用，不能颠倒。

4.2析构函数是虚函数的场景（动态申请的子类对象，交给父类指针管理，需要virtual修饰析构函数）

class Person 
{
public:
    virtual ~Person()
    {}
};
class Student : public Person
{
public:
    virtual ~Student()
    {}
};

析构函数也可重写，虽然父子析构函数的函数名表面上不一样，但其实所有析构函数的函数名都会被处理成destructor。

下面看个场景：

各new一个父类/子类的对象，交给父类指针管理，这没问题。但是在析构的时候，因为是父类指针，所以p1p2都会去调用父类的析构函数，但别忘了起初我们可是new了一个子类对象，如果子类对象中存在资源，那么就会导致内存泄漏！

为了避免这种情况，就需要使用virtual关键字修饰析构函数：

父子构造函数构成多态，那就不看p1p2的类型了，p1p2指向哪个对象，就调用哪个对象的析构函数。

四、C++11中的final和override

1、C++98防止一个类被继承的方法

class Person
{
public:
    static Person CreateObj()
    {
        //new Person;
        return Person();
    }
private:
    Person()
    {}
};
class Student : public Person
{
public: 
};
int main()
{
	Person p=Person::CreateObj();
    return 0;
}

C++98通过把构造函数变为私有的方式，让子类继承后根本构造不出父类对象。

但是父类却可以通过静态的“偷家”函数构造对象。（这里必须静态，静态成员函数调用无需借助对象。如果是非静态成员函数，则需要对象才能调用，但是生成对象必须通过这个函数······无限循环了）

2、C++11的final关键字

2.1final修饰类，防止该类被继承

class Person final
{
public:
};

Person被final修饰后将不能被继承，

2.2final修饰虚函数，防止该虚函数被重写

3、C++11的override关键字

override修饰子类重写的虚函数，检查是否完成重写

为了防止程序员在子类进行重写时，函数名拼写出现错误，这就造成了重写的函数和父类被重写的函数对不上。这是个很严重的问题，因为这种情况并不违反语法规则，编译期间编译器是不会报错的，只有在程序运行时发现结果不对，回去debug时才能发现问题。

C++很贴心的增加了override关键字，成员函数被修饰后，编译器会帮忙检查是否重写成功。

五、重载、重写、隐藏的区别

六、抽象类（接口类）

1、抽象类的概念

在虚函数的后面加上=0，则这个函数被称为纯虚函数。包含纯虚函数的类被称为抽象类（接口类）。一个类型，在现实世界中没有对应的实物，就可以定义为抽象类。例如职能类、Person类等。

抽象类不能实例化出对象。

class Person 
{
public:
    virtual void Func()=0
    {
        //纯虚函数一般只声明，不实现。因为没有对象
    }
};

子类继承了父类的纯虚函数，子类也变成了抽象类，同样不能实例化出对象。

除非子类重写纯虚函数，子类才能实例化出对象。

抽象类的作用是强制子类进行重写。

2、实现继承和接口继承

子类继承父类的普通函数，是为了使用该函数的具体实现，这是实现继承。

而虚函数是为了让子类进行重写，实现多态，子类只继承了函数名，并不继承具体实现，这是接口继承，接口继承会继承父类的类作用限定符和缺省参数。

所以不准备实现多态的话，就不要用virtual去修饰成员函数了。

七、多态的实现原理

1、虚函数表

注意：虚函数表指针并不一定放在所有成员变量的最前面，有的编译器会放在最后面。虚函数表指针指向的虚函数表本质是存放虚函数指针的函数指针数组，vs下会在这个数组最后放一个nullptr，而Linux不会。

虚函数表存放于常量区（代码段）。

vs中虚函数表中存放的并不是虚函数的地址，而是一句jump指令的地址，通过该jump指令找到对应的虚函数。

再看一段代码：

p能调用Func1是因为Func1并不存放在类中，而是在代码区，所以p->Func1并不是解引用，而是将p当做形参传递给this。

p调不了Func2是因为虚函数需要通过类对象中的虚函数表指针找到对应的虚函数进行调用，所以它是一个解引用行为，p是nullptr，对空指针的解引用行为引发程序崩溃。

2、多态的原理

2.1形成多态的原因

class Person
{
public:
    virtual void BuyTicket()
    {
        cout << "买票-全价" << endl;
    }
private:
    int _a;
};
class Student : public Person
{
public:
    virtual void BuyTicket()
    {
        cout << "买票-半价" << endl;
    }
private:
    int _b;
};
void Func(Person& p)//子类传入会被切片，所以可以不用const/构成多态，跟p类型无关，传子调子，传父调父
{
    p.BuyTicket();
}
int main()
{
    Person p;
    Student s;
    //传入父类对象，调用父类的BuyTicket();传入子类对象将调用子类的BuyTicket();
    Func(p);
    Func(s);//这里的s会被切片传参
}