/*条款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;
}
条款24 若所有参数皆需类型转换,请为此采用non-member函数
最新推荐文章于 2022-12-03 14:35:05 发布