C++面向对象三大特性--多态

文章目录

- - C++面向对象三大特性--多态
  - - [1.虚函数（Virtual Function）](#1.虚函数（Virtual Function）)
    - [2.纯虚函数（Pure Virtual Function）和抽象类（Abstract Class）](#2.纯虚函数（Pure Virtual Function）和抽象类（Abstract Class）)
    - 3.重写（Override）
    - [4.动态绑定（Dynamic Binding）或迟绑定（Late Binding）](#4.动态绑定（Dynamic Binding）或迟绑定（Late Binding）)
    - 5.虚析构函数和纯虚析构

C++中的多态（Polymorphism）是一种面向对象编程的重要特性，它允许你使用一个接口来表示不同的类型。C++中的多态主要通过虚函数（Virtual Functions）来实现，包括静态多态（编译时多态，主要是函数重载和模板）和动态多态（运行时多态）。下面将介绍C++中动态多态的基础语法：

1.虚函数（Virtual Function）

虚函数是实现动态多态的关键。在基类中声明函数为虚函数，使得派生类可以重写该函数。虚函数的声明需要在基类的函数声明前加上virtual关键字。

cpp 复制代码

class Base {
public:
    virtual void display() { /* 默认实现 */ }
    // 注意：析构函数建议声明为虚函数，以确保通过基类指针删除对象时能正确调用派生类的析构函数
    virtual ~Base() {}
};

class Derived : public Base {
public:
    void display() override { /* 重写实现 */ }
};

//
// Created by 86189 on 2024/6/22.
//
#include <iostream>

using namespace std;

class Animal {
public:
    virtual void speak() {
        cout << "Animal speak" << endl;
    }
};

class Dog : public Animal {
    void speak() override {
        cout << "Dog speak" << endl;
    }
};

class Cat : public Animal {
    void speak() override {
        cout << "Cat speak" << endl;
    }
};

void doWork(Animal &p) {
    p.speak();
}

int main() {
    Animal *p = new Dog(); // 动态绑定 父类的指针指向子类对象
    p->speak();
    Animal *p2 = new Cat();
    p2->speak();

    Cat c;
    Dog d;
    doWork(c);   //父类的引用指向子类对象
    doWork(d);

    delete p;
    delete p2;
    return 0;
}

2.纯虚函数（Pure Virtual Function）和抽象类（Abstract Class）

纯虚函数是在基类中没有具体实现的虚函数，要求派生类必须提供实现。含有纯虚函数的类称为抽象类，不能实例化。

cpp 复制代码

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

// Base类现在是一个抽象类，不能直接创建对象
// Base b; // 错误

class Derived : public Base {
public:
    void func() override { /* 实现 */ }
};

//
// Created by 86189 on 2024/6/22.
//
#include <iostream>
using namespace std;

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


//派生类必须重写纯虚函数  否则无法实例化对象
class Derived : public Base {
public:
    void func() override {
        cout << "Derived::func()" << endl;
    }
};

int main() {
    Base *p = new Derived();
    p->func();
    return 0;
}

3.重写（Override）

在派生类中重新定义基类的虚函数称为重写。使用override关键字可以明确指出某个函数是重写的意图，同时编译器会进行检查，确保该函数确实是在重写基类的一个虚函数。

cpp 复制代码

class Derived : public Base {
public:
    void display() override { /* 重写实现 */ }
};

4.动态绑定（Dynamic Binding）或迟绑定（Late Binding）

动态绑定是运行时根据对象的实际类型来决定调用哪个函数的机制。这要求通过基类指针或引用来调用虚函数。如果直接通过对象名调用，则仍然是静态绑定。

cpp 复制代码

Base* basePtr = new Derived();
basePtr->display(); // 运行时会调用Derived类的display()
delete basePtr;

5.虚析构函数和纯虚析构

5.1虚析构函数

基类的析构函数应该声明为虚函数，以确保当通过基类指针删除派生类对象时，能够正确地调用派生类的析构函数，避免内存泄漏。

在多态场景中，如果基类的析构函数不是虚函数，当通过基类指针删除派生类对象时，只会调用基类的析构函数，而派生类特有的资源可能不会被正确释放，从而导致资源泄漏或更严重的问题。

解决这个问题的方法很简单，就是确保所有包含纯虚函数的抽象基类，其析构函数也应该是虚函数。这样，无论通过基类指针指向的是基类对象还是派生类对象，都能够保证调用到正确的析构函数链，从派生类开始，逐级向上调用到基类的析构函数，彻底释放资源。

cpp 复制代码

//
// Created by 86189 on 2024/6/23.
//
#include <iostream>
using namespace std;

class Base {
public:
    virtual void func () = 0;
    virtual ~Base() {
        cout << "Base::~Base()" << endl;
    }
};

class Derived : public Base {
public:
    void func() override {
        cout << "Derived::func()" << endl;
        p = new int(10);
    }
    ~Derived() override {
        cout << "Derived::~Derived()" << endl;
        delete p;
    }
    int *p{};
};

int main() {
    Derived d;
    Base *p = new Derived();
    p->func();
    delete p;
    return 0;
}

定义：当在基类中将析构函数声明为虚函数时，它就成为了虚析构函数。声明时不需要赋值为0，格式为 virtual ~ClassName() {}。
用途：确保当通过基类指针或引用删除派生类对象时，能够调用到派生类的析构函数，从而正确释放派生类特有的资源。如果不声明为虚析构，那么仅基类的析构函数会被调用，可能导致派生类的资源泄露。
实例化：声明了虚析构函数的类仍然可以实例化对象，不是抽象类。

5.2纯虚析构函数

定义：在基类中将析构函数声明为纯虚函数，即在声明后加上= 0，格式为 virtual ~ClassName() = 0;。需要注意的是，纯虚函数需要在类外提供定义。
用途：与虚析构函数类似，用于确保多态销毁时调用正确的析构函数。但除此之外，声明了纯虚析构函数的类自动成为抽象类。
实例化：拥有纯虚析构函数的类是抽象类，这意味着不能直接实例化此类的对象。抽象类的主要目的是作为其他类的基类，强制要求派生类实现某些纯虚函数（不仅仅是析构函数）。

cpp 复制代码

//
// Created by 86189 on 2024/6/23.
//
#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() = 0;  // 纯虚析构函数 确保了派生类中内存可以被释放
};
class Derived : public Base {
public:
    void func() {
        cout << "func()" << endl;
        p = new int(10);
    }
    ~Derived() override {
        cout << "~Derived()" << endl;  //纯虚析构保证了释放派生类中申请的内存
        delete p;
        p = nullptr;
    }
    int *p{};
};

Base::~Base() {
    cout << "Base()" << endl;
}

int main() {
    Derived d;
    d.func();
    Base *p = new Derived();
    delete p;
    return 0;
}

5.3总结

两者都用于支持多态性下的正确资源管理，但纯虚析构函数额外具有将类定义为抽象类的特性。选择使用哪一种取决于你的设计需求：如果你希望基类可以实例化，并且需要多态性的析构，使用虚析构函数；如果你的基类根本就不应该直接实例化，而总是作为派生类的基类，并且同样需要多态性的析构，那么纯虚析构函数更为合适。