c++隐式类类型转换和explicit关键字详解

前言

关于c++中的隐式类型转换，一种是内置数据类型的转换，还有一种就是自定义数据类型的转换，例如类。下面我们来详细探讨一下c++中隐式类类型转换。
在c++prime中有：可以用单个形参来调用的构造函数都定义了从形参类型到类类型的隐式转换。在这里需要特别注意用单个形参来调用的构造函数并不是一定只有一个参数，它可以有多个参数，但是这些形参都是有默认值的。下面会通过几个例子把这两种形式（构造函数只有一个形参和构造函数有多个形参，但是有默认值）都讲解一下。

单行参构造函数例子

#include <iostream>
using namespace std;
class A
{
	public:
		A(int x):m(x){
			cout << "A()" << endl;
		}
		bool Isequal(A b)
		{
			cout << b.m << endl;
			return b.m == m;
		}
		~A()
		{
			cout << "~A():" << m << endl;
		}
	private:
		int m;
		
};
int main()
{
	A y(5);
	A x = 6; 
	cout << y.Isequal(0) << endl;
	return 0;
}

代码解析：
首先，我们可以看到有一个类A，并且其构造函数有一个形参，这就满足了隐式类类型转换的条件（单形参构造函数），类A中还有一个普通的成员函数，该成员函数接受一个参数，并且参数类型也是类A。
再看一下在main函数中的三条语句是否都有涉及到隐式类型转换。

A y(5);

很明显，这一句仅仅是调用了类的构造函数而已，不涉及某一种类型到该类的类型转换。

A x = 6; 

上面这行赋值代码，很明显存在隐式转换。可以看到x是类A的一个实例，而等号右边6是一个int型的数字，所以这里编译器会先把整型数字6通过类A的构造函数创建一个临时的A的实例，然后将这个临时的实例赋值给x。所以这里就存在由形参的类型（int）转换成该类类型，这个过程就是所谓的隐式转换的过程。
再看一下第三句代码：

cout << y.Isequal(0) << endl;

短暂思考一下，这一句代码有涉及到隐式转换吗？
1s,2s,3s,。。。。
emmm， 好了，下面我们一起来分析看看吧。
可以看一下Isequal（）这个函数它接收的参数类型是类A的类型，但是我们传进去的参数是0，是一个整型数字，不符合函数的参数类型要求。不过还有类A是有一个接收int型参数的构造函数，编译器则隐式的调用了这个构造函数将int型转换为类A的一个临时对象作为参数传给了Isequal函数。
接下来我们来看一下程序运行的结果：

可以看到，后面两行代码都进行了隐式转换，调用构造函数创建临时的对象。事实上，隐式转换类似于我们编写了如下代码：

A x = 5;
//类似于如下：
A temp(5);//创建一个临时的对象
A x = temp;//将该临时对象赋值给x

多形参的构造函数例子

前面我们也说过，隐式类型转换不仅仅局限于构造函数只有一个参数，还可以用在构造函数有多个参数，但是这些参数都有默认的值。举一个例子：

#include <iostream>
#include <math.h>
using namespace std;
class A
{
	public:
		A(int x,float y = 3.5):m(x),n(y){
			cout << "A()" << endl;
		}
		bool Isequal(A b)
		{
			cout << b.m << endl;
			return b.m == m;
		}
		~A()
		{
			cout << "~A():" << m << endl;
		}
	private:
		int m;
		float n;
		
};
int main()
{
	A y(5);
	A x = 6; 
	cout << y.Isequal(0) << endl;
	return 0;
}

还是前面的代码，只不过现在的构造函数接受两个参数，但是float n 是有默认值的。同样的，在main函数中的如下两句代码：

	A x = 6; 
	cout << y.Isequal(0) << endl;

上面两句代码都进行了隐式的类型转换。虽然构造函数是接收两个形参，但是由于float n具有默认值，也就是说该构造函数也接受一个形参来调用该构造函数的。所以上面两句代码中，编译器会分别把6和0通过调用构造函数来创建两个临时的对象，并把0和6分别赋值给两个临时变量的成员变量m。
事实上，像这样的隐式类型转换都存在隐患，因为他们都在我们不知情的情况下创建了临时的对象，有什么办法避免吗？这时候就轮到explicit关键字上场了。

explicit关键字

c++提供的explicit关键字，其作用就是防止类构造函数的隐式自动转换。这里也需要注意的是，explicit关键字是用来修饰只有一个参数的构造函数或者除了第一个参数之外的参数都有默认值的多参构造函数。现在我们对上面的函数加上explicit关键字修饰来看看：

#include <iostream>
#include <math.h>
using namespace std;
class A
{
	public:
		explicit A(int x,float y = 3.5):m(x),n(y){
			cout << "A()" << endl;
		}
		bool Isequal(A b)
		{
			cout << b.m << endl;
			return b.m == m;
		}
		~A()
		{
			cout << "~A():" << m << endl;
		}
	private:
		int m;
		float n;
		
};
int main()
{
	A y(5);
	A x = 6; 
	cout << y.Isequal(0) << endl;
	return 0;
}

编译程序结果如下：

可以看到第一条错误是从int型到A类型的转换是不允许的，第二个是不匹配接收int参数的函数，可见，explicit阻止了隐式类类型转换。
在effective c++中的导读有提到：被声明为explicit的构造函数通常比其no_explicit兄弟更受欢迎，因为他们限制了编译器执行我们不期望的类型转换。