如何通过父类对象向量调用子类的重写函数？

你的代码实际输出是AA而非预期的BC，核心原因是对象切片（Object Slicing）。当你将子类对象B、C存入std::vector<A>时，容器只会拷贝父类A的部分，子类独有的数据和虚函数表被截断，导致调用print()时始终执行父类的实现。

方案1：使用指针容器 #

用std::vector<A*>存储指向子类对象的指针，避免对象切片。指针指向的是完整的子类对象，虚函数调用会触发动态绑定：

#include <iostream>
#include <vector>

class A
{
public:
    virtual void print() { std::cout << "A"; }
    // 父类必须声明虚析构，避免内存泄漏
    virtual ~A() = default;
};

class B: public A
{
public:
    void print() override { std::cout << "B"; }
};

class C: public A
{
public:
    void print() override { std::cout << "C"; }
};

int main()
{
    std::vector<A*> list;

    B* obj1 = new B();
    list.push_back(obj1);

    C* obj2 = new C();
    list.push_back(obj2);

    for(A* ptr : list)
        ptr->print(); // 输出BC

    // 手动释放内存
    for(A* ptr : list)
        delete ptr;

    return 0;
}

方案2：使用智能指针（推荐） #

用std::unique_ptr或std::shared_ptr管理指针，无需手动释放内存，更安全：

#include <iostream>
#include <vector>
#include <memory> // 包含智能指针头文件

class A
{
public:
    virtual void print() { std::cout << "A"; }
    virtual ~A() = default;
};

class B: public A
{
public:
    void print() override { std::cout << "B"; }
};

class C: public A
{
public:
    void print() override { std::cout << "C"; }
};

int main()
{
    std::vector<std::unique_ptr<A>> list;

    // 直接在容器中构造子类对象
    list.emplace_back(std::make_unique<B>());
    list.emplace_back(std::make_unique<C>());

    for(const auto& ptr : list)
        ptr->print(); // 输出BC

    // 无需手动释放内存，智能指针会自动管理
    return 0;
}

std::unique_ptr是独占式智能指针，适合不需要共享所有权的场景；如果需要多个指针共享对象，可改用std::shared_ptr。

内容的提问来源于stack exchange，提问作者zogac