2

我希望为 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 太大且太复杂，无法放入我的项目中，但如果那里有这样的类，我可以查看它以获取指针 - 如果有，它的名称是什么？

4

6 回答 6

4

这很简单，虽然很乏味——你只需要实现标准类型支持的所有运算符，而强制类型转换运算符还不够。

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

于 2009-02-12T00:12:49.820 回答
3

这是一个对 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 &，然后从那里查找运算符。随意尝试。

于 2009-02-12T00:44:01.993 回答
2

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

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

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

于 2009-02-12T00:27:03.750 回答
1

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

于 2009-02-12T00:44:01.667 回答
0

我不确定是否boost::ref是您要查找的内容。

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

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

于 2009-02-12T00:23:30.997 回答
0

我喜欢这种简单类型的封装形式（原作者 - 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。

于 2009-03-11T13:02:54.663 回答