explicit（显式的）：作用是"禁止单参数构造函数"被用于自动类型转换

non-explicit:

class Fraction
{
public:
	Fraction(int num,int den=1)
	  :m_numerator(num),m_denominator(den){}
	Fraction operator +(const Fraction& f){
		return Fraction(......);
		}
private:
	int m_numerator; //分子
	int m_denominator;//分母
}
//调用
Fraction f(3,5);
Fraction d2=f+4;
//在调用的时候，因为有函数Fraction operator +(const Fraction& f)，因此编译器会判断4是否能转换成Fraction，
//如果能的话则可以调用函数Fraction operator +(const Fraction& f)，此函数即为Fraction operator +(this，const Fraction& f)
//由于有构造函数Fraction(int num,int den=1)，因此4可转换为Fraction(4,1)

并存报错的形式：

class Fraction
{
public:
	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& f){
		return Fraction(......);
		}
private:
	int m_numerator; //分子
	int m_denominator;//分母
}
//调用
Fraction f(3,5);
Fraction d2=f+4;
//编译器不知道是应该把4转换为Fraction还是应该用转换函数将f转换成double，所以会报错

构造函数加explicit：

class Fraction
{
public:
	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& f){
		return Fraction(......);
		}
private:
	int m_numerator; //分子
	int m_denominator;//分母
}
//调用
Fraction f(3,5);
Fraction d2=f+4;
//此处在进行f+4的时候，由于构造函数加了explicit，4就不会再变成1/4的Fraction形式了，此时编译器就不会进行Fraction operator +(const Fraction& f)的函数了，因为4不能转成Fraction的形式，因此只能调用operator double()const函数，将f转换成double的形式
//此时得到的d2是double值，不能转换成Fraction的形式，故报错