C++ explicit关键字详解
单参数构造函数
单参数构造函数作为隐含的类型转换符号
C++中，一个参数的构造函数(或者除了第一个参数外其余参数都有缺省值的多参构造函数)，承担了两个角色。
1.用于构建单参数的类对象
2.隐含的类型转换操作符．
例如一个类A的构造函数A(int i)就是，既可以用来作为构造器，又可以实现隐式转换A a=1；因为1可以通过构造函数A(int i)转换为一个类A的对象。
#include <iostream> class Base { public : Base(const char data) { std::cout <<"constructor..." <<std::endl; this->m_data = data; } protected : char m_data; }; int main(void) { Base base1('a'); // 用于构建单参数的类对象 Base base2 = 'b'; // 隐含的类型转换操作符 return 0; }
这种方法看起来很方便，但是有时这并不是我们想要的，但是由此可能引入一些其他问题。
由此带来的问题
比如如下的代码就可以正常运行
Base base = 10000; // 由于10000可以被转成char类型
因此C++提供关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换发生．
特别对于如下代码
#include <iostream> #include <cstring> class Base { public : Base(const char *str) { std::cout <<"constructor..." <<std::endl; this->m_length = strlen(str); this->m_cstr = new char[this->m_length + 1]; strcpy(this->m_cstr, str); } Base(const Base &base) { this->m_length = base.m_length; this->m_cstr = new char[this->m_length + 1]; strcpy(this->m_cstr, base.m_cstr); } ~Base() { delete this->m_cstr; } protected : char *m_cstr; int m_length; }; int main(void) { Base base = (char *)10000; // 隐含的类型转换操作符 return 0; }
声明为explicit的构造函数不能在隐式转换中使用，只能显示调用，去构造一个类对象。
拷贝构造函数copy construct
Copy constructor也是同样的，如果Copy constructor被声明为explicit，则这个类对象不能用于传参和函数返回值。但是仍然可以直接调用。
拷贝构造函数的调用时机
我们都知道，在C++中，拷贝构造函数的调用时机有如下三种情况
1.当用类的一个对象去初始化该类的另一个对象时
2.如果函数的形参是类的对象，调用函数，进行形参和实参结合时
3.如果函数的返回值是类的对象，函数执行完成返回调用者时
#include <iostream> class Base { public : Base( ) { //std::cout <<"default constructor..." <<std::endl; this->m_data = '\0'; } Base(char data) { //std::cout <<"simple constructor..." <<std::endl; this->m_data = data; } Base(const Base &base) { std::cout <<"copy constructor..." <<std::endl; this->m_data = base.m_data; } protected : char m_data; }; // 参数为Base对象 void Func(const Base base) { } // 返回值为base对象 Base Func( ) { Base base; return base; } void Copy() { Base b1; Base b2 = b1; } int main(void) { Base base(10); std::cout <<std::endl <<"参数为Base对象..." <<std::endl; Func(base); // 优化未优化情况下均调用1次拷贝构造函数 std::cout <<std::endl <<"返回值为base对象[可被优化]..." <<std::endl; Func(); // 优化情况下调用0次, 未优化情况下调用1次[函数返回时调用] Base b = Func(); // 优化情况下调用0次, 未优化情况下调用2次[函数返回时调用 + 初始化类型b时调用] std::cout <<std::endl <<"用base对象初始化另外一个对象..." <<std::endl; Copy(); // 优化未优化情况下均调用1次拷贝构造函数 return 0; }
但是其实很多现代编译器的返回值优化技巧，返回值时的情况会被优化掉，但是这个并不是我们今天讨论的重点。
具体可参见 RVO-编译器返回值优化
在使用GNU/g++编译器时可以使用”-fno-elide-constructors”选项来强制g++总是调用copy构造函数，即使在用临时对象初始化另一个同类型对象的时候（主要是返回值）
将拷贝构造函数声明为explicit，则会阻止隐式拷贝构造函数的调用。
explicit关键字对拷贝构造函数的限制
这时候我们可以将参数传递或者函数返回修改为引用的方法，而初始化的时候采用显式调用拷贝构造函数。
#include <iostream> class Base { public : Base( ) { //std::cout <<"default constructor..." <<std::endl; this->m_data = '\0'; } explicit Base(char data) { //std::cout <<"simple constructor..." <<std::endl; this->m_data = data; } explicit Base(const Base &base) { std::cout <<"copy constructor..." <<std::endl; this->m_data = base.m_data; } protected : char m_data; }; // 参数为Base对象 void Func(const Base& base) // 传入引用对象 { } // 返回值为base对象 Base& Func( ) { Base base; return base; // 返回引用对象 } void Copy() { Base b1; Base b2(b1); // Base b2 = b1显示调用拷贝构造函数 } int main(void) { Base base(10); std::cout <<std::endl <<"参数为Base对象..." <<std::endl; Func(base); // 优化未优化情况下均调用1次拷贝构造函数 std::cout <<std::endl <<"返回值为base对象[可被优化]..." <<std::endl; Func(); // 优化情况下调用0次, 未优化情况下调用1次[函数返回时调用] //Base b(Func()); 返回局部对象 std::cout <<std::endl <<"用base对象初始化另外一个对象..." <<std::endl; Copy(); // 优化未优化情况下均调用1次拷贝构造函数 return 0; }
总结
C++中，一个参数的构造函数(或者除了第一个参数外其余参数都有缺省值的多参构造函数)，承担了两个角色。
1.用于构建单参数的类对象
2.隐含的类型转换操作符
声明为explicit的构造函数不能在隐式转换中使用，只能显示调用，去构造一个类对象。
explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了
但是将拷贝构造函数声明成explicit并不是良好的设计，一般只将有单个参数的constructor声明为explicit，而copy constructor不要声明为explicit.
————————————————
版权声明：本文为CSDN博主「CHENG Jian」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gatieme/article/details/50867575
