如何通过基类unique_ptr调用派生类的非虚、非const成员方法？

咱们先从你遇到的崩溃问题说起——你用dynamic_cast拿到派生类指针后直接调用方法导致Segfault，最可能的原因是**dynamic_cast失败返回了nullptr，你没做检查就直接调用方法**。这是最常见的坑，先把这个补上：

auto& baseRef = forces.at("DerivedForce");
auto* basePtr = baseRef.get();
auto* derivedPtr = dynamic_cast<DerivedForce*>(basePtr); 
// 一定要加检查！
if (derivedPtr != nullptr) {
    derivedPtr->set_coefficients(...); 
} else {
    // 这里可以加日志、抛异常或者提示用户类型不匹配
    std::cerr << "Error: Force type mismatch!" << std::endl;
}

另外，你工厂里存的是unique_ptr<Force>，不存在对象切片的问题——切片只会发生在值拷贝的时候，指针/引用形式的多态是安全的，所以修改派生类的成员不会被“抹掉”，这点你可以放心。

接下来针对你的需求（不想把set_coefficients设为基类虚方法，因为不是所有派生类都需要），给你几个更优雅的解决方案：

方案一：给工厂加专属的类型安全获取方法 #

既然你的工厂清楚哪些是预定义的派生类，可以给它加一个模板方法，专门用来获取特定类型的派生类指针，既安全又方便：

class ForceFactory {
    // ... 你的现有代码 ...
public:
    template<typename DerivedType>
    DerivedType* get_force(const std::string& force_name) {
        // 先确保对象已经被构建
        if (!forces.count(force_name)) {
            build(force_name);
        }
        // 动态转换并返回，记得还是要检查
        return dynamic_cast<DerivedType*>(forces.at(force_name).get());
    }
};

调用的时候就很清晰：

auto* my_derived = factory.get_force<DerivedForce>("DerivedForce");
if (my_derived) {
    my_derived->set_coefficients(...);
}

方案二：用访问者模式解决多态下的专属方法调用 #

如果后续你还有更多派生类需要调用各自的专属方法，访问者模式是更优雅的选择，不用每次都写dynamic_cast。

首先给基类Force加一个accept方法：

class ForceVisitor; // 前向声明

class Force {
public:
    Force() = default;
    ~Force() = default;

    virtual std::array<double, 3> compute_force(...) const = 0;
    // 新增accept方法，用来接受访问者
    virtual void accept(ForceVisitor& visitor) = 0;
};

然后定义访问者基类：

class ForceVisitor {
public:
    // 每个派生类对应一个visit方法
    virtual void visit(DerivedForce& force) = 0;
    virtual void visit(DerivedForceA& force) = 0;
    virtual void visit(DerivedForceB& force) = 0;
};

让每个派生类实现accept：

class DerivedForce : public Force {
public:
    // ... 你的现有代码 ...
    void accept(ForceVisitor& visitor) override {
        visitor.visit(*this); // 把自己传递给访问者
    }
};

最后写一个专门用来设置系数的访问者：

class SetCoefficientsVisitor : public ForceVisitor {
private:
    // 保存需要传递的参数
    const std::vector<std::vector<double>>& _target_coeffs;
public:
    SetCoefficientsVisitor(const std::vector<std::vector<double>>& coeffs)
        : _target_coeffs(coeffs) {}

    // 只在DerivedForce的实现里做实际操作
    void visit(DerivedForce& force) override {
        force.set_coefficients(_target_coeffs);
    }

    // 其他派生类的visit可以留空或者报错
    void visit(DerivedForceA& force) override {
        std::cerr << "DerivedForceA doesn't support set_coefficients!" << std::endl;
    }

    void visit(DerivedForceB& force) override {
        std::cerr << "DerivedForceB doesn't support set_coefficients!" << std::endl;
    }
};

调用的时候就不用管类型转换了：

auto& base_ref = forces.at("DerivedForce");
SetCoefficientsVisitor visitor(my_coeffs);
base_ref->accept(visitor);

方案三：把初始化逻辑移到Builder里（从根源避免类型转换） #

你提到担心Builder的函数签名不一样，其实可以让Builder支持传递参数。比如把BuilderFunc改成可以接受任意参数的形式：

class ForceFactory {
private:
    // 把BuilderFunc改成接受std::any参数的形式
    using BuilderFunc = std::function<std::unique_ptr<Force>(const std::any& params)>;
    
    const std::unordered_map<std::string, BuilderFunc> builders = {
        {"DerivedForceA",  [](const std::any&){ return std::make_unique<DerivedForceA>(); }},
        {"DerivedForceB",  [](const std::any&){ return std::make_unique<DerivedForceB>(); }},
        {"DerivedForce",  [](const std::any& params){
            auto coeffs = std::any_cast<const std::vector<std::vector<double>>&>(params);
            auto force = std::make_unique<DerivedForce>();
            force->set_coefficients(coeffs);
            return force;
        }}
    };

    // ... 其他成员 ...
public:
    // 修改build方法，支持传递参数
    const std::unique_ptr<Force>& build(const std::string& force, const std::any& params = {}) {
        if (forces.count(force) == 0) {
            forces[force] = builders.at(force)(params);
        }
        return forces[force];
    }
};

这样在构建对象的时候就直接把系数设置好，后续再也不用做类型转换了：

factory.build("DerivedForce", my_coeffs);
// 之后直接用基类指针调用compute_force就行，系数已经设置好了

这个方案最省心，因为从一开始就把对象初始化到正确状态，避免了后续的类型转换操作。

最后再给你吃个定心丸：你的工厂模式思路是没问题的，用unique_ptr<Force>存储派生类完全符合多态的使用场景，修改派生类的成员也不会被“切片”——切片只发生在你把派生类对象直接赋值给基类对象的时候，指针和引用是安全的。

备注：内容来源于stack exchange，提问作者Jay Iuliano