关键字explicit

关键字只能用在类构造函数。它的作用是不能进行隐式转换。

 1 class gxgExplicit  //没有关键字explicit的类
 2 
 3 {
 4 
 5 public:
 6 
 7    int _size;
 8 
 9    gxgExplicit(int size)
10 
11    {
12 
13       _size = size;
14 
15    }
16 
17 };

下面是调用

   gxgExplicit gE1(24);     //这样是没有问题的

   gxgExplicit gE2 = 1;     //这样也是没有问题的

   gxgExplicit gE3;         //这样是不行的，没有默认构造函数

   gE1 = 2;                 //这样也是没有问题的

   gE2 = 3;                 //这样也是没有问题的

   gE2 = gE1;               //这样也是没有问题的

但是假如gxgExplicit修改为Stack，我们的_size代表的是堆栈的大小，那么调用的第二句就显得不伦不类，而且容易让人疑惑。这并不是可以让代码阅读者明白和接受的形式，虽然它是合法的（编译器可以通过编译）。这是因为编译器默认情况下有隐式转换的功能，你输入gE2 = 1就编译成同第一句相同的结果。所以，explicit就派上了用场。修改代码为：

 1 class gxgExplicit
 2 
 3 {
 4 
 5 public:
 6 
 7    int _size;
 8 
 9    explicit gxgExplicit(int size)
10 
11    {
12 
13       _size = size;
14 
15    }
16 
17 };

继续上面的调用:

   gxgExplicit gE1(24);     //这样是没有问题的

   gxgExplicit gE2 = 1;     //这样是不行的，关键字取消了隐式转换

   gxgExplicit gE3;         //这样是不行的，没有默认构造函数

   gE1 = 2;                 //这样是不行的，关键字取消了隐式转换

   gE2 = 3;                 //这样是不行的，关键字取消了隐式转换

   gE2 = gE1;               //这样是不行的，关键字取消了隐式转换，除非类实现操作符“=”的重载。

这是编译器（vs2005）显示：cannot convert from 'int' to 'gxgExplicit'。

从这里也就看出这个关键字的作用是将编译器隐式转换的功能给屏蔽掉。

MSDN上有一个注意点描述了下面的事实，当构造函数参数超过两个时自动取消隐式转换。例如

 1 class gxgExplicit
 2 
 3 {
 4 
 5 private:
 6 
 7    int _size;
 8 
 9    int _age;
10 
11 public:
12 
13    explicit gxgExplicit(int age, int size)
14 
15    {
16 
17       _age = age;
18 
19       _size = size;
20 
21    }
22 
23 };

这是有没有关键字效果是一样的。那就是相当于有这个关键字。

但是另外一种情况例外：其中只有一个必须输入的参数，其余的为有默认值的参数。

 1 class gxgExplicit
 2 
 3 {
 4 
 5 private:
 6 
 7    int _size;
 8 
 9    int _age;
10 
11 public:
12 
13    explicit gxgExplicit(int age, int size = 0)
14 
15    {
16 
17       _age = age;
18 
19       _size = size;
20 
21    }
22 
23 };