-1

不确定我将如何解释上述内容。

'this != rhs' 中的 'operator!=' 不匹配| 错误| 从“Collection* {aka Collection*}”类型的右值初始化“Collection&”类型的非常量引用无效|

我有两种方法，一种调用另一种方法。但是，当我按原样运行代码时，我会收到上面的错误消息。

Collection&  Collection::operator=(const Collection&& rhs)
        {
                   if (this!= rhs)// <--- Error |no match for 'operator!=' in 'this != rhs'
                    {
                        return copy(rhs);//<---Error| invalid initialization of non-const reference of type 'Collection&' from an rvalue of type 'Collection* {aka Collection*}'
                    }
                    return *this;
         }

Collection& Collection::copy(const Collection& coll)
{

}
4

3 回答 3

2

假设你已经定义operator!=了，你会想说if (*this != rhs)。this如果要检查它们的值是否相等，则需要取消引用指针。否则，如果您要查看它们是否是完全相同的对象（可能在这种情况下），那么您需要获取rhswith的地址this != &rhs。此解决方案不需要任何运算符重载，因为您只是比较两个指针，任何类型的指针都已支持该指针。

于 2012-04-26T17:00:36.377 回答
2

自赋值检查不再被视为惯用的 C++。它通常不如复制和交换。惯用的赋值运算符是这样的：

Collection& Collection::operator=(Collection rhs) {
    swap(rhs);
    return *this;
}

这假设您已经定义了复制和移动构造函数和一个swap函数。此外，启用移动语义的类应该采用非常量右值引用。右值引用的全部目的是改变右值——const右值是毫无价值的。这是一个简单的示例，我使用堆分配int的资源作为示例资源。

class Collection {
    int* ptr; // example resource
public:
    Collection(const Collection& c) {
        ptr = new int(*c.ptr); // copy
    }
    Collection(Collection&& c) {
        ptr = c.ptr; // move
        c.ptr = nullptr;
    }
    void swap(Collection& rhs) {
        std::swap(ptr, rhs.ptr); // swap
    }
    Collection& operator=(Collection rhs) {
        swap(rhs);
        return *this;
    }
    ~Collection() {
        delete ptr; // rule of three, bitch
    }
};
于 2012-04-26T17:06:49.903 回答
1

this是Collection*,rhs是const Collection&&. 你不能!=在他们之间。您应该转换rhs为const Collection*via &rhs。 

if (this!= &rhs)

更好的是，编写一个赋值运算符，如果你尝试自赋值也没关系。

于 2012-04-26T17:00:53.523 回答