C++中调用辅助类重写方法异常：为何未触发子类方法？

嘿，这个问题我太熟悉了——你遇到的是C++里经典的**对象切片（Object Slicing）**问题！咱们一步步拆解：

为什么输出是HelperBase而不是HelperChild？ #

你在Base类里定义的成员变量hb是HelperBase的实体对象，而不是指针或引用。当你把HelperChild对象传给Base的构造函数时，C++只会把HelperChild中属于HelperBase的那部分数据拷贝到hb里——HelperChild特有的部分（包括你重写的something()方法）被直接"切掉"了！

这就导致Base::print()里调用的hb.something()，其实是在调用被切片后的纯HelperBase对象的方法，自然输出HelperBase。而你在Child构造函数里直接调用helperChild.something()能正常输出，是因为那时候你操作的还是完整的HelperChild对象。

怎么改才能实现预期效果？ #

核心思路是：C++的多态必须通过指针或引用来触发，所以我们需要修改Base类存储辅助类的方式，同时不用重写庞大的print()方法，完美适配你的需求。

方案1：使用引用（简单直接，注意生命周期） #

把Base里的hb改成引用类型，这样它会一直绑定到你传入的HelperChild对象，不会被切片：

class Base {
public:
    // 这里用引用绑定传入的辅助类对象
    Base(HelperBase& helperBase) : hb(helperBase) {}
    virtual void print() {
        std::cout << "-- Base" << std::endl;
        hb.something(); // 现在会触发多态调用
    }
    HelperBase& hb; // 从实体对象改成引用
};

⚠️ 注意：引用的生命周期必须和Base对象一致，也就是说你传入的HelperChild对象不能比Base/Child对象先销毁，否则会出现悬空引用问题。

方案2：使用指针（更灵活，适合复杂场景） #

如果辅助类对象的生命周期不好控制，或者需要动态切换不同的辅助类实现，用指针会更灵活。甚至可以用智能指针避免内存泄漏：

原始指针版本：

class Base {
public:
    Base(HelperBase* helperBase) : hb(helperBase) {}
    virtual void print() {
        std::cout << "-- Base" << std::endl;
        hb->something(); // 指针调用虚函数触发多态
    }
    HelperBase* hb; // 改成指针
};

// 对应的Child构造函数也要调整参数类型
class Child : public Base {
public:
    Child(HelperChild* helperChild) : Base(helperChild) {
        helperChild->something();
    }
};

// 主函数调用时传地址
int main() {
    HelperChild helperChild;
    Child child(&helperChild);
    child.print();
    return 0;
}

智能指针版本（更安全）：

如果是动态创建的辅助类对象，推荐用std::unique_ptr或std::shared_ptr管理内存：

#include <memory> // 引入智能指针头文件

class Base {
public:
    // 用unique_ptr转移所有权，避免内存泄漏
    Base(std::unique_ptr<HelperBase> helper) : hb(std::move(helper)) {}
    virtual void print() {
        std::cout << "-- Base" << std::endl;
        hb->something();
    }
    std::unique_ptr<HelperBase> hb;
};

class Child : public Base {
public:
    Child(std::unique_ptr<HelperChild> helper) : Base(std::move(helper)) {
        // 如果需要在构造函数里调用HelperChild的方法，可以这样转换
        static_cast<HelperChild*>(hb.get())->something();
    }
};

int main() {
    auto helper = std::make_unique<HelperChild>();
    Child child(std::move(helper));
    child.print();
    return 0;
}

修改后的输出 #

不管用哪种方案，修改后程序的输出都会变成：

HelperChild
-- Base
HelperChild

完全符合你的预期，而且不需要改动Base::print()的任何逻辑，完美解决了你的痛点。

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