在C+中创建泛型数值类+； < >在C++中创建通用数字类的最佳方法是什么？我在考虑一个可以包含整数、浮点和双精度的对象

我的第一个想法是使用一个将在数值类中使用的并集，您可以在其中为每种类型定义允许的操作。比如：

union mixed_number{
    int a;
    float b;
    double c;
};

class Number{
    //define operations
    ...
};

---

请告诉我是否有更好的方法。

我不久前创建了一个通用数字类。在这里：

template< typename T> class TypeWrapper
{
    T value;
public:
    TypeWrapper(T v): value(v) {}

    operator T() { return value; }

    // basic arithmetic operators
    void operator = (T v){  value = v; }

    TypeWrapper operator + (T v) { return TypeWrapper( value + v ); }
    TypeWrapper operator - (T v) { return TypeWrapper( value - v); }
    TypeWrapper operator * (T v) { return TypeWrapper( value * v); }
    TypeWrapper operator / (T v) { return TypeWrapper( value / v); }
    TypeWrapper operator % (T v) { return TypeWrapper( value % v); }

    void operator += (T v) { value += v; }
    void operator -= (T v) { value -= v; }
    void operator *= (T v) { value *= v; }
    void operator /= (T v) { value /= v; }
    void operator %= (T v) { value %= v; }

    T operator ++ () { return ++value; }
    T operator -- () { return --value;}
    T operator ++ (int v) { return value++; }
    T operator -- (int v) { return value--; }

    // conditions
    bool operator == (T v) { return value == v; }
    bool operator != (T v) { return value != v; }
    bool operator > (T v) { return value > v; }
    bool operator < (T v) { return value < v; }
    bool operator >= (T v) { return value >= v; }
    bool operator <= (T v) { return value <= v; }

    T toPrimitive() { return value; }
    string toString()
    {
        stringstream ss;
        string rtn;

        ss << value;
        ss >> rtn;

        return rtn;
    }
};

// just to make things easier for a future move.
#define NumericTypeWrapper TypeWrapper

    typedef NumericTypeWrapper< int > Integer;
    typedef NumericTypeWrapper< double > Double;
    typedef NumericTypeWrapper< float > Float;
}

template类TypeWrapper
{
T值；
公众：
TypeWrapper（tv）：值（v）{}
运算符T（）{返回值；}
//基本算术运算符
void运算符=（tV）{value=v；}
TypeWrapper运算符+（tV）{返回TypeWrapper（值+v）；}
TypeWrapper运算符-（tV）{返回TypeWrapper（值-v）；}
TypeWrapper运算符*（tV）{返回TypeWrapper（值*v）；}
TypeWrapper运算符/（tV）{返回TypeWrapper（值/v）；}
TypeWrapper运算符%（tV）{返回TypeWrapper（值%v）；}
void运算符+=（tV）{value+=v；}
无效运算符-=（tV）{value-=v；}
void运算符*=（tV）{value*=v；}
void运算符/=（tV）{value/=v；}
无效运算符%=（tV）{value%=v；}
T运算符++（）{return++value；}
T运算符--（）{return--value；}
T运算符++（int v）{返回值++；}
T运算符--（int v）{返回值--；}
//条件
布尔运算符==（tV）{返回值==v；}
布尔运算符！=（tV）{返回值！=v；}
布尔运算符>（tV）{返回值>v；}
布尔运算符<（tV）{返回值=（tV）{返回值>=v；}
布尔算子整数；
typedef NumericTypeWrapperdouble；
typedef NumericTypeWrapperfloat；
}

更好方法的候选者：只需使用

double

。假设的

Numeric

类与此相比有什么优势？哦，当你说泛型时，我以为你指的是泛型。。。不管怎样，为什么？你想写一个javascript解释器或类似的东西吗？是的，我想写一个小的解释器，同时我试图理解Python和Ruby等动态语言是如何定义它们的数据的。我知道我可以查看源代码，但我想先尝试一些想法。这绝对是不正确的类！例如bool操作符==（tV）{返回值==v；}对double不起作用。我不认为OP是指带有“generic”的模板。@MrLister噢，该死。那他是什么意思？抱歉误解。@IntermediateHacker OP想编写一个小型解释器，同时尝试理解Python和Ruby等动态语言如何定义它们的数据。他知道他可以查看源代码，但他想先尝试一些想法。@mmissu哦，你的个人资料没有提到你的性别。对不起，有任何误解。