C++ explicit 关键字工程实践
flyfish
本文所有代码均使用C++20实际编译运行验证
- implicit = 隐含的、不明说的、 折在里面、
- explicit = 明说的、明确的、摊开在外的、
1. 为什么需要 explicit?
只要一个类的构造函数能接收一个参数,编译器就会在需要时自动调用这个构造函数,把一个普通类型(比如 int)悄悄转换成一个临时的类对象。这叫隐式转换(implicit conversion)。
比如下面这段代码:
cpp
#include <iostream>
class Number {
public:
Number(int x) {
std::cout << "Constructor Called: " << x << "\n";
}
};
int main() {
Number n = 10; // 注意:这里没有写 Number(10)
}
输出:
Constructor Called: 10
Number n = 10; 里的 = 不是赋值运算符,而是初始化语法 。编译器看到右边是个 int,左边需要一个 Number,而 Number(int) 正好能接收 int,于是它自作主张帮你构造了一个临时 Number 对象再交给 n。
传了个 int,函数却期望一个类对象,编译器不报错而是默默转换,把类型不匹配的错误掩盖了。explicit 的作用就是关掉这条自动转换通道
explicit不禁止构造函数或转换运算符本身,它只禁止它们被用于隐式转换 和复制初始化语境。
2. 四种初始化方式
explicit 到底拦哪些写法、不拦哪些写法,完全取决于 C++ 的初始化分类。
| 写法 | 正式名称 | 能否调用 explicit 构造函数 |
|---|---|---|
T x(arg); |
直接初始化(direct-initialization) | 可以 |
T x = arg; |
复制初始化(copy-initialization) | 不可以 |
T x{arg}; |
直接列表初始化(direct-list-initialization) | 可以 |
T x = {arg}; |
复制列表初始化(copy-list-initialization) | 不可以 |
复制初始化 这个语境比你想象的出现得更频繁,它不只出现在 T x = arg; 里:
- 用
=定义变量:Number n = 42; - 函数按值传参:
print(42);(形参需要用实参构造) - 函数按值返回:
return 42;(返回类型是Number) - 成员变量用
=初始化:Number n = 42;写在类内 return {a, b};这类花括号返回
这就是为什么加了 explicit 之后 Number n = 42; 报错,而 Number n(42); 和 Number n{42}; 仍然合法------后两者属于直接初始化语境,显式构造是被允许的。
一个容易混淆的点:= 不是赋值
初学者经常看到 Number n = 42; 就以为是"先默认构造 n,再把 42 赋给它"。完全不是。在 C++ 标准里,带 = 的这种变量初始化是 copy-initialization,语义上等价于"用 42 构造一个临时 Number,再拷贝/移动给 n"。在 C++17 复制消除规则下,这个临时对象通常被优化掉,但判断是否允许隐式转换时,看的是语法语境,不是最终优化结果。
3. 单参数构造函数(最常见场景)
cpp
#include <iostream>
class Number {
public:
int value;
explicit Number(int v) : value(v) {
std::cout << "Number constructed with " << v << "\n";
}
};
void print(Number n) {
std::cout << "print: " << n.value << "\n";
}
int main() {
// Number n1 = 42; // 编译错误:copy-initialization
Number n2(42); // direct-initialization
Number n3{42}; // direct-list-initialization
// print(100); // 编译错误:按值传参是 copy-initialization
print(Number(100)); // 显式构造临时对象
print(Number{200}); //
}
实际编译运行输出:
Number constructed with 42
Number constructed with 42
Number constructed with 100
print: 100
Number constructed with 200
print: 200
工程建议 :单参数构造函数默认加 explicit。这是 C++ Core Guidelines C.46 的要求:By default, declare single-argument constructors explicit。因为绝大多数单参数构造函数的本意是"用这个值构造一个对象",而不是"允许任意 int 在任何地方自动变成这个对象"。
C.46: By default, declare single-argument constructors explicit
4. 多参数构造函数(C++11 之后必须重视)
在 C++11 引入花括号初始化之前,explicit 主要管单参数构造函数。但 C++11 之后,多参数构造函数也能通过花括号列表被隐式调用了:
cpp
#include <iostream>
class Point {
public:
int x, y;
explicit Point(int a, int b) : x(a), y(b) {}
};
void show(Point p) {
std::cout << p.x << ", " << p.y << "\n";
}
int main() {
//show({10, 20}); // copy-list-initialization 被 explicit 拦截
show(Point{ 10, 20 }); //
show(Point(30, 40)); //
}
10, 20
30, 40
原则 :只要不希望调用者用 {a, b} 这种花括号列表隐式构造你的对象,就给多参数构造函数也加上 explicit。现代 C++ 代码里花括号初始化无处不在,不加 explicit 的多参数构造函数等于把这条隐式通道打开了。
5. 转换运算符 operator T()(C++11 起)
explicit 不只用于构造函数。从 C++11 开始,它也能修饰用户自定义转换运算符,禁止对象被隐式转换成其他类型:
cpp
class Integer {
public:
int data;
explicit Integer(int v) : data(v) {}
explicit operator int() const {
return data;
}
};
int main() {
Integer obj{99};
// int a = obj; // 隐式转换被禁止
int a = static_cast<int>(obj); //
int b = int(obj); // 函数风格强转
}
为什么转换运算符也该默认加 explicit? 因为一个对象能被悄悄转成 int、bool、std::string,往往意味着它会在你意想不到的地方参与运算、匹配重载函数。比如你的类有个 operator int(),那 obj + 1 这种写法就会成立------这通常不是设计者的本意。
6. 特殊设计:explicit operator bool()
这是标准库里被大量使用的惯用法(std::unique_ptr、std::optional、std::ifstream、std::lock_guard 等等):
cpp
#include <iostream>
class FileHandle {
bool is_open_ = false;
public:
explicit FileHandle(bool open) : is_open_(open) {}
explicit operator bool() const {
return is_open_;
}
};
int main() {
FileHandle f(true);
if (f) { // 布尔语境下允许
std::cout << "file is open\n";
}
// int x = f; // 禁止隐式变成 int
// bool b = f; // 普通赋值语境禁止
bool b = static_cast<bool>(f); //
}
这里有个 C++ 标准的特殊规则 :explicit operator bool() 虽然在普通 copy-initialization 语境下被禁止,但在条件语境下仍然允许隐式转换。所谓条件语境包括:
if/else if的条件while的条件for的判断表达式- 逻辑非
!、逻辑与&&、逻辑或||的操作数 - 三元运算符
?:的条件部分
这就是为什么 if (f) 能编译通过,而 bool b = f; 不能。这个设计精确地实现了我们想要的效果:
- 支持
if (file)、while (stream)这种最自然的"对象是否有效"写法 - 同时防止对象被意外赋值给
int、参与算术运算obj + 1、或者匹配到某个接受int的重载函数
7. RAII 场景:explicit 最该用的地方
这是 explicit 在工程上最不可遗漏 的场景。资源管理类(锁、文件句柄、堆内存包装、引用计数)的构造函数几乎必须加 explicit。
cpp
#include <iostream>
#include <mutex>
class ScopedLock {
public:
explicit ScopedLock(std::mutex& m) : mutex_(m) {
mutex_.lock();
std::cout << "locked\n";
}
~ScopedLock() {
mutex_.unlock();
std::cout << "unlocked\n";
}
ScopedLock(const ScopedLock&) = delete;
ScopedLock& operator=(const ScopedLock&) = delete;
private:
std::mutex& mutex_;
};
void do_work(ScopedLock lock) {
std::cout << "doing work\n";
}
int main() {
std::mutex mtx;
{
ScopedLock lock(mtx); // 正常加锁,作用域结束自动解锁
}
// do_work(mtx); // 如果不加 explicit,这行能编译通过!
}
重点说一下这个反例 :如果 ScopedLock 的构造函数没有 explicit,那么 do_work(mtx) 会被编译器接受------它会用 mtx 隐式构造一个临时 ScopedLock 对象作为函数实参。这个临时对象在函数进入时加锁,函数返回时立刻析构解锁,导致锁的生命周期只覆盖函数调用本身,函数外面的代码完全在无锁状态下运行。这是一个极难排查的并发 bug。
我验证过:去掉 explicit 之后,do_work(mtx); 这行没有任何编译错误 ,编译器默默接受了它。这就是为什么 RAII 守卫类的构造函数必须加 explicit------它把一个会引发严重并发错误的隐式转换挡在了编译期。
8. C++20:explicit(bool) 条件显式
C++20 引入了条件 explicit,允许模板根据编译期条件决定构造函数是否显式:
cpp
#include <type_traits>
#include <iostream>
#include <string>
template <typename T>
class Wrapper {
public:
// T 是算术类型(int/double/...):explicit(false),允许隐式转换
// T 不是算术类型:explicit(true),禁止隐式转换
explicit(!std::is_arithmetic_v<T>)
Wrapper(T v) : value(v) {}
T value;
};
int main() {
Wrapper<int> a = 42; // int 是算术类型,允许隐式
Wrapper<double> b = 3.14; // double 也是算术类型
Wrapper<std::string> c("hi"); // 显式构造
// Wrapper<std::string> d = "hi"; // 非算术类型,禁止隐式
}
注意这里的表达式是 explicit(!std::is_arithmetic_v<T>)。逻辑是:
std::is_arithmetic_v<T>为true(T 是 int/double)时,!true = false,即explicit(false),构造函数不是 explicit,允许隐式转换。std::is_arithmetic_v<T>为false(T 是 std::string)时,!false = true,即explicit(true),构造函数是 explicit,禁止隐式转换。
这个特性主要给库作者用,避免为"允许隐式"和"禁止隐式"两种情况写两套构造函数加 SFINAE。普通业务代码很少直接用到。
9. 实践
| 场景 | 建议 | 原因 |
|---|---|---|
| 单参数构造函数 | 默认加 explicit |
防止意外隐式转换 |
| 多参数构造函数 | 通常加 explicit |
防止 {a, b} 隐式构造 |
转换运算符 operator T() |
默认加 explicit |
防止对象悄悄变成其他类型 |
需要 if (obj) 判断有效性 |
用 explicit operator bool() |
安全且自然 |
| RAII / 资源管理类 | 必须加 explicit |
防止临时对象提前析构 |
| 拷贝 / 移动构造函数 | 不要加 | 加了会破坏按值传参和按值返回 |
| 明确想要隐式转换(少数情况) | 不加 | 例如 std::string 从字符串字面量 |
10. 常见误区
误区一:"加了 explicit 就不能用 = 初始化这个类了。"
不对。T x = T(arg); 这种写法仍然可以------= 右边已经是完整类型了,不涉及隐式转换。被禁止的只是"T x = 其他类型"这种跨类型转换。
误区二:"explicit 会影响运行时性能。"
完全不影响。它是纯编译期规则,只决定哪些写法合法,不生成任何额外代码。
误区三:"拷贝构造函数也该加 explicit。"
千万别。拷贝构造函数 T(const T&) 如果加了 explicit,那函数按值传参、按值返回都会出问题,因为那些场景大量依赖隐式拷贝构造。标准库从来不会给拷贝/移动构造函数加 explicit。
误区四:"explicit 只对构造函数有效。"
C++11 起对转换运算符同样有效,C++20 起还支持条件表达式。
参考资料
- cppreference: explicit specifier
- cppreference: Copy-initialization vs Direct-initialization