如何简化结构相同但内容不同的两个C++结构体实现？

问题背景 #

你目前有两个结构高度重复的结构体DEF和R2，仅构造函数参数需求、成员函数实现不同，且被用于模板类STT中。以下是几种可以避免重复定义的简洁实现方式：

方案一：抽象基类+派生类（推荐） #

定义一个包含所有公共成员的抽象基类，将差异部分（成员函数实现、构造逻辑）交给派生类完成，利用多态实现不同行为：

#include <string>

// 抽象基类：封装所有公共结构
class TheoryBase {
public:
    virtual ~TheoryBase() = default; // 虚析构函数确保派生类析构正确

    // 纯虚函数：由派生类实现具体逻辑
    virtual double V_of_phi(double, double) = 0;
    virtual double dV_of_phi(double, double) = 0;

    // 公共成员变量
    double metricStartingPoint;
    double scalarStartingPoint;
    // ...其他公共成员
};

// DEF派生类：实现自身构造和成员函数
struct DEF : public TheoryBase {
    DEF(std::string, double /* 未使用的coupling参数 */, double central_density) {
        // 仅使用central_density完成初始化逻辑
    }

    double V_of_phi(double a, double b) override {
        // DEF专属的V_of_phi实现
        return 0.0; // 示例返回值，替换为实际逻辑
    }

    double dV_of_phi(double a, double b) override {
        // DEF专属的dV_of_phi实现
        return 0.0; // 示例返回值，替换为实际逻辑
    }
};

// R2派生类：实现自身构造和成员函数
struct R2 : public TheoryBase {
    R2(std::string, double coupling, double /* 未使用的central_density参数 */) {
        // 仅使用coupling完成初始化逻辑
    }

    double V_of_phi(double a, double b) override {
        // R2专属的V_of_phi实现
        return 0.0; // 示例返回值，替换为实际逻辑
    }

    double dV_of_phi(double a, double b) override {
        // R2专属的dV_of_phi实现
        return 0.0; // 示例返回值，替换为实际逻辑
    }
};

使用时，原STT模板类无需大幅修改，依然可以用DEF/R2作为模板参数，调用theory->V_of_phi(...)时会自动触发多态，调用对应派生类的实现。

方案二：模板结构体+标签分派 #

通过模板标签区分不同的理论类型，将差异逻辑用标签分派实现，无需继承：

#include <string>
#include <type_traits>

// 定义区分标签
struct DEFTag {};
struct R2Tag {};

// 模板结构体：封装公共结构，根据标签实现差异逻辑
template <typename Tag>
struct Theory {
    // 构造函数：用SFINAE适配不同参数需求
    template <typename T = Tag, std::enable_if_t<std::is_same_v<T, DEFTag>, int> = 0>
    Theory(std::string, double /* coupling */, double central_density) {
        // DEF专属构造逻辑，使用central_density
    }

    template <typename T = Tag, std::enable_if_t<std::is_same_v<T, R2Tag>, int> = 0>
    Theory(std::string, double coupling, double /* central_density */) {
        // R2专属构造逻辑，使用coupling
    }

    ~Theory() = default;

    // 对外统一接口，内部通过标签分派到不同实现
    double V_of_phi(double a, double b) {
        return V_of_phi_impl(a, b, Tag{});
    }

    double dV_of_phi(double a, double b) {
        return dV_of_phi_impl(a, b, Tag{});
    }

    // 公共成员变量
    double metricStartingPoint;
    double scalarStartingPoint;
    // ...其他公共成员

private:
    // DEF专属实现
    double V_of_phi_impl(double a, double b, DEFTag) {
        // DEF的V_of_phi逻辑
        return 0.0;
    }

    double dV_of_phi_impl(double a, double b, DEFTag) {
        // DEF的dV_of_phi逻辑
        return 0.0;
    }

    // R2专属实现
    double V_of_phi_impl(double a, double b, R2Tag) {
        // R2的V_of_phi逻辑
        return 0.0;
    }

    double dV_of_phi_impl(double a, double b, R2Tag) {
        // R2的dV_of_phi逻辑
        return 0.0;
    }
};

使用时，STT的模板参数替换为Theory<DEFTag>或Theory<R2Tag>，构造调用方式与原代码完全一致，模板会自动匹配对应的构造函数和成员函数实现。

方案三：组合模式（函数对象注入） #

将差异逻辑封装为函数对象，结构体仅保留公共成员和函数对象接口，通过工厂函数创建不同实例：

#include <string>
#include <functional>

struct Theory {
    // 构造函数：接受公共参数和差异逻辑的函数对象
    Theory(std::string, double central_density, double coupling,
           std::function<double(double, double)> v_func,
           std::function<double(double, double)> dv_func)
        : V_of_phi(std::move(v_func)), dV_of_phi(std::move(dv_func)) {
        // 根据类型选择使用central_density或coupling初始化
    }

    ~Theory() = default;

    // 函数对象：存储不同的实现逻辑
    std::function<double(double, double)> V_of_phi;
    std::function<double(double, double)> dV_of_phi;

    // 公共成员变量
    double metricStartingPoint;
    double scalarStartingPoint;
    // ...其他公共成员
};

// 工厂函数：创建DEF实例
Theory create_DEF(std::string eos_name, double central_density) {
    return Theory(
        eos_name, central_density, 0.0,
        [](double a, double b) { /* DEF的V_of_phi实现 */ return 0.0; },
        [](double a, double b) { /* DEF的dV_of_phi实现 */ return 0.0; }
    );
}

// 工厂函数：创建R2实例
Theory create_R2(std::string eos_name, double coupling) {
    return Theory(
        eos_name, 0.0, coupling,
        [](double a, double b) { /* R2的V_of_phi实现 */ return 0.0; },
        [](double a, double b) { /* R2的dV_of_phi实现 */ return 0.0; }
    );
}

这种方式灵活性高，但std::function会带来轻微的间接调用开销，适合非性能敏感场景。

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