C++多态与动态绑定详解-优快云博客

//动物类
class Aninal
{
public:
    virtual void speak()
    {
        cout << "动物在说话" << endl;   
    }
};

//猫类
class Cat : public Aninal
{
public:
    void speak()
    {
        cout << "小猫在说话" << endl;
    }
};

//执行说话的函数
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，这个函数的地址不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
void doSpeak(Aninal &animal)
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);
}

int main()
{
    test01();
    return 0;
}

二.多态的深入剖析

C++ 中的多态是通过虚函数表（vtable）和虚函数表指针（vptr）来实现的。每个包含虚函数的类（或者从这样的类派生的类）都有一个虚函数表，这个表中存储了虚函数的地址。每个这样的对象都有一个虚函数表指针，这个指针指向该对象所属类的虚函数表。

当你通过基类指针或引用调用虚函数时，编译器会生成代码来获取虚函数表指针，然后通过这个指针找到虚函数表，再从表中获取虚函数的地址，最后调用这个地址对应的函数。这个过程发生在运行时，所以称为动态绑定。

class Base {
public:
    virtual void foo() { std::cout << "Base::foo" << std::endl; }
};

class Derived : public Base {
public:
    void foo() override { std::cout << "Derived::foo" << std::endl; }
};

int main() {
    Base* ptr = new Derived();
    ptr->foo();  // 输出 "Derived::foo"
    delete ptr;
    return 0;
}

三.纯虚函数和抽象类

1.纯虚函数的作用

定义接口：纯虚函数允许你定义一个接口，这个接口在基类中没有具体的实现，而是在派生类中实现。这使得你可以编写与具体实现无关的代码，只需要依赖接口。
禁止实例化：包含纯虚函数的类被称为抽象类，抽象类不能被实例化。这可以确保只有实现了所有纯虚函数的派生类才能被实例化。
强制派生类实现：如果一个类从抽象类派生，并且想要成为一个可以实例化的类，那么它必须实现基类中的所有纯虚函数。这确保了派生类必须提供某些特定的行为。

2.纯虚函数的实现

//纯虚函数及抽象类
class test
{
public:
    //子类类必须重写父类中的纯虚函数，否则也是抽象类
    //抽象类不能实例化对象
    virtual void print() = 0;
};

class test1 : public test
{
public:
    virtual void print()
    {
        cout << "test1" << endl;
    }
};

void test3()
{
    test * p = new test1;
    p->print();
    delete p;
}

int main()
{
    test3();
    return 0;
}

四.虚析构和纯虚析构

1.虚析构和纯虚析构的概念

虚析构函数：如果你有一个指向派生类对象的基类指针，并且通过这个指针删除对象，那么如果基类的析构函数不是虚函数，就只会调用基类的析构函数，而不会调用派生类的析构函数，这可能会导致资源泄漏。如果基类的析构函数是虚函数，那么就会先调用派生类的析构函数，然后再调用基类的析构函数，这样就可以正确地清理资源。

纯虚析构函数：纯虚析构函数是一种特殊的虚析构函数，它在基类中没有实现（或者说，它的实现被声明为 0）。包含纯虚析构函数的类是抽象类，不能被实例化。纯虚析构函数必须在基类中提供定义，否则在删除派生类对象时会出错。

2.虚析构和纯虚析构的实现

//虚析构和纯虚析构
class Animal
{
public:
    Animal()
    {
        cout << "Animal的构造函数调用" << endl;
    }
    //虚析构和纯虚析构就是用来解决通过父类指针释放子类对象
    //如果子类中有属性开辟了堆区数据，那么父类指针释放的时候就无法调用到子类的析构代码
    //导致子类出现内存泄漏
    //virtual ~Animal()
    //{
    //	cout << "Animal的析构函数调用" << endl;
    //}
    virtual ~Animal() = 0;
    virtual void speak() = 0;
};

Animal::~Animal()
{
    cout << "Animal的纯虚析构函数调用" << endl;
}

class Cat : public Animal
{
public:
    Cat(string name)
    {
        cout << "Cat的构造函数调用" << endl;
        m_Name = new string(name);
    }
    virtual void speak()
    {
        cout << *m_Name << "小猫在说话" << endl;
    }
    ~Cat()
    {
        if (m_Name != NULL)
        {
            cout << "Cat的析构函数调用" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
    string *m_Name;
};

void test01()
{
    Animal *animal = new Cat("Tom");
    animal->speak();
    delete animal;
}

int main()
{
    test01();
    return 0;
}

总结

1. 多态是面向对象编程的核心概念，可以通过基类指针或引用操作派生类对象。C++中主要通过虚函数实现多态。
2. 多态分为静态多态（编译时多态）和动态多态（运行时多态）。静态多态主要通过函数重载和运算符重载实现。动态多态主要通过虚函数实现。
3. 多态的主要优点是提高代码的可扩展性和可维护性。使用基类指针或引用可以编写能处理任何派生类对象的通用代码，而无需知道对象的具体类型。
4. 为了实现动态多态，需要满足三个条件：有一个基类和至少一个派生类，基类中有一个或多个虚函数，并在派生类中被重写，使用基类的指针或引用来指向派生类的对象。
5. C++实现动态多态主要通过虚函数表（vtable）和虚函数表指针（vptr）。虚函数的运行过程是动态绑定的。
6. 纯虚函数和抽象类用来定义接口，其中定义的函数在基类中没有具体实现，而在派生类中实现。抽象类不能被实例化，只能通过派生类进行实现。
7. 虚析构和纯虚析构用于在删除基类指针时，能正确析构派生类对象，防止资源泄漏。