C++中的 explicit 关键字

C++中定义的 explicit  常在构造函数中使用防止C++的隐式转换，可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。

错误预防技巧11.3：

对于那些不应该被编译器用来执行隐式转换的单参数构造函数，请使用关键字explicit

explicit  关键字在函数声明处使用：

示例：

  explicit Array(int = 10);

C++中， 一个参数构造函数
(或者除了第一个参数外其余参数都有默认值的多参构造函数)
， 承担了两个角色。

1 一个参数的构造函数 是个构造器

2 一个参数的构造函数 是个默认且隐含的类型转换操作符。
  任何单参数的构造函数都可以看做是转换构造函数。

C++中， 一个参数的 构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)， 承担了两个角色。 1 是个 构造器 ，2 是个默认且隐含的类型转换操作符。

所以， 有时候在我们写下如 AAA = XXX， 这样的代码， 且恰好XXX的类型正好是AAA单参数构造器的参数类型， 这时候 编译器就自动调用这个构造器， 创建一个AAA的对象。

这样看起来好象很酷， 很方便。 但在某些情况下（见下面权威的例子）， 却违背了我们（程序员）的本意。 这时候就要在这个构造器前面加上explicit修饰， 指定这个构造器只能被明确的调用，使用， 不能作为类型转换操作符被隐含的使用。 呵呵， 看来还是光明正大些比较好。

示例 一：

Array.h

#ifndef ARRAY_H
#define ARRAY_H

#include <iostream>
#include <iomanip>
using namespace std;






class Array{
	friend ostream& operator<< (ostream&, const Array &);
	friend istream& operator>>  (istream&, Array &);
public:
	Array(int arraySize = 10){
		size = (arraySize > 0 ? arraySize : 10);
		ptr = new int[size];
		for (int i = 0; i < size; i++)
			ptr[i] = 0;

	}
	Array(const Array  &arrayToCopy){
		ptr = new int[size];

		for (int i = 0; i < size; i++){
			ptr[i] = arrayToCopy[i];
		}
	}



	~Array(){
		delete[] ptr;
	}

	int getSize()const{
		return size;
	}

	const Array& operator=(const Array &right){
		if (&right != this){
			if (size != right.size){
				delete[] ptr;
				size = right.size;
				ptr = new int[size];
			}
			for (int i = 0; i < size; i++)
				ptr[i] = right.ptr[i];
		}
		return *this;
	}

	bool operator==(const Array &right)const{
		if (size != right.size)
			return false;

		for (int i = 0; i < size; i++)
			if (ptr[i] != right.ptr[i])
				return false;

		return true;
	}

	bool operator!=(const Array &right)const{
		return !(*this == right);
	}


	int operator[](int subscript)
	{
		if (subscript < 0 || subscript >= size){
			cerr << "\nError: Subscript " << subscript
				<< "out of range" << endl;
			exit(1);
		}

		return ptr[subscript];
	}
	int operator[](int subscript)const{
		if (subscript < 0 || subscript >= size)
		{
			cerr << "\nError: Subscript" << subscript
				<< "out of range" << endl;
			exit(1);
		}
		return ptr[subscript];
	}

private:
	int size;
	int *ptr;
};



#endif





istream& operator>>(istream &input, Array &a){
	for (int i = 0; i < a.size; i++)
		input >> a.ptr[i];
	return input;
}

ostream& operator<<(ostream &output, const Array &a){
	int i;

	for (i = 0; i < a.size; i++){
		output << setw(12) << a.ptr[i];

		if ((i + 1) % 4 == 0)
			output << endl;
	}

	if (i % 4 != 0)
		output << endl;

	return output;
}

主函数：

#include "Array.h"

void outputArray(const Array &);

int main()
{
	Array integers1(7);
	outputArray(integers1);
	outputArray(3);

	return 0;
}


void outputArray(const Array &arrayToOutput)
{
	cout << "The Array received has " << arrayToOutput.getSize()
		<< " elements. The contents are:\n" << arrayToOutput << endl;
}

输出：

可以看出我们并没有定义

参数为int类型的outputArray的输出函数。但是还是输出了，这是什么原因？？？

</pre><pre name="code" class="cpp" style="color: rgb(51, 51, 51); line-height: 23.9999980926514px; text-indent: 28px;">

<span style="line-height: 23.9999980926514px; font-family: arial, 宋体, sans-serif; font-size: 12px;">原因如下：</span><span style="line-height: 23.9999980926514px; font-family: arial, 宋体, sans-serif; font-size: 12px;">编译器确定Array类是否提供了能把int转换成Array的转换构造函数。由于任何单参数的构造函数都可以看做是转换构造函数，编译器就认为接收单个int参数的Array构造函数是一个转换构造函数，并用它将参数3转换成了一个包含了三个元素的临时Array对象。</span></strong></span></span>

解决方法：

修改Array.h代码：

	explicit Array(int arraySize = 10){
		size = (arraySize > 0 ? arraySize : 10);
		ptr = new int[size];
		for (int i = 0; i < size; i++)
			ptr[i] = 0;

	}

修改为如上即可

这时就不能调用转换构造函数了。。。

示例 二：

explicit 构造函数的作用

解析：

explicit构造函数是用来防止隐式转换的。请看下面的代码：

下面示例展示了如何防止隐式转换。

#include <iostream>
using namespace std;


class Text{
public:
	explicit Text(string a) :name(a){
		cout << name.c_str() << endl;
	};
	Text() :name(NULL){
		cout << name.c_str() << endl;
	};
private:
	string name;
};

class Text2{
public:
	Text2(string a) :name(a){
		cout << name.c_str() << endl;
	};
	Text2() :name(NULL){
		cout << name.c_str() << endl;
	};
private:
	string name;
};

int main(){
	Text s = "xxxxxx";
	Text s2("xxxxxxx");
	Text2 s3 = "xxxxxxx";


	return 0;
}

注释掉不能隐式转换后执行结果