192-C++中的explicit關鍵字

首先, C++中的explicit關鍵字只能用于修飾只有一個引數的類建構式, 它的作用是表明該建構式是顯示的, 而非隱式的，
跟它相對應的另一個關鍵字是implicit, 意思是隱藏的,類建構式默認情況下即宣告為implicit(隱式)，

顯示宣告的建構式和隱式宣告的有什么區別呢? 我們來看下面的例子:

class CxString  // 沒有使用explicit關鍵字的類宣告, 即默認為隱式宣告  
{  
public:  
	char *_pstr;  
	int _size;  
	CxString(int size)  
	{  
		_size = size;                // string的預設大小  
		_pstr = malloc(size + 1);    // 分配string的記憶體  
		memset(_pstr, 0, size + 1);  
	}  
	CxString(const char *p)  
	{  
		int size = strlen(p);  
		_pstr = malloc(size + 1);    // 分配string的記憶體  
		strcpy(_pstr, p);            // 復制字串  
		_size = strlen(_pstr);  
	}  
	// 解構式這里不討論, 省略...  
};  

// 下面是呼叫:  

CxString string1(24);     // 這樣是OK的, 為CxString預分配24位元組的大小的記憶體  
CxString string2 = 10;    // 這樣是OK的, 為CxString預分配10位元組的大小的記憶體  
CxString string3;         // 這樣是不行的, 因為沒有默認建構式, 錯誤為: “CxString”: 沒有合適的默認建構式可用  
CxString string4("aaaa"); // 這樣是OK的  
CxString string5 = "bbb"; // 這樣也是OK的, 呼叫的是CxString(const char *p)  
CxString string6 = 'c';   // 這樣也是OK的, 其實呼叫的是CxString(int size), 且size等于'c'的ascii碼  
string1 = 2;              // 這樣也是OK的, 為CxString預分配2位元組的大小的記憶體  
string2 = 3;              // 這樣也是OK的, 為CxString預分配3位元組的大小的記憶體  
string3 = string1;        // 這樣也是OK的, 至少編譯是沒問題的, 但是如果解構式里用free釋放_pstr記憶體指標的時候可能會報錯, 完整的代碼必須多載運算子"=", 并在其中處理記憶體釋放  

上面的代碼中, “CxString string2 = 10;” 這句為什么是可以的呢? 在C++中, 如果的建構式只有一個引數時, 那么在編譯的時候就會有一個預設的轉換操作:將該建構式對應資料型別的資料轉換為該類物件. 也就是說 “CxString string2 = 10;” 這段代碼, 編譯器自動將整型轉換為CxString類物件, 實際上等同于下面的操作:

CxString string2(10);  
或  
CxString temp(10);  
CxString string2 = temp;  

但是, 上面的代碼中的_size代表的是字串記憶體分配的大小, 那么呼叫的第二句 “CxString string2 = 10;” 和第六句 “CxString string6 = ‘c’;” 就顯得不倫不類, 而且容易讓人疑惑. 有什么辦法阻止這種用法呢? 答案就是使用explicit關鍵字. 我們把上面的代碼修改一下, 如下:

class CxString  // 使用關鍵字explicit的類宣告, 顯示轉換  
{  
public:  
	char *_pstr;  
	int _size;  
	explicit CxString(int size)  
	{  
		_size = size;  
		// 代碼同上, 省略...  
	}  
	CxString(const char *p)  
	{  
		// 代碼同上, 省略...  
	}  
};  

// 下面是呼叫:  

CxString string1(24);     // 這樣是OK的  
CxString string2 = 10;    // 這樣是不行的, 因為explicit關鍵字取消了隱式轉換  
CxString string3;         // 這樣是不行的, 因為沒有默認建構式  
CxString string4("aaaa"); // 這樣是OK的  
CxString string5 = "bbb"; // 這樣也是OK的, 呼叫的是CxString(const char *p)  
CxString string6 = 'c';   // 這樣是不行的, 其實呼叫的是CxString(int size), 且size等于'c'的ascii碼, 但explicit關鍵字取消了隱式轉換  
string1 = 2;              // 這樣也是不行的, 因為取消了隱式轉換  
string2 = 3;              // 這樣也是不行的, 因為取消了隱式轉換  
string3 = string1;        // 這樣也是不行的, 因為取消了隱式轉換, 除非類實作運算子"="的多載  

