Pointer如何实现多态

在C++中，指针可以通过多种方式实现多态。以下是几种常见的方法：

1. 虚函数（Virtual Functions）

虚函数是实现运行时多态的基础。通过在基类中声明虚函数，并在派生类中重写这些函数，可以使用基类指针或引用来调用派生类的实现。

#include <iostream>

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

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

int main() {
    Base* basePtr;
    Derived derivedObj;

    basePtr = &derivedObj;
    basePtr->display(); // 输出: Display of Derived

    return 0;
}

2. 纯虚函数（Pure Virtual Functions）

纯虚函数是在基类中声明的没有实现的虚函数，它使得基类成为抽象类。派生类必须实现这些纯虚函数。

#include <iostream>

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

class ConcreteDerived : public AbstractBase {
public:
    void pureVirtualFunction() override {
        std::cout << "Implementation of pureVirtualFunction in ConcreteDerived" << std::endl;
    }
};

int main() {
    AbstractBase* abstractBasePtr;
    ConcreteDerived concreteDerivedObj;

    abstractBasePtr = &concreteDerivedObj;
    abstractBasePtr->pureVirtualFunction(); // 输出: Implementation of pureVirtualFunction in ConcreteDerived

    return 0;
}

3. 抽象类（Abstract Classes）

抽象类是不能实例化的类，通常包含至少一个纯虚函数。通过抽象类指针或引用，可以指向派生类对象并调用其实现。

#include <iostream>

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

class ConcreteClass : public AbstractClass {
public:
    void abstractMethod() override {
        std::cout << "Implementation of abstractMethod in ConcreteClass" << std::endl;
    }
};

int main() {
    AbstractClass* abstractClassPtr;
    ConcreteClass concreteClassObj;

    abstractClassPtr = &concreteClassObj;
    abstractClassPtr->abstractMethod(); // 输出: Implementation of abstractMethod in ConcreteClass

    return 0;
}

4. 接口（Interfaces）

在某些编程语言中，接口是一种特殊的抽象类，只包含纯虚函数。通过接口指针或引用，可以实现多态。

#include <iostream>

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

class ImplementingClass : public Interface {
public:
    void interfaceMethod() override {
        std::cout << "Implementation of interfaceMethod in ImplementingClass" << std::endl;
    }
};

int main() {
    Interface* interfacePtr;
    ImplementingClass implementingClassObj;

    interfacePtr = &implementingClassObj;
    interfacePtr->interfaceMethod(); // 输出: Implementation of interfaceMethod in ImplementingClass

    return 0;
}

总结

通过使用虚函数、纯虚函数、抽象类和接口，可以在C++中实现多态。这些机制允许基类指针或引用指向派生类对象，并调用派生类的实现，从而实现运行时多态。