条款24 若所有参数皆需类型转换，请为此采用non-member函数

/*条款24 若所有参数皆需类型转换，请为此采用non-member函数*/
#include<iostream>
using namespace std;
class Rational{
public:
	Rational(int numerator = 0, int denominator = 1):n(numerator),d(denominator){

	}
	int numerator()const {
		return n;
	}
	int denominator()const{
		return d;
	}
	/*const Rational operator*(const Rational&rhs)const{
		return Rational(n*rhs.n, d*rhs.d);
	}*/
	friend ostream &operator<<(ostream& os, const Rational & rhs);
private:
	int n, d;
};
ostream &operator<<(ostream &os, const Rational & rhs){
	return os << rhs.n << "/" << rhs.d ;
}
const Rational operator*(const Rational&lhs, const Rational&rhs){
	return Rational(lhs.numerator()*rhs.numerator(), lhs.denominator()*rhs.denominator());//operator* 也不必是Rational的友元函数
}
//问题 :如果你想支持算术运算，定义成non-member or member?
int main(){
	Rational oe(1, 8);
	Rational oh(1, 2);
	Rational res = oh*oe;
	cout << res << endl;
	res = res*oe;
	cout << res << endl;
	res = oh * 2;        /*res = oh.operator*(2) 单参构造
						 如果构造是 explicit 这句也过不了
						 const Rational temp(2)根据2建立一个暂时性的Rataional对象 就等同于res = oh.operator*(temp)
------------
结论：只有当参数被列于参数列内，这个参数才是隐式类型转换的合格参与者 地位相当于“被调用的成员函数所隶属的那个对象”即this对象的那个隐喻参数 绝不是隐式转换的合格参与者
  那么解决的方法就是让operator* 成为一个non-member函数 允许编译器在每一个实参身上执行隐式类型转换
						 */
	//cout << res << endl;
	//res = 2 * oh       // res = 2.operator*(oh) 当然错了
	//res = operator*(2, oh);
	//--------------------------non-member的测试
	res = 2 * oh;
	cout << res << endl;

	system("pause");
	return 0;
}