conversion function (自定义类型转换为其余类型)

• 比如自定义了一个Fraction分数类, 它应该可以被转换为double

operator type() const {…};

• 返回值类型默认和type相同
• 函数名operator type()
• 因为function body中不修改数据成员, 因此设置为const.

• 执行2+f时, 首先会检查有没有operator+对应的重载
  • 如果没有, 再看能不能把f转换成数字类型

class Fraction{
public:Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}operator double() const {return double(m_numerator) / double(m_denominator);}
private:int m_numerator;int m_denominator;
};void test() {Fraction f(3,5);cout<<2+f<<endl;
}

non-explicit-one-argument constructor (基本类型转换为自定义类型)

• 执行 f + 1时, 编译器首先去查看Fraction有没有重载+运算符
  • 发现重载了, 但是接收的参数类型是Fraction, 然后再看能不能把1转换成Fraction
  • 发现了non-explicit-one-argument constructor, 调用这个构造函数创建了一个Fraction对象
  • 然后调用了operator+函数
• two parameter 两个形参, one argument 一个实参

class Fraction{
public:Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}Fraction operator+ (const Fraction& f) {return Fraction(this->m_numerator + f.m_numerator, this->m_denominator + f.m_denominator);}
private:int m_numerator;int m_denominator;
};void test() {Fraction f(3,5);Fraction d2 = f + 1;
}

conversion function v.s. non-explicit-one-argument constructor

• Use of overloaded operator ‘+’ is ambiguous
  • 第一种情况 : f使用conversion function可以转换为double类型, 和1相加后, 成为一个数字类型, 可以调用non-explicit-one-argument隐式转换为Fraction对象
  • 第二种情况 : 1先调用non-explicit-one-argument隐式转换为Fraction对象, 然后调用operator+ 两个Fraction对象相加

class Fraction{
public:Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {cout<<"ctor"<<endl;}operator double() const {return double(m_numerator) / double(m_denominator);}Fraction operator+ (const Fraction& f) {return Fraction(this->m_numerator + f.m_numerator, this->m_denominator + f.m_denominator);}
private:int m_numerator;int m_denominator;
};void test() {Fraction f(3,5);Fraction d2 = f + 1;
}

explicit-one-argument constructor

• 将构造函数声明为explicit, 使得无法进行隐式转换. 因此1无法转换为Fraction

class Fraction{
public:explicit Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {cout<<"ctor"<<endl;}operator double() const {return double(m_numerator) / double(m_denominator);}Fraction operator+ (const Fraction& f) {return Fraction(this->m_numerator + f.m_numerator, this->m_denominator + f.m_denominator);}
private:int m_numerator;int m_denominator;
};void test() {Fraction f(3,5);cout<<f + 1<<endl;  //1.6
}