#include 
class X 
{
public:
    X(){}
    X(int){} // int 类型可以被隐式转换成 X
    friend bool operator<(const X& x1, const X& x2) { return true; } // 只是测试，无意义
};

class Y 
{
public:
    Y(){}
    Y(int){} // int 类型可以被隐式转换成 Y
    bool operator<(const Y& y) const { return true; } // 只是测试，无意义
};
int main()
{
    X x;
    if(1 < x) // 合法，使用友元重载函数，1 可以被隐式地转换为 X 类型 －－友元函数的第一个参数
    {}

    Y y;
    if(1 < y) // 不合法，使用成员重载函数，函数的第一个参数是 const *this，1 不能被隐式转换
    {}
    return 0;

}

// 注：编译的时候可以通过注释掉不同的代码来查看错误（即合法性），后面解释不能作为友元全局重载的原因

由上面的代码可以知道，如果将 =,[],(),-> 进行友元全局重载，那么就会出现 1＝x; 1[x]; 1->x; 1(x); 这样的合法语句（起码编译器认为这些是合法的）－－参考代码中的 if(1

#include 

class X 
{
public:
    X(){}
    X(int){} // int 类型可以被隐式转换成 X
    friend const X& operator+=(const X& x1, const X& x2) { return x1; } // 只是测试，无意义
};

int main()
{
    X x;
    1 += x;// 合法，使用友元重载函数，1 可以被隐式地转换为 X 类型 －－友元函数的第一个参数
    return 0;
}