新C++(7):多态那些事儿_上

news2024/10/7 18:20:46

"也应该歌颂赞美那株鲜红的玫瑰。"

一、回顾多态

(1)什么是多态呢

在编程语言和类型轮中，多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。多态类型(英语:polymorphic type）可以将自身所支持的操作套用到其它类型的值上。取自这里

所谓多态，通俗来讲就是多种形态。当不同的对象去执行同一个行为，产生处不同的结果和状态。我们举一个买车票的例子，普通人买车票对应的是"全价",学生呢买车票则对应的是"半价",军人买票呢，对应的是"优先买票"。

(2)多态的定义

多态形成的条件:
①虚函数完成重写
②父类的指针或者引用去调用虚函数

虚函数;

什么是虚函数呢？C++定义了一个关键字virtual，这个肯定不陌生，因为在前篇谈论虚继承的时候，这位仁兄出现过，展现出了它惊人的一面。

virtual void func(){}

虚函数的重写(覆盖)要求:
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)

我们根据上述的场景，简单来实现一份多态的代码吧~

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

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

class Soidler :public Person
{
    virtual void BuyTicket() { cout << "Soidler -- 买票-军人优先" << endl; }
};

此时还不是多态。因为我们都知道，那个对象就调用哪个对象的类成员方法。我们还差一个条件，"父类的指针引用去调用虚函数"。

显然，颠覆我们的认知。不管是student、soidler、person都传递给父类引用，但是因为多态的条件达成，那么传递的什么类型，就去调用什么类型中被重写(覆盖)。

(3)override\final

继承final:

如果你不想让一个类被继承，那么你应该让它的构造函数声明为私有；

这是C++11之期解决类不能被继承的写法。C++11后引入了final关键字表示该类不能被继承。

虚函数final:

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

overrid

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

二、多态与析构函数

在继承中，我们层提到，在子类的析构函数中，不用显式去调用父类的析构函数，因为当子类的析构函数结束后，就会去调用父类的析构函数。

我们来看看下面的一段代码;

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

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


int main()
{
    Person* ptr1 = new Person;
    Person* ptr2 = new Student;
    
    delete ptr1;
    delete ptr2;

    return 0;
}

delete类，要做两件事:调用释放类的析构函数，再调用operator.delete()。

我们析构ptr1那么很好，它成功地帮我释放了Person中的数组。delete ptr2时，它仅仅帮我们完成了父类的析构函数。难道你会指着编译器抱怨，不去释放那子类对象动态开辟的空间，而造成的内存泄漏的问题？当然不行！这怨不得人家，因为它严格按照，自己是什么类，就去调用该类的拥有的什么成员方法。

似乎我们预想的是，让ptr2delete的时候，不是去调用它类型的析构,而是去调用new的对Student的析构。看到这里我们想到了什么？？？父类的指针引用调用重写的虚函数构成多态！

 class Person
{
public:
    //虚函数
    virtual ~Person()
    {
        cout << "Person delete:" << _p << endl;
        delete[] _p;
    }
protected:
    int* _p = new int[10];
};

class Student : public Person
{
public:
    //虚函数
    virtual ~Student()
    {
        cout << "Student delete:" << _s << endl;
        delete[] _s;
    }
protected:
    int* _s = new int[20];
};

同时，这里也回答了上一篇中，为什么在编译器看来基类与派生类的析构函数，都会做特殊处理成一样的函数(destructor)。就是为了实现多态的析构函数。

请记住:
"为多态基类声明virtual析构函数"。这是永远不会错的。

三、sizeof(Base)

我们看看下面的代码,你能否计算该类的大小？

class A
{
public:
    void Func(){}
private:
    int _a;
    char _b;
};

内存对齐！这可难不到我，_a占4字节，_b占1字节，内存对齐到8。A的大小为8byte。

嗯？还不错，确实是8字节。

class A
{
public:
    virtual void Func(){}
private:
    int _a;
    char _b;
};

这难道不是同一道题？这么送分的嘛？

这怎么回事儿？为什么加上虚函数，类的大小就变了呢？

这个是因为，当类有虚函数时，就会给类增加一个结构,"虚函数表指针"。那么这个虚函数表指针的讲解不在本篇，也就此略过。

四、抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。
包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

同时，这也要求了，该基类的派生类必须完成重写，否则无任何意义。

class Car
{
public:
     //纯虚函数
    virtual void Drive() = 0;
};

class BMW : public Car
{
public:
};

int main()
{
    BMW b;
    return 0;
}

class Car
{
public:
     //纯虚函数
    virtual void Drive() = 0;
};

class BMW : public Car
{
public:
    virtual void Drive()
    {
        cout << "驾驶乐趣" << endl;
    }
};

int main()
{
    BMW b;
    return 0;
}

接口继承vs实现继承:

普通函数的继承是一种实现继承,派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。

五、经典考察

我们最后以一道面试题作为本篇的结束。

class A
{
public:
    virtual void func(int val = 1){ std::cout << "A->" << val << std::endl; }
    void test() { func(); }
};

class B : public A
{
public:
    virtual void func(int val = 0){ std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
    B*p = new B;
    p->test();
    return 0;
}

程序应该打印成什么？