Question

我有两个文件：

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

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
}

我不明白，我在哪里弄错了。我重载了运算符<。另外，我constructor类型double。

当然，我还在this scheme之前实现了其他5个运算符（==, !=, >, <=, =>）。其他运算符位于同一名称空间中，但它们不是成员函数。

测试用例：

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

Answer 1

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

你写了一次，然后你所要做的就是提供一个（成员）功能，并从中得出：

class MyClass : public ComparisonOperators<MyClass>
{
public:
    int compare( MyClass const& other ) const
    {
        //  return <, == or > 0, according to whether this is
        //  <, == or > other.
    }
}

Answer 2

问题是编译器无法知道您想要隐式地将5.17转换为my_class的实例。想想如果你有两个不同的类可以接受double作为唯一的构造函数参数会发生什么。有两种方法可以解决这个问题。

提供转换运算符。这将允许编译器将my_class的实例读作double。
切换参数的顺序。 !(my_class > 5.17)应该可以正常工作。

没有操作员＆＃34;＆lt;＆＃34;匹配这些操作数的操作数类型是：double＆lt;我的课

2 个答案: