C++ “无操作员”<&引用；匹配这些操作数操作数类型为：double<；我的班级

我有两个文件：

my_header.h

：

class my_class {
public:
    my_class();

    my_class(long long number);

    my_class(int number);

    my_class(double number);

    bool operator<(const my_class& rhs) const;

    //////
}

my_class::my_class()
{
    //implementation
}

my_class::my_class(long long number)
{
    //implementation
}

my_class::my_class(int number)
{
    //implementation
}

my_class::my_class(double number)
{
    //implementation
}

bool my_class::operator<(my_class const& rhs) const
{
    //implementation
}

我不明白，我哪里做错了。I通过重载运算符

，

）。其他运算符位于同一命名空间中，但它们不是成员函数

测试用例是：

my_class a = 2;
bool check = 5.17 < long_int1;

my_class a=2；
布尔检查=5.17<长\u int1；

问题在于编译器无法知道您想要隐式地将

5.17

转换为

my\u类的实例。想想如果有两个不同的类可以接受一个
double
作为唯一的构造函数参数，会发生什么。有两种方法可以解决这个问题

提供一个转换运算符。这将允许编译器将您的
my_class
实例作为
double
读取
切换参数的顺序<代码>！（my_class>5.17）

应该可以正常工作

---

< C++规则禁止使用隐式转换创建一个 要对其调用成员函数的对象。因此，当 对象支持隐式转换，通常定义二进制文件 作为非成员的运算符（如有必要，请交朋友）。作为比较 运算符，我有一个简单的模板基类，它将提供， 假设我的类有一个成员函数

compare

，并从中继承

template <typename T>
class ComparisonOperators
{
    friend bool operator==( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) == 0;
    }
    friend bool operator!=( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) != 0;
    }
    friend bool operator<( T const& lhs, T const& rhs )
    {
        return lhs.compare( rhs ) < 0;
    }
    //  and so on.
};

模板
类比较运算符
{
友元布尔运算符==（T常量和lhs，T常量和rhs）
{
返回lhs.compare（rhs）==0；
}
友元布尔运算符！=（T常量和lhs，T常量和rhs）
{
返回左侧。比较（右侧）！=0；
}
朋友BoOL操作程序提供一个自由函数<代码>布尔操作程序，可能是CLCTO的复制品，为什么我必须提供这个函数？实际上，我有双构造函数，为什么C++不铸双-MyOrthCub？@丹尼斯。在链接问题中看到链接：它只是被解析的方式，标准可能定义。this@AlanStokes，我试过这个不起作用。如果我的_类不能转换为double，并且我不能切换参数的顺序，我该怎么办？如果你进行比较，那么该比较必须为你的类计算一个“值”，并将其与5.17进行比较。这个“值”可以由转换运算符返回。以什么方式不能切换参数？只是代码可读性？我的对象可以更多，然后是MAX\u DOUBLE。我不切换参数，因为此代码由外部系统测试。作为黑客，转换运算符可以返回min（“value”，MAX\u DOUBLE）。他提供了一个转换：
double
到他的类。我说得对吗，在MyClass:：compare函数中，我必须计算
之间的差异（*这个）
和
其他
，然后我必须比较
diff
和
0
？@Denis如果
*这个
应该在
其他
之前排序，等于0是
，你必须做任何必要的事情才能返回一个小于0的
int
，如果
*这个
应该被认为等于
其他*此
应被视为大于
其他
，则大于0。实际上，这意味着什么将取决于对象中的实际数据类型以及您希望如何定义关系。
class MyClass : public ComparisonOperators<MyClass>
{
public:
    int compare( MyClass const& other ) const
    {
        //  return <, == or > 0, according to whether this is
        //  <, == or > other.
    }
}