C++ - explicit关键字

最近在阅读android底层源码的时候，发现其中好多代码使用了explicit关键字，因此这里对explicit关键字进行了分析和介绍。

文章目录

C++ - explicit关键字
- 1. 抑制构造函数定义的隐式转换
- 2. 为转换显式地使用构造函数
- 3. 类型转换运算符可能产生意外结果
- 4. 显示的类型转换运算符
- 5. explicit练习
- - 5.1 当不使用explict关键字时
  - 5.2 使用explict关键字时
  - 5.3 explicit 标识的构造函数中存在一个默认值

1. 抑制构造函数定义的隐式转换

在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为explicit加以组织：

class Sales_data {public:Sales_data() = default;Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n) {}explicit Sales_data(const std::string &s): bookNo(s) {}explicit Sales_data(std::istream&);Sales_data& combine(const Sales_data &rhs) {units_sold += rhs.units_sold;revenue += rhs.revenue;;return *this;}private:double avg_price() const {return units_sold ? revenue / units_sold : 0; }string bookNo;unsigned units_sold = 0;double revenue = 0.0;
};

此时，没有任何构造函数能用于隐式地创建Sales_data对象：下面的两种用法都无法通过编译：

Sales_data item;        // right, 调用默认构造函数
Sales_data item2("book");  // right, 调用explicit Sales_data(const std::string &s): bookNo(s) {}
item.combine(null_book);   // error: string构造函数式explicit的
item.combine(cin);         // error: istream构造函数式explicit的

关键字 explicit 只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行隐式转换，所以无须将这些构造函数指定为 explicit 的。只能在类内声明构造函数时使用 explicit 关键字，在类外部定义时不应重复：

// error: explicit 关键字只允许出现在类内的构造函数声明处
explicit Sales_data::Sales_data(istream& is) {read(is, *this);
}

note1: explicit 构造函数只能用于直接初始化。
note2: 当使用explicit 关键字声明构造函数时，它将只能以直接初始化的形式使用。而且，编译器将不会在自动转换过程中使用该构造函数。

发生隐式转换的一种情况时当我们执行拷贝的初始化时（使用 = ）。此时，我们只能使用直接初始化而不能使用explicit构造函数：

Sales_data null_book("book", 1, 10.0); // rightSales_data item1(null_book);  // right，直接初始化
Sales_data item2 = null_book; // error, 不能将explicit 构造函数用于拷贝形式的初始化过程

2. 为转换显式地使用构造函数

尽管编译器不会将 explicit 的构造函数用于隐式转换过程，但是我们可以使用这样的构造函数显式地强制进行转换：

Sales_data null_book("book", 1, 10.0); // right// right: 直接初始化
item.combine(Sales_data(null_book));// right: static_cast可以使用explicit的构造函数
item.combine(static_cast<Sales_data>(cin));

在第一个调用中，我们直接使用Sales_data的构造函数，该调用通过接受string构造函数创建了一个临时的 Sales_data 对象。在第二个调用中，我们使用 static_cast 执行了显式的而非隐式的转换。其中 static_cast 使用 istram 的构造函数创建了一个临时的Sales_data对象。

3. 类型转换运算符可能产生意外结果

《C++ prime》第五版，14.9.1中关于类型转换的介绍：

在实践中，类很少提供类型转换运算符。在大多数情况下，如果类型转换自动发生，用户可能会感觉比较意外，而不是感觉受到了帮助。然而这条经验法则存在一种例外情况：对于类来说，定义向bool的类型转换还是比较普遍的现象。

在C++标准的早期版本中，如果类想定义一个向bool的类型转换，则它常常遇到一个问题：因为bool是一种算术类型，所以类类型的对象转换成bool后就能被用在任何需要算数类型的上下文中。这样的类型转换可能引发意想不到的结果，特别是当istream含有向bool的类型转换时，下面的代码仍将通过编译：

int i = 42;
cin << i; // 如果向bool的类型转换不是显式的，则该代码在编译器看来将是合法的！
// 这个程序只有在输入数字的时候，i会默认为整数，输入字符串则会为0

这段程序视图将输出运算符用作输入流。因为istream本身并没有定义<<，所以本来代码应该产生错误。然而，该代码能使用istream的bool类型转换运算符将cin转换成bool，而这个bool值接着会被提升成int并用作内置的左移运算符的左侧运算对象。这样一来，提升后的bool值（1或0）最终会被左移42个位置。这一结果显示与我们的预期大相径庭。

4. 显示的类型转换运算符

为了防止这样的异常情况发生，C++11新标准引入了显式的类型转换运算符（explicit conversion operator）：

class SmallInt {public:// 编译器不会自动执行这一类型转换explicit operator int() const {return val;}// 其他成员与之前的版本一致
};

和显示的构造函数一样，编译器（通常）也不会将一个显式的类型转换运算符用于隐式类型转换：

SmallInt si = 3; // 正确：SmallInt的构造函数不是显式的
si + 3;             // 错误：此处需要隐式的类型转换，但类的运算符是显式的
static_cast<int>(si) + 3;    // 正确：显示地请求类型转换。这里的static_cast<int>可以进行强制类型转换

当类型转换运算符是显式的时，我们也能执行类型转换，不过必须通过显式的强制类型转换才可以。

该规定存在一个例外，即如果表达式被用作条件，则编译器会将显式的类型转换自动应用于它。换句话说，当表达式出现在下列位置时，显式的类型转换将被隐式地执行：

