C++中的explicit关键字用法

c++中的explicit关键字用来修饰类的构造函数，被修饰的类的构造函数不能进行隐式类型的转换，既然有"显式"那么必然就有"隐式"，那么什么是显示而什么又是隐式的呢？

如果c++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示：

class MyClass
{
public:
     MyClass( int num );
};
....
MyClass obj = 10; //ok,convert int to MyClass

在上面的代码中编译器自动将整型转换为MyClass类对象，实际上等同于下面的操作：

 

MyClass temp(10);
MyClass obj = temp;

上面的所有的操作即是所谓的"隐式转换"。

如果要避免这种自动转换的功能，我们该怎么做呢？使用关键字explicit，将类的构造函数声明为"显示"，也就是在声明构造函数的时候前面添加上explicit即可，这样就可以防止这种自动的转换操作

用下面的例子进行说明：

class Number {
public:
   String type; 

   Number(): type(“void”) { }
   explicit Number(short) : type(“short”) { } 
   Number(int) : type(“int”) { }
};
void Show(const Number& n) { cout << n.type; }
void f()
{
    short s = 42;
    Show(s); //进行了隐式类型转换，调用的是Number(int)

    Show((short)s); //调用的是Number(short)
}

引用一下经典的Bjarne Stroustrup的例子:

class String{

      explicit String(int n);

      String(const char *p);

};

String s1 = 'a'; //错误：不能做隐式char->String转换

String s2(10);   //可以：调用explicit String(int n);

String s3 = String(10);//可以：调用explicit String(int n);再调用默认的复制构造函数

String s4 = "Brian"; //可以：隐式转换调用String(const char *p);再调用默认的复制构造函数

String s5("Fawlty"); //可以：正常调用String(const char *p);

void f(String);

String g()

{

    f(20); //错误：不能做隐式int->String转换

    f("Arthur"); //可以：隐式转换，等价于f(String("Arthur"));

    return 10; //同上

}

在实际代码中的东西可不像这种故意造出的例子。

发生隐式转换，除非有心利用，隐式转换常常带来程序逻辑的错误，而且这种错误一旦发生是很难察觉的。

原则上应该在所有的构造函数前加explicit关键字，当你有心利用隐式转换的时候再去解除explicit，这样可以大大减少错误的发生。