使用 C++ 封装简单类型 模板

Question

我希望为 C++ 中的所有简单类型添加功能。

我想编写一个模板类，它将要封装的类型作为模板参数，然后定义所有运算符，以便封装的类与它封装的简单类型完全相同。

像这样的事情：

template <typename _SimpleType_>
class Attribute
{
public:
    Attribute(_SimpleType_ value){ m_value = value; }
    ~Attribute(){}

    // Cast
    operator _SimpleType_() { return(m_value); }

    // Comparisons
    bool operator==(const a& other) const { return a == m_value; }
    etc...

private:
   _SimpleType_ m_value;
}

// Use like:
Attribute<int> i = 20;

while(i)
{
   if((i & 0xF) == 0)
   {
      i >>= 2;
   }

   i--;
}  etc...

问题是我确信必须处理大量细微差别并编写专门的模板运算符； 那么是否有任何地方已经完成了此操作，以便我可以使用它来代替？

Boost 太大且复杂，无法放入我的项目中，但如果其中有这样的类，我可以查看它以获取指针 - 如果有，它的名字是什么？

Answer 1

这非常简单，如果乏味的话，您只需实现标准类型支持的所有运算符，而强制转换运算符是不够的。

但我不得不问，你到底为什么要这样做？

Answer 2

下面是一个自动类型转换为 T& 的示例。 （使用 GNU C++ 4.3.2 进行测试）：

#include <iostream>

using namespace std;

template <typename T>
class Attribute {
public:
    Attribute(const T &value) { v = value; }
    operator T & () { return v; }
private:
    T v;
};

int main(int argc, char **argv)
{
    Attribute<int> i(0);
    i = 3;
    i++;
    i += 4;
    i = i + 5;
    i <<= 3;
    cout << "i is now " << i << endl;
}

C++ 编译器使用强制运算符“operator T &”自动将对“Attribute”的引用强制转换为对“int”的引用。 ()'。 因此，当 Attribute 类不提供“++”运算符或任何内容时，该对象将被类型转换为 int & 然后从那里查找操作员。 请随意尝试。

Answer 3

您只需转换为 _Simple_type_ 即可免费获得非变异运算符的实现（并且您可以通过转换为 _Simple_type_& 来获得赋值和递增/递减）。 另一个问题是这是否真的是一个好主意，因为它创建了 T 到 Attribute 和 Attribute 到 T 的转换。 code>T 会在重载时导致问题 - 但您可以通过显式显示 Attribute 的构造函数来解决该问题。

这留下了分配和递增/递减——你只需要实现这些。

另一种可能性是使用 boost::operators - 一个仅标头的库，有助于根据代数规则创建运算符重载。 例如。 您创建operator+=，它将为您提供operator+。 您创建 operator< 和 operator== ，它会给您其他关系等。

Answer 4

与您的问题无关，但您应该知道诸如 _SimpleType_ 之类的名称（即以下划线和大写字符开头的名称）是为 C++ 编译器和标准库实现者保留的use - 不允许您在自己的代码中使用它们。

Answer 5

我不确定 boost::ref 是否是您正在寻找的。

无论如何，您要做的最好的事情就是用手写出来——但是如果您打算支持指针和引用语义，这将开始成为一个问题。

您可能还需要做的是将其放入命名空间中并实现自由函数运算符重载，并依赖 ADL 来获取它。 但是，当您实现越来越多的运算符时，这会变得有点笨拙。

Answer 6

我喜欢这种简单类型的封装形式（原作者 - Sektor van Skijlen）：

template<typename T>
class explicit_t
{
private:
    T value;

    template<typename V> explicit_t(V t);
public:
    operator T&() {return value;}
    explicit_t(const T& c) : value(c) {}    
}; 

还有一个简短的示例：

void fun(explicit_t<int> foo) {}

int main()
{
        // fun('a');
        // fun(3u);
        // fun(3.0);
        fun(4);
}

那么我会得到什么？ 不再有不需要的转换。

您可能还想看看一些更奇特的东西 - typegen。