C++：限制數字的異構模板

Question

我想創建一個列表（std ::容器或甚至列表*將是好的）數字（int和double），可以對它們施加限制。

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; 

我已經嘗試了這兩種不同的方式，但我不滿意他們中的任何一個。無法從公共基礎派生，因爲基礎類型不知道「值」，因爲它不知道類型或必須提前定義類型。試用了宏模板，但低調感覺很sl。。有沒有辦法做到這一點，而不訴諸所有類型的聯合與類型標識符來選擇正確的成員？

的boost ::用的重載構造變形，似乎做什麼，我想，到目前爲止，除了具有在編譯時枚舉所有類型：

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，只需使用雙），或者定義一個更通用的基本類型。

您使用泛型基類型記下的問題是泛泛而談。您正在丟失您訪問容器中的元素時無法返回的類型信息。

我認爲你的設計目標不一致。你應該創建一個足夠滿足你的需求的通用接口（這是類型不可知的），或者選擇一種類型並堅持下去。

Answer 4

我會先說你可以在基類中提供幾個toInt和toDouble和toInt64方法。那麼，如果你需要雙倍的價值，你只需要它。這需要每個人都付出最少的努力。

如果失敗了，您可以用virtual void value(Operator&) const替換一個常規的virtual int value() 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類;比如對所有的整型類型調用act(int)，對於所有浮點類型調用act(double)，那麼你會回到每個實現只需要兩個重載，再加上你需要用於該特定用例的其他任何重載。

但現在我正在尋找YAGNI。你有一個複雜的基類，你可以通過不存儲完整的int來提供節省幾個字節的設置？你真的不能把所有東西都存儲爲double？它精確地存儲了大量的整數值。或者使用boost::variant並限制自己輸入，雙打和字符串。