C++篇之多态

1，多态的概念

多态的概念：通俗的来讲，就是多种形态。多态分为编译时多态（静态多态）和运行时多态（动态多态）。这里主要讲的是运行时多态。

编译时多态：比如函数重载和函数模板，通过传不同类型的参数就可以调用不同的函数，通过参数不同达到多态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在 编译时完成的，我们把编译时⼀般归为静态，运⾏时归为动态。

运行时多态：具体点就是去完成某个⾏为(函数)，可以传不同的对象就会完成不同的⾏为，就达到多种 形态。

用生活中的一种例子来讲，比如买票这个行为：当学生买票时是半价，而当是成年人买票时就是全价。有几种不同的状态。

2，多态的定义及实现

2.1，虚函数

类成员函数前⾯加virtual修饰，那么这个成员函数被称为虚函数。注意⾮成员函数不能加virtual修饰。

2.2，虚函数的重写 

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

注：基类的重写虚函数可以加上virtual，也可以不加，一般建议加上 

2.3，多态的构成条件

多态是在继承关系下形成的。条件如下图：

示例：

  

总结：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向派⽣ 类对象；第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有不同的函数，多 态的不同形态效果才能达到。 

 2.4，协变

派⽣类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引 ⽤，派⽣类虚函数返回派⽣类对象的指针或者引⽤时，称为协变。

示例：

class A {};
class B :public A{};
class Person
{
public:
    virtual A* BuyTicket()
    {
        cout << "person买票全价" << endl;
        return nullptr;
    }
};
class Student :public Person
{
public:
    virtual B* BuyTicket()
    {
        cout << "Student买票半价" << endl;
        return nullptr;
    }
};
//这里参数也可以使用指针
void func(Person& p)
{
    p.BuyTicket();
}

int main()
{
    Person p;
    func(p);

    Student s;
    func(s);
    return 0;
}

2.5，析构函数的重写 

如果基类的析构函数为虚函数，那么派生类的虚函数只要定义，无论是否加virtual，都与基类的析构函数构成重写。

虽然他们的函数名不同，但可以理解为编译器做了特殊处理，编译后析构函数统一名称为destructor。

为什么要重写析构函数？下面的代码解释：（没有实现析构函数重写）

class A
{
public:
    ~A()
    {
        cout << "~A()" << endl;
    }
};
class B :public A
{
public:
    ~B()
    {
        cout << "~B()::p->" << p<<endl;
        delete p;
    }
protected:
    int* p = new int[10];
};

int main()
{
    A* p1 = new A;
    A* p2 = new B;

    delete p1;
    delete p2;
    return 0;
}

 运行结果：

可以看出，两个对象都调用的是A的析构，而p2new的是B类型的对象，应该调用B的析构， 这样就会造成内存泄漏的问题。所以需要对析构函数进行重写，在执行delete p2时，A和B的析构函数构成多态，回去调用B的析构函数，释放资源p;

class A
{
public:
    virtual ~A()
    {
        cout << "~A()" << endl;
    }
};
class B :public A
{
public:
    virtual ~B()
    {
        cout << "~B()::p->" << p<<endl;
        delete p;
    }
protected:
    int* p = new int[10];
};

int main()
{
    A* p1 = new A;
    A* p2 = new B;

    delete p1;
    delete p2;
    return 0;
}

运行结果：

 这里最后会再调用A的析构，是因为继承的原因。内容在上一节中。

2.6，override和final关键字

如果我们不想让派生类去重写该函数，可以用final修饰。

override可以检测虚函数是否重写成功。

2.7，重写/重载/隐藏的对比 

3，纯虚函数和抽象类

 在虚函数的后⾯写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现，只要声明即可

。包含纯虚函数的类叫做抽象类，抽象类不能实例 化出对象，如果派⽣类继承后不重写纯虚函数，那么派⽣类也是抽象类。纯虚函数某种程度上强制了 派⽣类重写虚函数，因为不重写实例化不出对象

4，多态的原理 

⼀个含有虚函数的类中都⾄少都有⼀个虚函数表指针，因为⼀个类所有虚函数的地址要 被放到这个类对象的虚函数表中，虚函数表也简称虚表。

class Base
{
public:
    virtual void Func1()
    {
        cout << "Func1()" << endl;
    }
protected:
    int _b = 1;
    char _ch = 'x';
};

int main()
{
    Base b;
    cout << sizeof(b) << endl;
    return 0;
}

//运行结果   16

 

由上图调试代码可以看出，除了_b和_ch成员，还多⼀个__vfptr放在对象的前⾯ ，这个指针就叫做虚函数表指针。

总结如下图所示：

class Base
{
public:
    virtual void Func1()
    {
        cout << "Base::Func1()" << endl;
    }
    virtual void Func2()
    {
        cout << "Base::Func2()" << endl;
    }
protected:
    int _b = 1;
};

class Drive :public Base
{
public:
    virtual void Func1()
    {
        cout << "Drive::Func1()" << endl;
    }

};
int main()
{
    Base b;
    Drive d;
    
    return 0;
}

 

从上图可以看出,d的虚函数表包含了重写的func1，也包含了基类的虚函数func2,其中func2没有被重写。 

原文地址：https://blog.csdn.net/2401_82677021/article/details/143890605

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！