C++中explicit技术探索

C++中explicit技术探索

【原创文章，转载请保留或注明出处：http://blog.csdn.net/yinyhy/article/details/8643094】

       C++编程语言中有很多比较重要的关键字在实际编程中起着非常重要的作用。我们今天为大家介绍的C++explicit关键字就是其中一个应用比较频繁的关键字。

1.问题的引出

       按照默认规定，只有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象，如下面所示：

class String 

{

public:

String ( const char* pString ); // 用C风格的字符串p作为初始化值

~String();

private:

char *m_pString;

}

String s1 = “hello”; //OK 隐式转换，等价于String s1 = String（“hello”）;

但是有的时候可能会不需要这种隐式转换，如下：

class String 

{

String ( int nLength); //本意是预先分配n个字节给字符串

String ( const char* pString ); // 用C风格的字符串p作为初始化值

~String();

private:

char *m_pString;

}

String::String(int nLength)

{

if(nLength > 0)

{

m_pString = new char[nLength];

}

}

String::String(char *pString)

{

pString = new char[strlen(pString)];

strcpy(m_pString, pString);

}

String::~String()

{

if(m_pString != NUU)

{

delete m_pString;

}

}

下面两种写法比较正常：

String s2 ( 10 );   //OK 分配10个字节的空字符串

String s3 = String ( 10 ); //OK 分配10个字节的空字符串

下面两种写法就比较疑惑了：

String s4 = 10; //编译通过，也是分配10个字节的空字符串

String s5 = ‘a’; //编译通过，分配int（‘a’）个字节的空字符串

s4 和s5 分别把一个int型和char型，隐式转换成了分配若干字节的空字符串，容易令人误解。为了避免这种错误的发生，我们可以声明显示的转换，使用explicit 关键字：

class String 

{

explicit String ( int nLength ); //本意是预先分配n个字节给字符串

String ( const char* p ); // 用C风格的字符串p作为初始化值

~String();

}

加上explicit，就抑制了String ( int n )的隐式转换，

下面两种写法仍然正确：

String s2 ( 10 );   //OK 分配10个字节的空字符串

String s3 = String ( 10 ); //OK 分配10个字节的空字符串

下面两种写法就不允许了：

String s4 = 10; //编译不通过，不允许隐式的转换

String s5 = ‘a’; //编译不通过，不允许隐式的转换

因此，某些时候，explicit 可以有效得防止构造函数的隐式转换带来的错误或者误解

2.explicit关键字的作用

       在C++中，如果一个类有只有一个参数的构造函数，C++ 允许一种特殊的声明类变量的方式。在这种情况下，可以直接将一个对应于构造函数参数类型的数据直接赋值给类变量，编译器在编译时会自动进行类型转换，将对应于构造函数参数类型的数据转换为类的对象。如果在构造函数前加上explicit修饰词，则会禁止这种自动转换，在这种情况下， 即使将对应于构造函数参数类型的数据直接赋值给类变量，编译器也会报错。

2.1实例1

explicit只对构造函数起作用，用来抑制隐式转换。如：   
class A

{
A(int a);
};   
int Function(A a);

当调用Function(2)的时候，2会隐式转换为A类型。这种情况常常不是程序员想要的结果，所以，要避免之就可以这样写：
class A

{

explicit A(int a);

};   
int Function(A a);  

这样，当调用Function(2)的时候，编译器会给出错误信息（除非Function有个以int为参数的重载形式），这就避免了在程序员毫不知情的情况下出现错误。

2.2实例2

       C++ explicit关键字用来修饰类的构造函数，表明该构造函数是显式的，既然有"显式"那么必然就有"隐式"，那么什么是显示而什么又是隐式的呢？如果c++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示：
class MyClass  
{  
public:  
MyClass( int num );  
}
MyClass obj = 10; //ok,convert int to MyClass
在上面的代码中编译器自动将整型转换为MyClass类对象，实际上等同于下面的操作：
MyClass temp(10);  
MyClass obj = temp;
上面的所有的C++ explicit关键字相关的操作即是所谓的"隐式转换"。
如果要避免这种自动转换的功能，我们该怎么做呢？这就是关键字explicit的作用了，将类的构造函数声明为"显式"，也就是在声明构造函数的时候前面添加上explicit即可，这样就可以防止这种自动的转换操作，如果我们修改上面的MyClass类的构造函数为显式的，那么下面的代码就不能够编译通过了，如下所示：
class MyClass  
{  
public:  
explicit MyClass( int num );  
}
MyClass obj = 10; //err,can't non-explict convert

3.explicit注意事项

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

（a）构造器

（b）默认且隐含的类型转换操作符

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

将拷贝构造函数声明为explicit，则会阻止隐式拷贝构造函数的调用。隐式拷贝构造函数的调用主要发生在三个点：

1.一个对象作为函数参数，以值传递的方式传入函数体．

2.一个对象作为函数返回值，以值传递的方式从函数返回．

3.以AAA = xxx的方式创建对象AAA，xxx为与AAA为同类型的对象.

因而，将拷贝构造函数声明成explicit并不是良好的设计，一般只将有单个参数的constructor声明为explicit，而copy constructor不要声明为explicit.

4.参考资料

http://www.cnblogs.com/cutepig/archive/2009/01/14/1375917.html

http://www.cnblogs.com/dwdxdy/archive/2012/07/17/2595479.html

http://www.cnblogs.com/liao-xiao-chao/archive/2011/05/30/2063670.html

http://developer.51cto.com/art/201002/183398.htm

http://blog.csdn.net/sunyonggao/article/details/1598816