if、while及do语句的条件部分
for 语句头的条件表达式
逻辑非（！）、逻辑或（||）、逻辑与（&&）的运算对象
条件运算符（？ : ）的条件表达式

5. explicit练习

5.1 当不使用explict关键字时

// explicit关键字的作用就是防止类构造函数的隐式自动转换
// 并且explicit关键字只对有一个参数的类构造函数有效，如果类构造函数参数大于
// 或等于两个时，是不会产生隐式转换的，所有explicit关键字也就无效了。
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>using namespace std;class CxString // 这里没有使用explicit关键字的类声明，即默认为隐式声明
{public:char *_pstr;int _size;CxString(int size) {cout << "CxString(int size), size = " << size << endl;_size = size;   // string的预设大小_pstr = (char*)malloc(size + 1);memset(_pstr, 0, size + 1);}CxString(const char *p) {int size = strlen(p);_pstr = (char*)malloc(size + 1); // 分配string的内存strcpy(_pstr, p);_size = strlen(_pstr);cout << "CxString(const char *p), strlen(p) = " << size << endl;}~CxString() {if (_pstr != nullptr) {delete(_pstr);_pstr = nullptr;}}
};int main() {CxString string1(24);     // right, 为CxString预分配24字节的大小的内存  CxString string2 = 10;    // right, 为CxString预分配10字节的大小的内存  CxString string3;         // error, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用  CxString string4("aaaa"); // right  CxString string5 = "bbb"; // right, 调用的是CxString(const char *p)  CxString string6 = 'c';   // right, 其实调用的是CxString(int size), 且size等于'c'的ascii码  string1 = 2;              // right, 为CxString预分配2字节的大小的内存  string2 = 3;              // right, 为CxString预分配3字节的大小的内存  CxString string3 = string1;        // right, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放return 0;
}

上面的代码中, “CxString string2 = 10;” 这句为什么是可以的呢? 在C++中, 如果的构造函数只有一个参数时, 那么在编译的时候就会有一个缺省的转换操作:将该构造函数对应数据类型的数据转换为该类对象. 也就是说 “CxString string2 = 10;” 这段代码, 编译器自动将整型转换为CxString类对象, 实际上等同于下面的操作:

CxString string2(10);
或
CxString temp(10);
CxString string2 = temp;

但是, 上面的代码中的_size代表的是字符串内存分配的大小, 那么调用的第二句 “CxString string2 = 10;” 和第六句 “CxString string6 = ‘c’;” 就显得不伦不类, 而且容易让人疑惑. 有什么办法阻止这种用法呢? 答案就是使用explicit关键字. 我们把上面的代码修改一下, 如5.2小节。

5.2 使用explict关键字时

// explicit关键字的作用就是防止类构造函数的隐式自动转换
// 并且explicit关键字只对有一个参数的类构造函数有效，如果类构造函数参数大于
// 或等于两个时，是不会产生隐式转换的，所有explicit关键字也就无效了。
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>using namespace std;class CxString // 这里没有使用explicit关键字的类声明，即默认为隐式声明
{public:char *_pstr;int _size;int _age;explicit CxString(int size) {cout << "CxString(int size), size = " << size << endl;_size = size;   // string的预设大小_pstr = (char*)malloc(size + 1);memset(_pstr, 0, size + 1);}CxString(const char *p) {int size = strlen(p);_pstr = (char*)malloc(size + 1); // 分配string的内存strcpy(_pstr, p);_size = strlen(_pstr);cout << "CxString(const char *p), strlen(p) = " << size << endl;}// 上面也已经说过了, explicit关键字只对有一个参数的类构造函数有效。// 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了.explicit CxString(int age, int size) {_age = age;_size = size;}~CxString() {if (_pstr != nullptr) {delete(_pstr);_pstr = nullptr;}}
};int main() {CxString string1(24);     // right, 为CxString预分配24字节的大小的内存  CxString string2 = 10;    // error, 因为取消了隐式转换   CxString string3;         // error, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用  CxString string4("aaaa"); // right  CxString string5 = "bbb"; // right, 调用的是CxString(const char *p)  CxString string6 = 'c';   // error, 其实调用的是CxString(int size), 且size等于'c'的ascii码, 因为取消了隐式转换 string1 = 2;              // error, 因为取消了隐式转换  string2 = 3;              // error, 因为取消了隐式转换 CxString string3 = string1;        // right, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放return 0;
}

5.3 explicit 标识的构造函数中存在一个默认值

但是, 也有一个例外, 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效, 此时, 当调用构造函数时只传入一个参数, 等效于只有一个参数的类构造函数, 例子如下:

class CxString  // 使用关键字explicit声明
{
public:  int _age;  int _size;  // 此时该构造函数等效于只有一个参数的类构造函数，explicit可以生效explicit CxString(int age, int size = 0)  {  _age = age;  _size = size;  // 代码同上, 省略...  }  CxString(const char *p)  {  // 代码同上, 省略...  }
};  // 下面是调用:  CxString string1(24);     // right CxString string2 = 10;    // error, 因为explicit关键字取消了隐式转换  CxString string3;         // error, 因为没有默认构造函数  string1 = 2;              // error, 因为取消了隐式转换  string2 = 3;              // error, 因为取消了隐式转换  string3 = string1;        // error, 因为取消了隐式转换, 除非类实现操作符"="的重载

参考文献：
1. C++ explicit关键字详解
2. 《C++ Primer》第五版