使用C+封装一个简单类型+；模板 我想在C++中添加所有简单类型的功能。p>

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

大概是这样的：

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...

模板
类属性
{
公众：
属性（_SimpleType_value）{m_value=value；}
~Attribute（）{}
//铸造
运算符_SimpleType_u3;（）{return（m_值）；}
//比较
布尔运算符==（常量a和其他）常量{返回a==m_值；}
等
私人：
_SimpleType_Um_值；
}
//使用类似于：
属性i=20；
而(i)
{
如果（（i&0xF）==0）
{
i>>=2；
}
我--；
}等等。。。

问题是，我确信有很多细微差别需要处理，需要编写专门的模板操作员；那么，是否有任何地方已经这样做了，这样我就可以用它来代替呢

---

Boost太大、太复杂，无法放在我的项目中，但如果有这样的类，我可以查看它的指针-如果有，它的名称是什么？

它非常简单，但很乏味，-您只需实现标准类型支持的所有运算符，而cast运算符还不够

---

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

我不确定你要找的是不是

boost:：ref

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

---

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

您可以免费实现非置换运算符，只需将其转换为

\u Simple\u type\u

（并且您可以通过转换为

\u Simple\u type\u&

）即可。另一个问题是，这是否真的是一个好主意，因为它创建了

T

到

Attribute

和

Attribute

到

T

的转换，这会在重载时引起问题，但您可以通过使

Attribute

的构造函数显式化来解决这一问题

这就剩下了赋值和递增/递减-您只需要实现它们

---

另一种可能是使用

boost:：operators

——一种仅用于标题的库，它有助于基于代数规则创建运算符重载。例如，您创建

操作符+=

，它将为您提供

操作符+

。您创建

操作符与您的问题无关，但是您应该知道，诸如
\u SimpleType\u
之类的名称（即以下划线和大写字符开头的名称）预留给C++编译器和标准的LIBA程序实现者使用-不允许在自己的代码中使用它们。
 < P>这是一个用Ty&（用GNU C++ 4.4.2进行测试）的自动类型化程序的例子：

#包括
使用名称空间std；
模板
类属性{
公众：
属性（常数T&value）{v=value；}
运算符T&（{return v；}
私人：
电视
};
int main（int argc，字符**argv）
{
属性i（0）；
i=3；
i++；
i+=4；
i=i+5；
我我喜欢这种简单类型的封装形式（原始作者-Sektor van Skijlen）：

模板
类显式
{
私人：
T值；
模板显式t（vt）；
公众：
运算符T&（{返回值；}
显式_t（const t&c）：值（c）{
}; 

举个简单的例子：

void fun(explicit_t<int> foo) {}

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

void-fun（显式\u t-foo）{
int main（）
{
//乐趣（“a”）；
//乐趣（3u）；
//乐趣（3.0）；
乐趣（4）；
}

那我能得到什么呢？没有多余的转换

您可能还想看一看更别致的东西-。
请注意，您只能使用实际需要的boost部分。如果您只需要shared_ptr，请只将shared_ptr.hpp添加到您的项目中。许多库仅为头文件，因此您不需要在构建过程中添加任何内容。一个很好的理由是默认构造函数正确构造包含的类型。因此没有更多未初始化的变量。这还不够好。编译器仍会警告未初始化的变量。也许您的编译器会警告未初始化的变量。并非每个编译器都必须设置为这样做。我的原因是为应该ct作为一个整数。@CygnusX1那么为什么不直接使用
typedef
或
使用
？
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);
}