Question

假设我有以下课程：

class Point{
private:
int x,y;

public:
int get_x() const {return x;}
int get_y() const {return y;}

Point() :x(0),y(0){}
Point(int x,int y):x(x),y(y){}
Point(const Point& P){
    x = P.get_x();
    y = P.get_y();
}
Point& operator=   (const Point& P) {
            x = P.get_x();
            y = P.get_y();

    return *this;
}
friend ostream& operator<<(ostream& os,const Point& P) {

    os<<"["<<P.get_x()<<", "<<P.get_y()<<"]";
    return os;
}


Point operator - (const Point &P){
    return Point(x-P.get_x(),y-P.get_y());
}

friend bool operator > (const Point &A, const Point &B) {
    return A.get_y()>B.get_y();
}


};

这里我使用了朋友功能。我也可以使用没有朋友的功能：

class Point{
...
bool operator > (const Point &B) const {
    return y>B.get_y();
}
 ...

};

在实际实施中它们之间有什么区别？同样在第二种方法中，代码不会在没有'cont'的情况下编译，为什么呢？即使在我将getter函数更改为非const函数之后，如果没有'const'，它仍然无法编译。

Answer 1

正如您已经注意到的，比较运算符重载可以作为成员函数实现，也可以作为非成员函数实现。

作为rule of thumb，您应该尽可能将它们实现为非成员非friend函数，因为这会增加封装，并允许（非explicit）转换构造函数用于运营商的任何一方。

比如你的Point课程，无论出于何种原因都有int转换构造函数：

Point(int x);

使用非成员比较运算符，您现在可以执行以下操作：

Point p;
p < 3; // this will work with both a member and non-member comparison
3 < p; // this will **only** work if the comparison is a non-member function

您似乎对何时使用const感到困惑，再次作为比较运算符的经验法则，您应尽可能始终使用const，因为逻辑上的比较不会涉及任何更改对象

由于Point是一个非常小的类，您也可以通过值来取代它，所以按照大多数情况下最不可取的选项是：

// Non-member, non-friend
bool operator>(Point const& A, Point const& B);
bool operator>(Point A, Point B);

// Non-member, friend    
friend bool operator>(Point const& A, Point const& B);
friend bool operator>(Point A, Point B);

// Member
bool Point::operator>(Point const& B) const;
bool Point::operator>(Point B) const;

过载大于操作员有或没有朋友

1 个答案: