有些场景仍然需要 写成 non-member func进行隐式类型转换（implicit type conversion）

有些场景仍然需要 写成 non-member func进行隐式类型转换（implicit type conversion）
《Effective C++》 条款-24：若所有参数皆需类型转换，请为此采用 Non-member func()

举例： 写一个 operator*， 然后测试其交换律
结论：
当在 member func() 中，写成Entity operator* ( const Entity& e) 会造成不能隐式转换的问题；
当写成 non-member func()时候，写成Entity operator* ( const Entity& e1, const Entity& e2 )
可以完成隐式转换
【注】
在写 operator* 的时候，e1 * e2 return的是一个 临时值，所以函数要 return-by-value
我自己写了一个 operator *=， 可以发现返回值是自身，因此可以 return-by-reference

#include <iostream>

class Entity{
public:
    // 在构造函数中给个初始值，方便后面的 * 运算
    Entity( int x = 0, int y = 0) : _x(x), _y(y){
        std::cout << "ctor" << std::endl;
    }
    Entity( const Entity& e ) : _x(e._x), _y(e._y){
        std::cout << "copy ctor" << std::endl;
    }
    ~Entity( ){
        std::cout << "dtor" << std::endl;
    }

public:
    void Print( ) const{
        std::cout << "x: " << _x << " y: " << _y << std::endl;
    }

    // Entity operator* ( const Entity& e){
    //     this->_x *= e._x;
    //     this->_y *= e._y;
    //     return *this;
    // }

    // p.s 接下面（operator*），如果我写成 *=， 这样能用 const Entity& operator*=(...)吗？
    // 可以的！
    const Entity& operator*= ( const Entity& e){
        this->_x *= e.Get_x();
        this->_y *= e.Get_y();
        return *this;
    }


    // 由于 _x, _y 是 private，所以需要写 func() 得到该变量
    int Get_x( ) const{
        return _x;
    }
    int Get_y( ) const {
        return _y;
    }

private:
    int _x, _y;
};

// 写成 non-member func()
// p.s. 这里不能写成 const Entity& operator*(...) 因为不能对一个临时值进行返回其 reference
const Entity operator* ( const Entity& e1, const Entity& e2 ){
    return Entity( e1.Get_x() * e2.Get_x(), e1.Get_y() * e2.Get_y());
}


int main( ){
    std::cout << "test No.1" << std::endl;
    Entity e1(1, 2);
    Entity e2(3, 4);
    e1.Print();
    e2.Print();
    e1 = e1 * e2;
    e1.Print();

    std::cout << "test No.2" << std::endl;
    Entity e3(1, 2);
    Entity e4(1,2);
    e3 = e3 * 2;
    e3.Print();

    // Entity operator* ( const Entity& e) 时不能隐式转换
    // 写成 non-member func时候可以隐式转换
    e4 = 2 * e4;
    e4.Print();

    // 测试 *=
    std::cout << "test No.3" << std::endl;
    Entity e5(1, 2);
    Entity e6(1, 2);
    e5 *= e6;
    e5.Print();

    return 0;
}