关键字explicit的作用

                                       C++中explicit有什么作用？

      关键字explicit可以禁止“单参数构造函数”被用于自动类型转换
      class Stack
      {
          explicit Stack(int size);
      };
      没有explicit的话Stack s = 40;能编译通过。因为它会把40隐式转换成Stack对象。而有explicit则不能，必需Stack s(40);

具体解释如下：

       我们可以把数字当做对象赋给另一个对象，这样在对该对象表达式进行计算时，首先要对数字进行类型转换，同时判断该类的构造函数的参数是否与数字类型匹配，假如匹配则调用构造函数创建一个临时对象，跟着将该对象赋给赋值操作符左边的对象，最后调用析构函数删除临时对象。我们可以看下面的例子：

#include <iostream>
using namespace std;

class A
{
public:
	A(int x){i = x;cout << "构造函数执行！" << i << endl ;}
	~A() {cout << "析构函数执行！" << i << endl ;}
	void get(){cout << i << endl ;}
private:
	int i ;
};

int main()
{
	A a(99) ;
	a.get() ;
	a = 1000 ; //注意这里1000发生了类型转换。转换成于左边对象a的类型一样
	return 0 ;
}

程序输出的结果如下：

       我们可以看到在执行“a = 1000 ;”时，调用了一次构造函数，这说明1000发生了类型转换。调用类A的构造函数进行类型的转换。那么它是怎么调用的呢？它调用了类A的带参数的构造函数。发现类A带参数的构造函数的参数的类型与其是一样的。所以就调用了该构造函数。其实它就相当于这样：

#include <iostream>
using namespace std;

class A
{
public:
	A(int x){i = x;cout << "构造函数执行！" << i << endl ;}
	~A() {cout << "析构函数执行！" << i << endl ;}
	void get(){cout << i << endl ;}
private:
	int i ;
};

int main()
{
	A a(99) ;
	a.get() ;
	a = A(1000) ; //这里是显示调用构造函数产生一个临时对象，然后将该临时对象赋给对象a
	return 0 ;
}

       程序执行的结果和上面的一样。其实，我们也可以换种方式理解：A本来是一个数据类型，在1000加上括号后，前面加上类型A，这是一种强制类型转换。即我们要将int类型的1000强制转换成类型A。所以这样就会强制调用构造函数。当然，这个构造函数的参数必须与1000的类型一样。比如，我们在构造函数增加一个参数则程序会出错。因为参数的个数不一致的，无法调用该构造函数。

	A(int x,int y){i = x;cout << "构造函数执行！" << i << endl ;}//增加一参数int y

程序出错：

error C2664: “A::A(const A &)”: 不能将参数 1 从“int”转换为“const A &”

       如果我们不想隐式的让数字1000转换成类型A，那么，我们这是就可以使用关键字explicit。请注意是阻止隐式转换，但是显示转换还是可以的。

#include <iostream>
using namespace std;

class A
{
public:
	explicit A(int x){i = x;cout << "构造函数执行！" << i << endl ;}//增加一参数int y
	~A() {cout << "析构函数执行！" << i << endl ;}
	void get(){cout << i << endl ;}
private:
	int i ;
};

int main()
{
	A a(99) ;
	a.get() ;
	a = 1000 ; //构造函数前面加上了关键字explicit，阻止了这种隐式转换，程序出错
	return 0 ;
}

程序出错：（因为阻止了隐式转换）

 error C2679: 二进制“=”: 没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)

       但是显示转换可以，注意显示转换和隐式转换的区别。

#include <iostream>
using namespace std;

class A
{
public:
	explicit A(int x){i = x;cout << "构造函数执行！" << i << endl ;}//增加一参数int y
	~A() {cout << "析构函数执行！" << i << endl ;}
	void get(){cout << i << endl ;}
private:
	int i ;
};

int main()
{
	A a(99) ;
	a.get() ;
	a = A(1000) ; //构造函数前面加上了关键字explicit，阻止了这种隐式转换，但是可以用显示转换
	return 0 ;
}

程序运行正确。