C++子类多态返回类型问题：如何正确扩展Result类？

我希望实现一个包含纯虚函数process的抽象类Base，该函数返回Base::Result类型对象。我的设想是Base的子类可通过继承Base::Result来扩展Result类（如Child类的ResultChild），但在实现子类的process函数并调用时，出现了对象切片问题：返回的ResultChild对象被切片为Base::Result，导致无法访问扩展的成员b，且dynamic_cast转换失败。

相关代码 #

Base类定义 #

class Base {
public:
    class Result {
    public:
        int a = 1;
        virtual ~Result() {} // Virtual destructor
    };
    virtual Result process() = 0; // Pure abstract function
};

Child子类定义 #

class Child : public Base {
public:
    class ResultChild : public Base::Result  {
    public:
        int b;
    };
    
    Base::Result process() override {
        std::cout << "Processing in Child class" << std::endl;
        ResultChild  result;
        result.a = 7;
        result.b = 2;
        return result;
    }
};

主函数调用 #

int main() {
    Child child;
    auto result = child.process(); // Does result even know the member b here?
    std::cout << "a: " << result.a << std::endl; // this is 7
    //std::cout << "b: " << result.b << std::endl; //‘class Base::Result’ has no member named ‘b’
    // Child::ResultChild poly = dynamic_cast<Child::ResultChild>(result); // ‘class Child::ResultChild’ (target is not pointer or reference)
    Child::ResultChild* poly = dynamic_cast<Child::ResultChild*>(&result); // warning: can never succeed
    return 0;
}

具体问题 #

1. 是否存在正确的类型转换方式？
2. 成员b是否在返回时丢失？
3. 这种实现思路是否不可行？

注：这是简化版代码，实际场景中Base对应VideoPipeline类，子类需实现process(image)方法，部分子类需添加其他子类不具备的额外信息。

1. 是否存在正确的类型转换方式？ #

没有。因为process返回的是值类型，当ResultChild对象被返回时，已经被切片成了Base::Result对象——内存里仅保留Base::Result的部分，ResultChild的额外成员已被截断。此时无论怎么使用dynamic_cast都无法恢复被切掉的部分，编译器警告“can never succeed”正是这个原因。

2. 成员b是否在返回时丢失？ #

是的。对象切片发生时，子类对象中不属于父类的部分会被直接丢弃。你在Child::process里创建的ResultChild对象，其b成员在返回过程中会被切掉，最终得到的Base::Result对象里根本没有b的存储空间，自然无法访问。

3. 这种实现思路是否不可行？ #

直接返回值的思路不可行，但可以通过修改返回类型来实现你的需求，推荐两种方案：

方案一：返回智能指针（推荐） #

把process的返回类型改成std::unique_ptr<Base::Result>，返回子类对象的指针即可避免切片。修改后的代码示例：

#include <memory>
#include <iostream>

class Base {
public:
    class Result {
    public:
        int a = 1;
        virtual ~Result() {} // Virtual destructor
    };
    virtual std::unique_ptr<Result> process() = 0; // 改为返回智能指针
};

class Child : public Base {
public:
    class ResultChild : public Base::Result  {
    public:
        int b;
    };
    
    std::unique_ptr<Base::Result> process() override {
        std::cout << "Processing in Child class" << std::endl;
        auto result = std::make_unique<ResultChild>();
        result->a = 7;
        result->b = 2;
        return result;
    }
};

int main() {
    Child child;
    auto result = child.process();
    std::cout << "a: " << result->a << std::endl;
    
    // 动态转换为子类指针
    if (auto poly = dynamic_cast<Child::ResultChild*>(result.get())) {
        std::cout << "b: " << poly->b << std::endl; // 可正常访问b
    }
    return 0;
}

方案二：使用std::variant（适合固定子类场景） #

如果Result子类类型固定，可用std::variant作为返回类型，避免指针操作。示例：

#include <variant>
#include <iostream>

class Base {
public:
    class Result {
    public:
        int a = 1;
        virtual ~Result() {}
    };
    // 定义variant类型，包含所有可能的Result子类
    using ResultVariant = std::variant<std::unique_ptr<Result>, std::unique_ptr<class Child::ResultChild>>;
    virtual ResultVariant process() = 0;
};

class Child : public Base {
public:
    class ResultChild : public Base::Result  {
    public:
        int b;
    };
    
    ResultVariant process() override {
        std::cout << "Processing in Child class" << std::endl;
        auto result = std::make_unique<ResultChild>();
        result->a = 7;
        result->b = 2;
        return result;
    }
};

int main() {
    Child child;
    auto result = child.process();
    
    // 访问对应的子类成员
    std::visit([](auto&& res) {
        if constexpr (std::is_same_v<std::decay_t<decltype(res)>, std::unique_ptr<Child::ResultChild>>) {
            std::cout << "a: " << res->a << ", b: " << res->b << std::endl;
        } else {
            std::cout << "a: " << res->a << std::endl;
        }
    }, result);
    return 0;
}

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