C++转换函数 （conversion function）与 C++中explicit关键字

C++转换函数 （conversion function）与 C++中explicit关键字

本文将介绍C++中的转换函数（conversion function）和 C++中explicit关键字。

1、c++中explicit的作用

​ 作用：在c++中，explicit只能用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换。

 class Circle  
 {  
 public:  
    Circle(double r) : m_R(r) {}  
    Circle(int x, int y = 0) : m_X(x), m_Y(y) {}  
    Circle(const Circle& c) : m_R(c.R), m_X(c.X), m_Y(c.Y) {}  
 private:  
     double m_R;  
     int    m_X;  
     int    m_Y;  
 };  

 int main()  
 {  
 //发生隐式类型转换  
 //编译器会将它变成如下代码  
 //tmp = Circle(1.23)  
 //Circle A(tmp);  
 //tmp.~Circle();  
     Circle A = 1.23;   
 //注意是int型的，调用的是Circle(int x, int y = 0)  
 //它虽然有2个参数，但后一个有默认值，任然能发生隐式转换  
     Circle B = 123;  
  //这个算隐式调用了拷贝构造函数  
     Circle C = A;  
     return 0;  
 } 

加入explicit的例子如下：

class Circle  
{  
 public:  
     explicit Circle(double r) : m_R(r) {}  
     explicit Circle(int x, int y = 0) : m_X(x), m_Y(y) {}  
     explicit Circle(const Circle& c) : m_R(c.R), m_X(c.X), m_Y(c.Y) {}  
 private:  
     double m_R;  
     int    m_X;  
     int    m_Y;  
};  

int main()  
{  
//以下3句，都会报错  
//Circle A = 1.23;   
//Circle B = 123;  
//Circle C = A;  
       
//只能用显示的方式调用，但根据拷贝构造函数是否也加了explicit关键字，也可以分为两种情况  
//未给拷贝构造函数加explicit之前可以这样  
      Circle A = Circle(1.23);  
      Circle B = Circle(123);  
      Circle C = A;  

//给拷贝构造函数加了explicit后只能这样了  
      Circle A(1.23);  
      Circle B(123);  
      Circle C(A);  
      return 0;  
 } 

2、转换函数（conversion function）

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

Fraction类的代码如下，下文会对该代码做详细的分析。

class Fraction
{
public:
	Fraction(int numerator, int denominator = 1)
		:m_numerator(numerator), m_denominator(denominator)
	{
	}
	//转换函数
	operator double() const
	{
		return (double)m_numerator / m_denominator;
	}

private:
	int m_numerator;        //分子
	int m_denominator;      //分母
};

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

3、转换函数的分析

转换函数的定义如下：

//转换函数

operator double() const
{
	return (double)m_numerator / m_denominator;
}

operator是关键字，它通常和运算符一起使用，表示运算符函数。

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

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

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

4、测试代码

调用转换函数的代码如下：

double sum = 4 + f;

当编译器看到这行代码时会做什么呢？

首先，它会寻找+操作符是否有重载了参数为double和Fraction的函数。很明显，我们并没有为刚刚新建的类Fraction重载+操作符，编译器的该次尝试以失败告终。

接着，不轻言放弃的编译器发现操作符+可以接收两个double类型的参数，那么是否可以将Fraction转换为double，从而调用该版本的函数呢？这次编译器成功了，因为我们刚刚实现了转换为double的函数。

最终，编译器成功实现了求和操作，输出了结果4.6。

4.扩展
我们来扩展一下转换功能。考虑能否将Fraction转化为其它类型，如string。

转换函数的定义如下：
//转换函数

operator string() const
{	
	return to_string(m_numerator) + "/" + to_string(m_denominator);
}

调用转换函数的代码如下：

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

代码的分析与转换为double类型相同，就不多叙述了。

5、转换函数 （conversion function）VS C++中no explicit

class Fraction
{
public:
	Fraction(int numerator, int denominator = 1)
		:m_numerator(numerator), m_denominator(denominator)
	{
	}
	//转换函数
	operator double() const
	{
		return (double)m_numerator / m_denominator;
	}
	int GetNumerator const()
	{
		return m_numerator;
	}
	int GetDenominator const()
	{
	 	return m_denominator;
	}
	Fraction oprateor + (const Fraction& f)
	{
	    int nNumerator = this->m_numerator*f.GetDenominator() + this->m_denominator* f.GetNumerator();
	    int nDenominator = this->m_denominator*F.GetDenominator();
		return Fraction(nNumerator, nDenominator);
	}
private:
	int m_numerator;        //分子
	int m_denominator;      //分母
};

int main()
{
	Fraction f(3,5);
	Fraction sum = 4 + f;  //Error ambiguous 编译器不知道调用哪个 f可以转为double 4也可以转为Fraction对象
	
    return 0;
}

注意：此时在构造函数前加上关键字explicit后，你认为上述的代码能够运行嘛？

其实也不可以此时编译器会提示 double 不能转化为Fraction对象，编译器会报错

怎样才可以使得函数运行起来？

去掉转化函数operator double() const，不加explicit关键字，main函数种的代码能正常的跑起来

革命尚未成功，同志还需努力！！