explicit關鍵字的作用就是防止類建構式的隱式自動轉換.

上面也已經說過了, explicit關鍵字只對有一個引數的類建構式有效, 如果類建構式引數大于或等于兩個時, 是不會產生隱式轉換的, 所以explicit關鍵字也就無效了. 例如:

class CxString  // explicit關鍵字在類建構式引數大于或等于兩個時無效  
{  
public:  
	char *_pstr;  
	int _age;  
	int _size;  
	explicit CxString(int age, int size)  
	{  
		_age = age;  
		_size = size;  
		// 代碼同上, 省略...  
	}  
	CxString(const char *p)  
	{  
		// 代碼同上, 省略...  
	}  
};  
// 這個時候有沒有explicit關鍵字都是一樣的  

但是, 也有一個例外, 就是當除了第一個引數以外的其他引數都有默認值的時候, explicit關鍵字依然有效, 此時, 當呼叫建構式時只傳入一個引數, 等效于只有一個引數的類建構式, 例子如下:

class CxString  // 使用關鍵字explicit宣告  
{  
public:  
	int _age;  
	int _size;  
	explicit CxString(int age, int size = 0)  
	{  
		_age = age;  
		_size = size;  
		// 代碼同上, 省略...  
	}  
	CxString(const char *p)  
	{  
		// 代碼同上, 省略...  
	}  
};  

// 下面是呼叫:  

CxString string1(24);     // 這樣是OK的  
CxString string2 = 10;    // 這樣是不行的, 因為explicit關鍵字取消了隱式轉換  
CxString string3;         // 這樣是不行的, 因為沒有默認建構式  
string1 = 2;              // 這樣也是不行的, 因為取消了隱式轉換  
string2 = 3;              // 這樣也是不行的, 因為取消了隱式轉換  
string3 = string1;        // 這樣也是不行的, 因為取消了隱式轉換, 除非類實作運算子"="的多載  

總結

explicit關鍵字只需用于類內的單引數建構式前面，由于無引數的建構式和多引數的建構式總是顯示呼叫，這種情況在建構式前加explicit無意義，

google的c++規范中提到explicit的優點是可以避免不合時宜的型別變換，缺點無，所以google約定所有單引數的建構式都必須是顯示的，只有極少數情況下拷貝建構式可以不宣告稱explicit，例如作為其他類的透明包裝器的類，
effective c++中說：被宣告為explicit的建構式通常比其non-explicit兄弟更受歡迎，因為它們禁止編譯器執行非預期（往往也不被期望）的型別轉換，除非我有一個好理由允許建構式被用于隱式型別轉換，否則我會把它宣告為explicit，鼓勵大家遵循相同的政策，

講解2

C++提供了關鍵字explicit，可以阻止不應該允許的經過轉換建構式進行的隱式轉換的發生,宣告為explicit的建構式不能在隱式轉換中使用，

C++中， 一個引數的建構式(或者除了第一個引數外其余引數都有默認值的多參建構式)， 承擔了兩個角色，

1 是個構造；2 是個默認且隱含的型別轉換運算子，

所以， 有時候在我們寫下如 AAA = XXX， 這樣的代碼， 且恰好XXX的型別正好是AAA單引數構造器的引數型別， 這時候編譯器就自動呼叫這個構造器， 創建一個AAA的物件，

這樣看起來好像很酷， 很方便， 但在某些情況下， 卻違背了程式員的本意， 這時候就要在這個構造器前面加上explicit修飾， 指定這個構造器只能被明確的呼叫使用， 不能作為型別轉換運算子被隱含的使用，

決議：explicit建構式是用來防止隱式轉換的，請看下面的代碼：

#include <iostream>
using namespace std;
class Test1
{
public :
	Test1(int num):n(num){}
private:
	int n;
};
class Test2
{
public :
	explicit Test2(int num):n(num){}
private:
	int n;
};
 
int main()
{
	Test1 t1 = 12;
	Test2 t2(13);
	Test2 t3 = 14;
		
	return 0;
}

編譯時，會指出 t3那一行error:無法從“int”轉換為“Test2”，而t1卻編譯通過，注釋掉t3那行，除錯時，t1已被賦值成功，

注意：當類的宣告和定義分別在兩個檔案中時，explicit只能寫在在宣告中，不能寫在定義中，