原始数据类型的包装类

Question

在设计解决方案时，有时为原始数据类型提供包装类可能会很方便。考虑一个表示数值的类，可以是 double、float 或 int。

class Number {
private:
    double val;

public:
    Number(int n) : val(n) { }
    Number(float n) : val(n) { }
    Number(double n) : val(n) { }

    // Assume copy constructors and assignment operators exist

    Number& add(const Number& other) {
        val += other.val;
        return *this;
    }

    int to_int() const { return (int) val; }
    float to_float() const { return (float) val; }
    double to_double() const { return val; }
};

现在假设我有一个这样的函数：

void advanced_increment(Number& n) {
    n.add(1);
}

我会这样使用这个函数：

Number n(2);
advanced_increment(n); // n = 3

这听起来很简单。但如果函数是这样的呢？

void primitive_increment(int& n) {
    ++n;
}

请注意，增量是一个示例。假设该函数将对原始数据类型执行更复杂的操作，它们也应该能够在 Number 类型上执行而不会出现任何问题。

我将如何像以前一样使用该功能？如：

Number n(2);
primitive_increment(n);

如何使我的 Number 类与 primitive_increment 兼容？如何为原始数据类型创建一个包装类，使其在需要这些数据类型的任何地方都兼容？

到目前为止，我只找到了两个解决方案。一种是创建一个函数，例如 double& Number::get_value()，然后像 primitive_increment(n.get_value()); 一样使用它。第二种解决方案是创建隐式转换方法，例如 Number::operator int&();但这些可能会导致许多不明确的调用，并使代码变得混乱。

我想知道是否有任何其他解决方案来实现这些类型的包装器并保留其原始功能。

更新：

为了进一步澄清，在实际项目中，这里的目的是在设计此类解决方案时使所有数据类型都派生自一个基类，该基类通常称为Object 。一个限制是不应使用外部库。因此，如果我有一个具有指向 Object 类型的指针的容器，它应该能够保存任何任意值（无论是否是原始值），并执行 Object< 上允许的任何原始操作。 /代码>。我希望这能更好地解释它。

Answer 1

C++11 具有显式运算符重载。

struct silly_wrapper {
  int foo;
  explicit operator int&() { return foo; }
};

void primitive_increment(int& x) { ++x; }


int main()
{
   silly_wrapper x;
   primitive_increment(x); // works
   x += 1; // doesn't work - can't implicitly cast
}

Answer 2

class Number {
    enum ValType {DoubleType, IntType} CurType;
    union {
        double DoubleVal;
        int IntVal;
    };
public:
    Number(int n) : IntVal(n), CurType(int) { }
    Number(float n) : DoubleVal(n), CurType(DoubleType) { }
    Number(double n) : DoubleVal(n), CurType(DoubleType) { }

   // Assume copy constructors and assignment operators exist

    Number& add(const Number& other) {
        switch(CurType) {
        case DoubleType: DoubleVal += other.to_double(); break;
        case IntType: IntVal+= other.to_int(); break;
        }
        return *this;
    }

    int& to_int() { 
        switch(CurType) {
        case DoubleType: IntVal = DoubleVal; CurType = IntType; break;
        //case IntType: DoubleVal = IntVal; CurType = DoubleType; break;
        }
        return IntVal; 
    }
    const int to_int() const { 
        switch(CurType) {
        case DoubleType: return (int)DoubleVal;
        case IntType: return (int)IntVal;
        }
    }
    const float to_float() const { 
        switch(CurType) {
        case DoubleType: return (float)DoubleVal;
        case IntType: return (float)IntVal;
        }
    }

    double& to_double() { 
        switch(CurType) {
        //case DoubleType: IntVal = DoubleVal; CurType = IntType; break;
        case IntType: DoubleVal = IntVal; CurType = DoubleType; break;
        }
        return DoubleVal; 
    }
    const double to_double() const { 
        switch(CurType) {
        case DoubleType: return (double)DoubleVal;
        case IntType: return (double)IntVal;
        }
    }
};

void primitive_increment(int& n) {
    ++n;
}

int main() {
    Number pi(3.1415);
    primitive_increment(pi.to_int());
    //pi now is 4
    return 0;
}

我承认这很尴尬，而且不是理想的情况，但它解决了给定的问题。

Answer 3

而不是将其提供给primitive_increment。您应该为 Number 类重载 ++ 运算符并以这种方式递增它。

Number& operator++() { ++val; return *this;}
Number& operator+=(const Number& rhs) { val += rhs.Val; return *this;}
Number operator+(const Number& rhs) { Number t(*this); t+=rhs; return t;}

