C++中的explicit关键字详解

目录

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

前言

最近在阅读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++中的explicit关键字详解的文章就介绍到这了,更多相关C++ explicit 内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！