初识c++(12)之转换函数及explicit的应用

• 转换函数，其实我们一直都在使用，知识没有注意到而已。比如，我们将一个int变量和double变量相加时，编译器会将int转换成double,然后再让两个double相加。那么我们是否可以将一个类对象转换成其他对象呢？答案是可以的，而且这里的其他对象既可以是int这样的内置类型，也可以是我们定义的另一个类。
• 先看一个例子：

#include<iostream>
using namespace std;
class Fraction
{
	public:
	       Fraction(int num,int den = 1):m_numerator(num),m_denominator(den) { }	
		int get_m_n() const {return 	m_numerator;}
	       int get_m_d() const {return 	m_denominator;}
		Fraction& operator+(const Fraction& f){
			int m_n;
			int m_d;
			m_n = m_numerator*f.m_denominator + m_denominator*f.m_numerator;
			m_d = m_denominator*f.m_denominator;
			m_numerator = m_n;
			m_denominator = m_d; 
			return *this;
		} 
	private:
		int m_numerator;
		int m_denominator;
} ;

ostream& operator<< (ostream& os,const Fraction& f){
	os << f.get_m_n() << '/' << f.get_m_d();
	return os;
}

int main(){
	Fraction i(2,5); 
	Fraction f = i + 4;
	cout << f << endl;
	return 0;
} 

结果：

22/5

分析：可见在    Fraction f = i + 4;这句中编译器就将4转换了一个Fraction类。

• 那要怎么样才能避免编译器做出这样的转换了，那就是用explicit关键字来修饰构造函数。

explicit Fraction(int num,int den = 1)
		  :m_numerator(num),m_denominator(den) { }	

• 第二个问题来了，我们怎么将Fraction这个类转换成int这样的变量呢，这样的转换函数就要我们自己来写啦。

#include<iostream>
using namespace std;
class Fraction
{
	public:
	    explicit Fraction(double num,double den = 1)
		  :m_numerator(num),m_denominator(den) { }	
		double get_m_n() const {return 	m_numerator;}
	    double get_m_d() const {return 	m_denominator;}
		Fraction& operator+(const Fraction& f){
			double m_n;
			double m_d;
			m_n = m_numerator*f.m_denominator + m_denominator*f.m_numerator;
			m_d = m_denominator*f.m_denominator;
			m_numerator = m_n;
			m_denominator = m_d; 
			return *this;
		} 
		operator double() const {
			return (double) (m_numerator/m_denominator);
		}
	private:
		double m_numerator;
		double m_denominator;
} ;

ostream& operator<< (ostream& os,const Fraction& f){
	os << f.get_m_n() << '/' << f.get_m_d();
	return os;
}

int main(){
	Fraction i(2,5); 
	cout << i << endl;
	double n = i + 4;
	cout << n << endl;
	return 0;
} 

• 转换函数还可以完成两个类之间的转化：

#include<iostream>
using namespace std;

class complex {
	private :
		double re;
		double im;
	public :
		complex(double r,double i){
			re = r;
			im = i;
		}
		double get_re() const {return re;}
		double get_im() const {return im;}
};


class Fraction
{
	public:
	    explicit Fraction(double num,double den = 1)
		  :m_numerator(num),m_denominator(den) { }	
		double get_m_n() const {return 	m_numerator;}
	    double get_m_d() const {return 	m_denominator;}
		Fraction& operator+(const Fraction& f){
			double m_n;
			double m_d;
			m_n = m_numerator*f.m_denominator + m_denominator*f.m_numerator;
			m_d = m_denominator*f.m_denominator;
			m_numerator = m_n;
			m_denominator = m_d; 
			return *this;
		} 
		operator complex() const {
			return complex(m_numerator,m_denominator);
		}
	private:
		double m_numerator;
		double m_denominator;
} ;

ostream& operator<< (ostream& os,const Fraction& f){
	os << f.get_m_n() << '/' << f.get_m_d();
	return os;
}


ostream& operator<< (ostream& os,const complex& c){
	os << c.get_re() << '+' << c.get_im() << "i";
	return os;
}


int main(){
	Fraction i(2,5); 
	cout << i << endl;
	complex n = i ;
	cout << n << endl;
	return 0;
} 

输出结果：

2/5
2+5i