C++ - explicit关键字

最新推荐文章于 2024-03-21 07:33:03 发布
最新推荐文章于 2024-03-21 07:33:03 发布
阅读量1.9k 收藏 23
点赞数 2
分类专栏： C/C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45676049/article/details/125980252
版权

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

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

凉冰难消一腔热血
关注
  • 2
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ explicit通俗解释
10-08
C++ explicit关键字在刚学的时候就接触到了，也从各处了解了一些，但始终云里雾里，在闲来无事的时候再仔细研究了一下，自己消化理解了一下，自认为比其他网友总结的精简而不失准确。
C++ Explicit关键字详细解析
09-05
以下是对C++中Explicit关键字的用法进行了详细的介绍，需要的朋友可以过来参考下，希望对大家有所帮助
C++关键字explicit的详解及用法
cbNotes的专栏：不积硅步，无以至千里;不积小流，无以成江海!
09-24 5268
在C++中，explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换。 explicit使用注意事项:     *     explicit 关键字只能用于类内部的构造函数声明上。     *     explicit 关键字作用于单个参数的构造函数。     *     在C++中，explicit关键字用
C++中的explicit关键字详解
最新发布
karl2000的专栏
03-21 318
在C++中，explicit关键字用于防止类构造函数、转换运算符或其他函数的隐式自动转换。使用explicit可以提高代码的可读性和健壮性，避免意外的类型转换导致的错误。以下是关于explicit关键字的详细介绍和示例。
C++中的explicit详解
热门推荐
k6604125的博客
08-25 4万+
C++ explicit详解
C++ 中explicit关键字详解
l2563898960的博客
07-30 2万+
目录explicit关键字的作用使用情况类型转换函数单操作数构造函数同时出现拷贝构造函数和类型转换函数拷贝构造函数总结参考文献 explicit关键字的作用 explicit关键字在写程序时使用的次数较少,但是仔细观察会发现,在C++标准库中的相关类声明中explicit出现的频率是很高的,那么explicit关键字到底有什么作用呢?接下来我就为大家一一解答. explicit为清晰的;明确的之意...
C++中的explicit
SHLYYY
02-27 6618
explicit前言0x00 explicit 前言 C++中， 一个类的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)， 承担了两个角色。 1.是个构造器 2.是个默认且隐含的类型转换操作符。 0x00 explicit C++中的关键字 explicit 主要是用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换。类构造函数默认情况下声明为隐式的即 implicit 。 explicit关键字作用于单个参数的构造函数，如果构造函数有多
C++中的explicit关键字实例浅析
08-31
在C++程序中很少有人去使用explicit关键字，不可否认，在平时的实践中确实很少能用的上，再说C++的功能强大，往往一个问题可以利用好几种C++特性去解决。接下来给大家介绍 C++中的explicit关键字,需要的朋友可以参考...
C++中的Explicit关键字
01-20
在C++程序中很少有人去使用explicit关键字，不可否认，在平时的实践中确实很少能用的上。再说C++的功能强大，往往一个问题可以利用好几种C++特性去解决。但稍微留心一下会发现现有的MFC库或者C++标准库中的相关类...
认识 C++ 中的explicit 关键字
12-22
带单一参数的构造函数在缺省情况下隐含一个转换操作符，请看下面的代码：   class MyClass{ public: MyClass(int nParam);// 带一个参数的构造函数 ... //////////////////////////////
C++ 中explicit的作用及用法（虽然简单，但是还是有用的）
weixin_57165154的博客
04-17 1万+
C++ 中explicit的作用及用法（虽然简单，但是还是有用的）
C++ | explicit关键字
做技术人 · 产优质博客 · 找好工作
04-05 1491
面对实例化对象时的隐式类型转换该如何处理，看看C++中的explicit关键字
C++ explicit
qq_24127015的博客
02-20 8515
C++提供了关键字explicit，声明为explicit的构造函数不能在隐式转换中使用。 1)C++的类型转换分为两种，一种为隐式转换，另一种为显式转换。 2)C++中应该尽量不要使用转换，尽量使用显式转换来代替隐式转换。 1隐式转换 定义：隐式转换是系统跟据程序的需要而自动转换的。 1）C++类型(char,int,float,long,double等)的隐式转换： 算...
【C++】explicit关键字
格物致知
05-17 297
explicit的优点是可以避免不合时宜的类型变换，缺点无。所以google约定所有单参数的构造函数都必须是显式的** explicit关键字只需用于类内的单参数构造函数前面。由于无参数的构造函数和多参数的构造函数总是显式调用，这种情况在构造函数前加explicit无意义。 google的c++规范中提到explicit的优点是可以避免不合时宜的类型变换，缺点无。所以google约定所有单参数的构造函数都必须是显式的，只有极少数情况下拷贝构造函数可以不声明称explicit。例如作为其他类的透明包装器的
c++ explicit关键字解读
bitcarmanlee的博客
04-24 2488
1.explicit的作用 我们自己平时写c++代码时候，较少会用到explicit关键字。但是在c++相关的标准类库中，看到explicit关键字的频率还是很高的。既然出现频率这么高，那我们就来看看explicit的作用到底是啥。 2.构造函数隐式转换 为了理解explicit的作用，我们就需要先了解构造函数的隐式转换。为了明白构造函数的隐式转换，我们来看下面的例子。 #include<iostream> #include<cstring> using namespace std;
【C++】explicit 用法
lemonxiaoxiao的博客
01-09 1302
explicit是个C++关键字，其作用是指定仅有一个参数或除第一个参数外其它参数均有默认值的类构造函数不能作为类型转化操作符被隐含的使用，防止该类的对象直接被对应内置类型隐式转化后赋值，从而规定这个构造函数必须被明确调用。对于仅有一个参数或除第一个参数外其余参数均有默认值的类构造函数，尽可能使用explicit关键字修饰。explicit主要就是避免隐式转换，C++ 中的转化真的是太灵活了，容易搞出 bug 来。
C++中explicit关键字是什么意思
05-31
在 C++ 中，`explicit` 是一个关键字，用于修饰类的构造函数。它的作用是防止编译器进行隐式类型转换，强制要求使用显式语法进行构造。 具体来说，如果一个构造函数被声明为 `explicit`，那么它就不能被用于隐式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值