Generics 无法为泛型类型创建运算符==？

我有一个通用的range类，我正在尝试添加一个比较运算符，以便测试一个范围是否等于另一个范围。它无法编译，我不知道如何修复它所抱怨的问题。我错过了什么明显的东西吗？下面是一段代码：

generic<typename T>
public ref class Range
{
protected:
    T m_min;
    T m_max;
public:

    ...
    ...

    bool operator==(Range<T>% rhs) 
    {
        return ( m_min == rhs.m_min ) && ( m_max == rhs.m_max );
    }
};

是否需要为要重载的每个类型定义转换（我使用的是Int32实例化）？我希望避免这类事情，因为它相当有损于使用泛型

[Edit]我得到了一个如下的实例：

Range<Int32> a = Range<Int32>(0,5);
Range<Int32> b = Range<Int32>(1,3);

if( Int32(2) != Int32(4) )
{
    printf("Int32 supports != operator");
}

if( a != b )
{
    printf("A != B : SUCCESS");
}
else
{
    printf("A == B : FAIL");
}

Range a=范围（0,5）；
范围b=范围（1,3）；
如果（Int32（2）！=Int32（4））
{
printf（“Int32支持！=运算符”）；
}
如果（a！=b）
{
printf（“A！=B：成功”）；
}
其他的
{
printf（“A==B：失败”）；
}

---

…除了上面提到的错误之外，它还可以编译。如果我将每个值转换为它编译的Int32，但实际上我希望尽可能保持类的泛型（即，不必为每个类型都重载）。我想我可以为每种类型创建子类，并在那里执行重载运算符，但解决方案不如我第一次发现

generic

s；-）时所预期的那么简洁

据我所知，当T的类型与类模板的实例化类型相同时，可以使用“Range”而不是“Range”。试试看

离题，但我会返回一个const bool，并使该函数也为const。此外，除非您知道需要保护，否则请将“保护”更改为“私有”

---

我假设“%”是“&”的拼写错误？编辑：除了我刚刚注意到c++-cli标记外，这可能是c++/cli中存在的一些疯狂的运算符，遗憾的是我对它一无所知：）

据我所知，当T与类模板实例化的类型相同时，可以使用“Range”而不是“Range”。试试看

离题，但我会返回一个const bool，并使该函数也为const。此外，除非您知道需要保护，否则请将“保护”更改为“私有”

---

我假设“%”是“&”的拼写错误？编辑：除了我刚刚注意到c++-cli标记外，这可能是c++/cli中存在的一些疯狂的运算符，遗憾的是，我对此一无所知：）

您无法将泛型类型的值与==运算符进行比较，因为并非所有值类型都能保证实现它

例如，此代码示例失败，错误为“Operator'==”不能应用于“Test.MyStruct”和“Test.MyStruct”类型的操作数

struct MyStruct { }

class Tester {
    void Go()
    {
        bool b = new MyStruct() == new MyStruct();
    }
 }

---

不能将泛型类型的值与==运算符进行比较，因为并非所有值类型都能保证实现它

例如，此代码示例失败，错误为“Operator'==”不能应用于“Test.MyStruct”和“Test.MyStruct”类型的操作数

struct MyStruct { }

class Tester {
    void Go()
    {
        bool b = new MyStruct() == new MyStruct();
    }
 }

---

在标准C++中，你将写< /P>

template< class T >
class Range {

    bool operator==(Range const & rhs) const {
        return ( m_min == rhs.m_min ) && ( m_max == rhs.m_max );
    }
};

模板
等级范围{
布尔运算符==（范围常数和rhs）常数{
返回值（m_min==rhs.m_min）和&（m_max==rhs.m_max）；
}
};

只要T型有一个操作符，它就可以工作==

但这显然不是标准C++，<代码>通用<代码>，即<代码>公共REF类< /COD>，<代码>范围% < /P>

---

<>查找关于<代码>通用< /COD>的一些特殊规则，我猜它们对T类型的约束比标准模板要多。

标准C++中，你会写

template< class T >
class Range {

    bool operator==(Range const & rhs) const {
        return ( m_min == rhs.m_min ) && ( m_max == rhs.m_max );
    }
};

模板
等级范围{
布尔运算符==（范围常数和rhs）常数{
返回值（m_min==rhs.m_min）和&（m_max==rhs.m_max）；
}
};

只要T型有一个操作符，它就可以工作==

但这显然不是标准C++，<代码>通用<代码>，即<代码>公共REF类< /COD>，<代码>范围% < /P>

---

寻找一些关于

泛型

的特殊规则，我猜它们对类型T的约束比标准模板多。

您是否尝试过在IComparable约束中添加

generic<typename T> where T: IComparable
public ref class Range  {
....

泛型，其中T:i可比较
公共参考类范围{
....
您是否尝试在IComparable

约束中添加

generic<typename T> where T: IComparable
public ref class Range  {
....

泛型，其中T:i可比较
公共参考类范围{
....
至少在VS2005中，需要的是：

generic<typename T> where T: IComparable, IEquatable<T>
public ref class Range {
    ...
};

泛型，其中T:i可比较，i可比较
公共参考类范围{
...
};

这导致编译器接受==运算符。我没有测试Range类，但它在类的以下静态方法中正常工作：

generic <class K, class V> where V: IComparable, IEquatable<V>
static
K
KeyForValue(Collections::Generic::IDictionary<K,V>^ src, V value) {
    for each (Collections::Generic::KeyValuePair<K,V>^ kvp in src) {
        if (kvp->Value==value) return kvp->Key ;
    }
    throw gcnew Collections::Generic::KeyNotFoundException() ;
    return K() ;
}

generic其中V:i可比，i可比
静止的
K
KeyForValue（集合：：泛型：：IDictionary ^src，V值）{
对于每个（集合：：Generic：：KeyValuePair ^kvp在src中）{
如果（kvp->Value==Value）返回kvp->Key；
}
抛出新集合：：泛型：：KeyNotFoundException（）；
返回K（）；
}
至少在VS2005中，需要的是：

generic<typename T> where T: IComparable, IEquatable<T>
public ref class Range {
    ...
};

泛型，其中T:i可比较，i可比较
公共参考类范围{
...
};

这导致编译器接受==运算符。我没有测试Range类，但它在类的以下静态方法中正常工作：

generic <class K, class V> where V: IComparable, IEquatable<V>
static
K
KeyForValue(Collections::Generic::IDictionary<K,V>^ src, V value) {
    for each (Collections::Generic::KeyValuePair<K,V>^ kvp in src) {
        if (kvp->Value==value) return kvp->Key ;
    }
    throw gcnew Collections::Generic::KeyNotFoundException() ;
    return K() ;
}

generic其中V:i可比，i可比
静止的
K
KeyForValue（集合：：泛型：：IDictionary ^src，V值）{
对于每个（集合：：Generic：：KeyValuePair ^kvp在src中）{
如果（kvp->Value==Value）返回kvp->Key；
}
抛出新集合：：泛型：：KeyNotFoundException（）；
返回K（）；
}
您有一个类的实例化，其中T被替换为实际类型-该类型是否有==运算符？您有一个类的实例化，其中T被替换为实际类型-该类型是否有==运算符？常量和私有上的公平点。是的，关于C++/CLI的疯狂，您是对的；-）常量上的公平点是的，关于C++/CLI的疯狂你是对的；-）是的，这正是我希望做的，但泛型似乎比我希望的更受限制（或者我还没有找到实现相同功能的适当方法）