C++转换函数、non-explicit-one-argument构造函数

本文将参考侯捷老师课程来简单介绍C++中的转换函数（conversion function）。

代码

设计一个类Fraction表示分数，包含分子和分母。我们希望它能自动转换为double类型，并参与运算。

class Fraction
{
public:
	Fraction(int num, int den = 1)
		:m_numerator(num), m_denominator(den)
	{
	}
	//转换函数
	operator double() const
	{
		return (double)m_numerator / m_denominator;
	}
 	//转换函数
	operator string() const
	{	
		return to_string(m_numerator) + "/" + to_string(m_denominator);
	}
 
private:
	int m_numerator;        //分子
	int m_denominator;      //分母
};

operator是关键字，它通常和运算符一起使用，表示运算符函数。转换函数不可有参数。

double是函数名，表明了将Fraction转换为double类型。(正是由于此处指明了输出类型，所以该函数没有返回值。编译器会根据函数名决定返回值类型)。

const是限制符，表示在该函数内，不会改变数据成员的值。（明确指定const，避免后期维护或重构时，出现错误）。

函数体内分子除以分母。由于两者均为整数，要使用doule强制转换，否则会返回整数。（为了简化，该代码省略了一些逻辑，如：分母不为0的判断）。

转换函数可以任意转换，只要设计者认为合理，即可。

测试

int main()
{
	Fraction f(3, 5);
	double sum = 4 + f;
	std::cout << "sum = " << sum << std::endl;   //sum = 4.6

	string str = f;
	std::cout << "Result is: " << str << std::endl; //Result is: 3/5

	return 0;
}

给出侯捷老师在源码中找出的例子

non-explicit-one-argument构造函数

在上面例子的基础上，我们稍加改动，加入一个全局的重载+运算符的函数，并删除转换函数。

class Fraction
{
public:
	Fraction(int numerator, int denominator = 1)
		:m_numerator(numerator), m_denominator(denominator)
	{
	}
	Fraction operator+ (const Fraction& opr2)
	{
		//这里不符合运算，就简单写一下，哈哈
		return Fraction(m_numerator + opr2.m_numerator, m_denominator + opr2.m_denominator);
	}
private:
	int m_numerator;        //分子
	int m_denominator;      //分母
};

int main()
{
	Fraction f(3, 5);
	Fraction d2 = f + 4;
	return 0;
}

依旧可以编译通过，调用 non-explicit ctor 将4转换为 Fraction（4，1），然后调用 operator+。

但是当转换函数与 non-explicit ctor 同时存在时，编译器会报错，

但是当可以明确让编译器知道应该用哪一种方式时，即编译通过。

例如：将operator+改为

	double operator+ (double & opr2)
	{
		return (double)m_numerator / m_denominator + opr2;
	}

explicit

当出现这种报错时，也可以使用 explicit关键字， 告诉编译器，我要明确，显式，不存在隐式转换 ，即可通过编译，并得到想要结果。

class Fraction
{
public:
	//去掉 explicit 会报错
	explicit Fraction(int num, int den = 1)
		:m_numerator(num), m_denominator(den)
	{
	}
	//转换函数
	operator double() const
	{
		return (double)m_numerator / m_denominator;
	}
	Fraction operator+ (const Fraction& opr2)
	{
		//这里不符合运算规则，就简单写一下，哈哈
		return Fraction(m_numerator + opr2.m_numerator, m_denominator + opr2.m_denominator);
	}
private:
	int m_numerator;        //分子
	int m_denominator;      //分母
};

int main()
{
	Fraction f(3, 5);
	double sum =  f + 4;
	std::cout << "sum = " << sum << std::endl;   //sum = 4.6
	return 0;
}

去掉 explicit 后

小结

• 严格意义上的转换函数指的是转出函数，即将本类型的对象转换为其他类型对象的函数。这类函数的语法是： operator 转出类型() const { //… return (转出类型)xxx; }
• 广义上的转换函数其实还包括non-explicit-one-argument ctor，该类型的构造函数只需要接收一个参数即可。用于将将收到的参数类型对象转换成本类型对象。当编译器判定可以进行隐式转换的时候，会创建临时对象，自动生成调用non-explicit-one-argument ctor的代码。
• 如果不希望编译器对本类型进行隐式转换，则需在本类型的non-explicit-one-argument ctor前，加上explicit关键字。
• 个人浅见：不要编写出有歧义代码，通过关键字等方式让编译器知道你想要怎么做，给予编译器最优解，保证严谨性，鲁棒性，有良好的编码习惯。