c++：有界数的异构模板

Question

我想创建一个可以对其施加限制的数字（int 和 double）列表（std::container 甚至 list* 都可以）。

template<typename T> 
class setting {
  public:
    std::string name, units;
    T value, min, max, step;

    setting(std::string n, T val) : name(n), value(val) { }

    setting operator++(int) {
      setting tmp = *this;
      value += step; if(value > max) value = max;
      return tmp;
    }
};
...
list.add(new setting<int>("channel", 4));
list.add(new setting<double>("amplitude", 5.6));
...
for(int i = 0; i < list.size(); i++)
  std::cout << list[i].name << ": " << list[i].value << std::endl;

我尝试了几种不同的方法，但我对其中任何一种都不满意。无法从公共基派生，因为基类型不知道“值”，因为它不知道类型或必须提前定义类型。尝试使用宏模板，但沮丧的感觉很草率。有没有一种方法可以做到这一点，而无需借助类型标识符的所有类型的联合来选择正确的成员？

到目前为止，具有重载构造函数的 boost::variant 似乎可以实现我想要的功能，除了必须在编译时枚举所有类型：

class setting {
   public:
      boost::variant<
         bool,
         int8_t,
         uint8_t,
         int16_t,
         uint16_t,
         int32_t,
         uint32_t,
         int64_t,
         uint64_t,
         float,
         double,
         std::string
            > value;

      std::string name;

      setting(std::string n, int v) : name(n), value(v) { }
      setting(std::string n, double v) : name(n), value(v) { }
      setting(std::string n, std::string v) : name(n), value(v) { }
};

typedef std::map<std::string, setting*> MapType;
typedef MapType::const_iterator MapItr;

int main() {
   MapType settinglist;

   settinglist["height"] = new setting("height", 1.3);
   settinglist["width"]  = new setting("width", 5);
   settinglist["name"]   = new setting("name", "the name");

   for(MapItr i = settinglist.begin(); i != settinglist.end(); ++i) {
      std::cout << i->second->name
         << " : " << i->second->value
         << std::endl;
   }

   return 0;
};

给出：

height : 1.3
name : the name
width : 5

Answer 1

也许是一个带有虚拟 toString 和 fromString 函数的公共基类？那么你的 for 循环就变成了：

list<setting_base> lst;
for( list<setting_base>::iterator it = lst.begin(); it != lst.end(); ++it )
     std::cout << it->name << ": " << it->toString() << std::endl;

Answer 2

将普通类型包装在 Boost.Operators 中怎么样？

template <class T, T max = numeric_limits<T>::max(), T min = 0>
class Saturate
    : boost::operators<Saturate<T, max, min>, T >
{
private:
    T _value;
    void normalize() {
        if(_value < min) _value = min;
        if(_value > max) _value = max;
    }
    void toNormal(T t) {
        if(t < min) return min;
        if(t > max) return max;
        return t;
    }
public:
    Saturate(T t = T()) : _value(toNormal(t)) {}
    T value() { return _value; }
    Saturate& operator+=(const Saturate& x)
      { _value += x._value; normalize(); return *this; }
    Saturate& operator-=(const Saturate& x)
      { _value -= x._value; normalize(); return *this; }
    ...
};
...
std::vector<Saturate<int, 1023, -1023> > volume;
...
volume[3] = 50000; // really loud
std::cout << volume[3].value(); // Not so loud

Answer 3

我认为您必须将所有内容都放入一种类型（意味着忘记 int，只需使用 double），或者定义一个更通用的基本类型。

您注意到通用基类型的问题是它非常通用。您将丢失类型信息，以后在访问容器中的元素时无法恢复这些信息。

我认为你的设计目标不一致。您应该创建一个足以满足您的需求的通用接口（与类型无关），或者选择一种类型并坚持使用它。

Answer 4

首先我会说，您可以在基类中提供一些 toInt 和 toDouble 和 toInt64 方法。然后，如果您需要双精度值，您只需提出要求即可。它需要每个人付出最少的努力。

如果做不到这一点，您可以将常规的 virtual int value() const 方法替换为 virtual void value(Operator&) const 方法。 Operator 将提供自己的虚拟函数，每个函数都接受您想要操作的类型之一。本质上：

struct Operator {
    virtual act(int) = 0;
    virtual act(double) = 0;
    //repeat for other types
};

struct Base {
    virtual value(Operator&) const = 0;
};

当您在基本类型上调用 value 时，虚拟调度将确保调用正确的实现。在该实现中，您为 act 提供正确的静态类型，然后重载决策就会启动。您实际上可以在 Operator 实例中执行计算，或者仅存储结果并进行计算。提供一个访问器。在前一种情况下，您可以为每种类型做一些独特的事情，例如使用一种对整数类型运行速度更快但没有精度的算法。在后一种情况下，您可以更进一步，在 Base 中提供一个模板化访问器。

struct Base {
    //other stuff
    template<typename Operator>
    typename Operator::ResultType value() const {
        Operator op;
        value(op); 
        return op.result();
    }
}
// later
cout << basePtr->get<IntGetter>();

当然，最终结果是采用一种极其复杂的方式来执行我最初建议的操作。

/////////////
我刚刚注意到您对原始问题的编辑。由于有如此多的可能的基础类型，这变得不太可行。您必须在 Operator 类中提供每个基本类型的重载。您可以为基本 Operator 类提供默认实现；就像为所有整型调用 act(int) 和为所有浮点类型调用 act(double) 一样，那么您将回到每个实现仅需要两个重载，加上该特定用例所需的任何其他内容。

但现在我把目光投向了亚格尼。您有一个复杂的基类，只是为了提供通过不存储完整 int 来节省一些字节的设置？你真的不能将所有内容都存储为 double 吗？它精确地存储了一大堆整数值。或者使用 boost::variant 并将自己限制为整数、双精度数和字符串。