explicit

                              explicit 用法

explicit用来防止构造函数自动转换

若我们在定义了的构造函数前加上explict，则在我们定义对象时，要想用到该构造函数必须是显示调用，所用隐式的操作都将被认为是错误的。(引用他人代码)

Code:

1. 1 class Test1   
2.   
3. 　　2 {   
4.   
5. 　　3 public:   
6.   
7. 　　4 Test1(int n) { num = n; } //普通构造函数   
8.   
9. 　　5 private:   
10.   
11. 　　6 int num;   
12.   
13. 　　7 };   
14.   
15. 　　8    
16.   
17. 　　9 class Test2   
18.   
19. 　　10 {   
20.   
21. 　　11 public:   
22.   
23. 　　12 explicit Test2(int n) { num = n; } //explicit(显式)构造函数   
24.   
25. 　　13 private:   
26.   
27. 　　14 int num;   
28.   
29. 　　15 };   
30.   
31. 　　16    
32.   
33. 　　17 int main()   
34.   
35. 　　18 {   
36.   
37. 　　19 Test1 t1 = 12; //隐式调用其构造函数, 成功   
38.   
39. 　　20 Test2 t2 = 12; //编译错误,不能隐式调用其构造函数   
40.   
41. 　　21 Test2 t3(12); //显示调用成功   
42.   
43. 　　22 return 0;   
44.   
45. 23 }   
46.   

　　我们再来看另一个例子：

Code:

1. class one   
2.   
3. {   
4.   
5. public:   
6.   
7.   one(){}   
8.   
9. };   
10.   
11. class two   
12.   
13. {   
14.   
15. public:   
16.   
17.   two(const one&){}   
18.   
19. };   
20.   
21. void f(two);   
22.   
23. int main()   
24.   
25. {   
26.   
27.     one tone;   
28.   
29.     f(tone);   
30.     return 0;   
31.   
32. }   

有代码中我们就可以看出我们并未定义f(one)这样一个函数，但是我们的程序是运行成功的，这是为什么呢?---隐式转换。当我们调用函数f(tone);时，编译器会会去查找名字为f的这样的函数，若找到他会检查对应的形参类型是否匹配。若不匹配，他还会检查是否可以发生隐式的转换，即这两个不同的类型间可以相互转换吗？若可以仍可以进行调用。否则则会产生编译错误,在我们本程序中，编译器会检查到类two的构造函数。他可以帮助进行隐式转换，故程序可以运行。若我们不想此情况的发生，在two的构造函数前加上explicit即可。即只允许显示的调用该构造函数。

但是这样的隐式转换只能发生一级:如:

 

Code:

1. #include <iostream>   
2. using namespace std;   
3. class one   
4. {   
5. public:   
6.   one(){}   
7. };   
8.   
9. class two   
10. {   
11. public:   
12.   two(const one&){}   
13. };   
14. class three   
15. {   
16. public:   
17.   three(const two&){}   
18. };   
19.   
20. void f(three);   
21.   
22. int main()   
23. {   
24.     one tone;   
25.     f(tone);//error cannot convert one to three   
26.     return 0;   
27. }   
28.