C++中如何让Parameter类上下限同时支持整数与整数引用类型

解决方案 #

你可以通过抽象阈值的取值逻辑，让minval和maxval支持「常量存储」和「引用其他参数值」两种模式，下面是两种常用的落地方式：

方案1：使用多态的取值接口（兼容性最好，支持C++11及以上） #

首先定义一个抽象的阈值获取类，再分别实现常量版本和参数引用版本：

// 抽象阈值接口
class Threshold {
public:
    virtual ~Threshold() = default;
    virtual int get() const = 0;
};

// 常量阈值实现
class ConstThreshold : public Threshold {
private:
    int val;
public:
    ConstThreshold(int v) : val(v) {}
    int get() const override { return val; }
};

// 参数引用阈值实现
class ParamRefThreshold : public Threshold {
private:
    const Parameter& ref;
public:
    ParamRefThreshold(const Parameter& p) : ref(p) {}
    int get() const override { return ref.value; }
};

然后修改Parameter类的成员类型，用智能指针持有阈值实例：

class Parameter
{
protected:
    int value;
    std::unique_ptr<Threshold> minval;
    std::unique_ptr<Threshold> maxval;
public:
    // 构造支持传入常量或者其他Parameter对象
    Parameter(int init_val, int min, int max) 
        : value(init_val), 
          minval(std::make_unique<ConstThreshold>(min)), 
          maxval(std::make_unique<ConstThreshold>(max)) {}
    Parameter(int init_val, const Parameter& min_param, const Parameter& max_param)
        : value(init_val),
          minval(std::make_unique<ParamRefThreshold>(min_param)),
          maxval(std::make_unique<ParamRefThreshold>(max_param)) {}
    // 也可以支持混合模式，比如最小值是常量，最大值引用其他参数
    Parameter(int init_val, int min, const Parameter& max_param)
        : value(init_val),
          minval(std::make_unique<ConstThreshold>(min)),
          maxval(std::make_unique<ParamRefThreshold>(max_param)) {}
    // 获取上下限的方法
    int get_min() const { return minval->get(); }
    int get_max() const { return maxval->get(); }
};

这个方案的好处是兼容旧标准，扩展灵活，后续要加其他阈值来源（比如计算公式）也很方便。

方案2：使用std::variant实现（C++17及以上，代码更简洁） #

如果你的项目允许用C++17，可以直接用标准库的variant容器存储两种类型的阈值：

#include <variant>
#include <functional>

class Parameter
{
protected:
    int value;
    std::variant<int, const Parameter*> minval;
    std::variant<int, const Parameter*> maxval;

    // 封装统一的取值逻辑
    int get_val(const std::variant<int, const Parameter*>& v) const {
        if (std::holds_alternative<int>(v)) {
            return std::get<int>(v);
        } else {
            return std::get<const Parameter*>(v)->value;
        }
    }
public:
    // 同样可以重载多种构造方式
    Parameter(int init_val, int min, int max) : value(init_val), minval(min), maxval(max) {}
    Parameter(int init_val, const Parameter& min_param, const Parameter& max_param)
        : value(init_val), minval(&min_param), maxval(&max_param) {}
    int get_min() const { return get_val(minval); }
    int get_max() const { return get_val(maxval); }
};

注意：使用指针引用其他Parameter对象时，要确保被引用的Parameter对象生命周期长于持有引用的Parameter对象，避免悬空指针问题。如果场景复杂可以改用std::shared_ptr持有Parameter实例，自动管理生命周期。

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