C++如何使用虚函数实现接口抽象

class Animal {
public:
    virtual void makeSound() = 0; // 纯虚函数
    virtual ~Animal() {} // 虚析构函数，保证派生类对象能被正确析构
};

= 0

makeSound

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Meow!" << std::endl;
    }
};

override

Animal* animal1 = new Dog();
Animal* animal2 = new Cat();

animal1->makeSound(); // 输出 "Woof!"
animal2->makeSound(); // 输出 "Meow!"

delete animal1;
delete animal2;

animal1

animal2

Animal

Dog

Cat

makeSound()

delete

class Base {
public:
    ~Base() { std::cout << "Base destructor called" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { data = new int[10]; }
    ~Derived() {
        std::cout << "Derived destructor called" << std::endl;
        delete[] data;
    }
private:
    int* data;
};

int main() {
    Base* b = new Derived();
    delete b; // 如果 Base 的析构函数不是虚函数，只会调用 Base 的析构函数，导致内存泄漏
    return 0;
}

Base

delete b

Derived

Base

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

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

int main() {
    Derived d;
    d.interface(); // 输出 "Derived implementation"
    return 0;
}