自由屋推书网—热门的小说推荐平台!

你的位置: 首页 > 其他程序

C++中的explicit关键字详解

2022-07-27 10:02:42

最近在阅读android底层源码的时候,发现其中好多代码使用了explicit关键字,因此这里对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); // right

Sales_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, 因为取消了隐式转换, 除非类实现操作符"="的重载
C++

最新推荐

编辑推荐

热门小说