C++中的explicit关键字(转)

本文介绍了C++中关于类类型的隐式类型转换,并详细解释了如何使用explicit关键字来阻止这种转换,避免潜在的错误。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

原创作品,转载请标明http://blog.csdn.NET/xiejingfa/article/details/48369081


问题

我们知道,C++在内置类型之间存在隐式类型转换。而在类类型中,也存在这样一种类型转换:当一个类的构造函数只有参数时,会将该类型的一个值隐式转换为对应的类类型。比如下面一个例子:

  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class Example  
  5. {  
  6. public:  
  7.     int e;  
  8.     Example(int n)  
  9.     {  
  10.         e = n;  
  11.     }  
  12. };  
  13.   
  14. int main()  
  15. {  
  16.     Example example1(100);  // 调用了默认构造函数  
  17.     Example example2 = 200; // 进行了隐式初始化  
  18.     cout << example1.e << endl; // 输出100  
  19.     cout << example2.e << endl; // 输出200  
  20. }  
#include <iostream> 
using namespace std;

class Example
{
public:
int e;
Example(int n)
{
e = n;
}
};

int main()
{
Example example1(100); // 调用了默认构造函数
Example example2 = 200; // 进行了隐式初始化
cout << example1.e << endl; // 输出100
cout << example2.e << endl; // 输出200
}隐式类型转换往往容易发生错误,为了禁止上述的隐式类型转换可以使用explicit关键字。

explicit关键字

explicit关键字用来修饰类的构造函数,被该关键字修饰的类,不能发生上述的隐式类型转换,只能以显形的方式进行类型转换。

  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. class Example  
  5. {  
  6. public:  
  7.     int e;  
  8.     explicit Example(int n)  
  9.     {  
  10.         e = n;  
  11.     }  
  12. };  
  13.   
  14. int main()  
  15. {  
  16.       
  17.     Example example1 = 100; // Error 不存在从”int”到”Example”的适当构造函数  
  18.     Example example2 = static_cast<Example>(200); // 显示转换  
  19.     cout << example2.e;    // 输出200  
  20. }  
#include <iostream> 
using namespace std;

class Example
{
public:
int e;
explicit Example(int n)
{
e = n;
}
};

int main()
{

Example example1 = 100; // Error 不存在从"int"到"Example"的适当构造函数
Example example2 = static_cast&lt;Example&gt;(200); // 显示转换
cout &lt;&lt; example2.e;    // 输出200

}

总结

1、explicit关键可以屏蔽编译器缺省的隐式类型转换;

2、explicit关键字只能用于类内部的构造函数声明,而不能于在类外部的函数声明;

3、explicit只有在构造器只传一个参数的情况下有意义,当构造函数的参数超过两个时会自动取消隐式类型转换。

### C++ 中 `explicit` 关键字的作用和用法 #### 单参数构造函数中的使用 在C++中,`explicit`关键字主要用于防止编译器执行不必要的隐式类型换。当定义了一个只接受单一参数的构造函数时,如果不加`explicit`修饰,则该构造函数可以被用来实现从其参数类型的对象到类类型的隐式换。这可能会导致一些难以察觉的错误。 通过声明为`explicit`,能够阻止这些潜在危险的行为发生,使得只有显式的强制换才能触发此类构造过程[^1]: ```cpp class MyClass { public: // 不带 explicit 的构造函数允许隐式换 MyClass(int value); }; void func(MyClass obj); int main() { int num = 5; // 下面这一行会因为存在无参构造而成功编译并运行, // 导致意料之外的对象创建行为。 func(num); } ``` 如果我们将上述例子中的构造函数改为带有`explicit`的关键字形式: ```cpp class MyClass { public: // 带有 explicit 的构造函数不允许隐式explicit MyClass(int value); }; ``` 此时再尝试传递整数给期望接收`MyClass`实例的地方将会引发编译期报错,除非程序员明确指定了类型换操作。 #### 换运算符上的应用 除了应用于单个参数的构造函数外,`explicit`也可以标注于用户自定义类型之间的换运算符上。同样地,这样做是为了避免不希望发生的自动型情况的发生: ```cpp class IntWrapper { private: int m_value; public: // 显式指定此换仅能由显示换完成 explicit operator bool() const noexcept { return static_cast<bool>(m_value); } }; ``` 在这个案例里,即使有一个布尔上下文环境(比如条件判断),也不会让`IntWrapper`对象直接参与逻辑表达式的求值;相反,必须采用静态或动态方式来实施必要的变动作。 关于多参数构造的情况,并不在`explicit`的应用范围内,因此对于这种情况下的处理方法并不涉及`explicit`关键字本身[^2]。然而值得注意的是,在某些版本之后的标准库支持下,可以通过大括号语法来进行初始化列表风格的新建工作,但这属于另一个话题了。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值