请参阅：C 和 C++ 中的运算符

Answer 4

如果您的 Number 类没有实现 int 的子集，您就不能这样做。例如，如果您的 Number 类包含值 INT_MAX 并且也可以保存值 INT_MAX+1，则会给出错误的结果。如果您的 Number 类模拟了 int 的子集，那么转换为 int 并返回当然是一种选择。

除此之外，您唯一的机会是重写函数以接受 Number 对象。理想情况下将其作为模板，以便它可以与 int 和 Number 一起使用（以及与任何其他当前或未来提供 int< 的类一起使用） /code> 类似接口）。

Answer 5

将转换运算符设为私有，并让友元函数在其中执行转换。

class silly_wrapper {
private:
  int foo;
  float bar;
  operator int&() { return foo; }

  template <typename T>
  friend void primitive_increment(T& x) { ++static_cast<int&>(x); }
};


int main()
{
   silly_wrapper x;
   primitive_increment(x); // works

   int i;
   primitive_increment(i); // works

   int& r = static_cast<int&>(x); // can't convert - operator is private
}

Answer 6

这是我刚刚想到的一个更奇怪的答案：

class Number; 
template<class par, class base>
class NumberProxy {
    base Val;
    par* parent;
    NumberProxy(par* p, base v) :parent(p), Val(v) {}
    NumberProxy(const NumberProxy& rhs) :parent(rhs.parent), Val(rhs.Val) {}
    ~NumberProxy() { *parent = Val; }
    NumberProxy& operator=(const NumberProxy& rhs) {Val = rhs.Val; return *this}
    operator base& {return Val;}
};

class Number {
private:
    double val;
public:
    Number(int n) : val(n) { }
    Number(float n) : val(n) { }
    Number(double n) : val(n) { }
    // Assume copy constructors and assignment operators exist        
    int to_int() const { return (int) val; }
    float to_float() const { return (float) val; }
    double to_double() const { return val; }

    NumberProxy<Number,int> to_int() { return NumberProxy<Number,int>(this,val); }
    NumberProxy<Number,float> to_float() { return NumberProxy<Number,float>(this,val); }
    NumberProxy<Number,double> to_double() { return NumberProxy<Number,double>(this,val); }
};

void primitive_increment(int& n) {
    ++n;
}

int main() {
    Number pi(3.1415);
    primitive_increment(pi.to_int());
    //pi now is 4
    return 0;
}

Number.to_int() 返回一个 NumberProxy，它可以隐式转换为 int& code>，函数对其进行操作。当函数和表达式完成时，临时 NumberProxy 将被销毁，并且它的析构函数会使用更新后的值更新其父 Number。这带来了额外的便利，只需要对 Number 类进行少量修改。

显然这里存在一些危险，如果您在同一个语句中调用 to_N() 两次，则两个 int& 不会同步，或者如果有人获取 int& ，则两个 int& 不会同步。超过了声明的结尾。

Answer 7

（这有点盲目，因为我不完全确定您的整体设计如何组合在一起。）

模板化的自由函数怎么样：

class IncTagIntegral{};
class IncTagNonintegral{};
template <bool> struct IncTag { typedef IncTagNonintegral type; }
template <> struct IncTag<true> { typedef IncTagIntegral type; }

template <typename T> void inc_impl(T & x, IncTagIntegral)
{
  ++x;
}

template <typename T> void inc_impl(T & x, IncTagNonintegral)
{
  x += T(1);
}


template <typename T> void primitive_increment(T & x)
{
  inc_impl<T>(x, typename IncTag<std::is_integral<T>::value>::type());
}

template <> void primitive_increment(Number & x)
{
  // whatever
}

这种方法可能可以推广到您需要将两者应用于现有类型的其他函数以及你自己的类型。

---

这是另一个长镜头，这次使用类型擦除：

struct TEBase
{
   virtual void inc() = 0;
}

struct any
{
  template <typename T> any(const T &);
  void inc() { impl->inc(); }
private:
  TEBase * impl;
};

template <typename T> struct TEImpl : public TEBase
{
  virtual void inc() { /* implement */ }
  // ...
}; // and provide specializations!

template <typename T> any::any<T>(const T & t) : impl(new TEImpl<T>(t)) { }

关键是您通过专门化的方式提供 TEImpl::inc() 的不同具体实现，但您可以使用 a .inc() 用于 any 类型的 any 对象 a。您可以根据这个想法构建额外的自由函数包装器，例如 void inc(any & a) { a.inc(); }。