C++ explicit

1. 什么是 explicit？​​

explicit 是 C++ 中的一个关键字，用于​​阻止隐式类型转换​​。
它可以用在以下两种场景：

• ​​构造函数​​：防止编译器通过该构造函数进行隐式转换。
• ​​转换运算符​​（C++11 起）：防止通过类型转换运算符的隐式转换。

​​2. 为什么需要 explicit？​​

隐式转换可能导致代码行为不直观，甚至隐藏错误。
例如，一个构造函数接受 int 参数，但你不希望代码中直接传递 int 被自动转换为你的类类型。
explicit 强制程序员​​显式调用转换​​，提高代码安全性和可读性。

​​3. 用于构造函数​​

​​没有 explicit 的情况​​

假设有一个类的构造函数接受 int 参数：

class MyClass {
public:
    MyClass(int x) { /* ... */ }  // 允许隐式转换
};

void func(MyClass obj) {}

int main() {
    func(10);  // 合法！编译器隐式将 10 转换为 MyClass 对象
}

这里，func(10) 会隐式调用 MyClass(int) 构造函数，可能产生意料之外的行为。

​​使用 explicit 后​​

class MyClass {
public:
    explicit MyClass(int x) { /* ... */ }  // 阻止隐式转换
};

void func(MyClass obj) {}

int main() {
    func(10);               // 错误！不能隐式转换
    func(MyClass(10));      // 合法！显式构造
    func(static_cast<MyClass>(10));  // 合法！显式类型转换
}

此时必须​​显式构造对象​​，避免隐式转换带来的歧义。​​

4. 用于转换运算符（C++11 起）​​

假设一个类需要转换为 bool 类型（例如判断对象是否有效）：

class MyClass {
public:
    explicit operator bool() const { 
        return /* 检查是否有效 */; 
    }
};

MyClass obj;
if (obj) { ... }            // 合法！显式转换为 bool
bool b = obj;               // 错误！隐式转换被阻止
bool b = static_cast<bool>(obj);  // 合法！显式转换

只有​​显式调用转换​​时（如 if (obj) 或 static_cast），才会触发转换。

​​5. 关键细节​​

​​1. 隐式转换的常见场景​​

• 函数传参时传递不同类型。
• 赋值初始化（如 MyClass obj = 10;）。

2. ​​explicit 与多参数构造函数（C++11 起）​​

• 即使构造函数有多个参数，只要它们能通过默认参数或列表初始化被调用，也可以标记为 explicit：

explicit MyClass(int a, int b = 0);  // 必须显式调用

3. 何时使用？​​

• 当隐式转换可能导致歧义或错误时（例如智能指针、字符串包装类）。
• 当类设计需要严格类型控制时。

4. 何时不用？​​

• 当隐式转换是安全的且符合直觉时（例如数值类型的包装类）。

​​6. 实际应用示例​​

标准库中的 explicit

1. std::shared_ptr​​ 的构造函数是 explicit 的：

std::shared_ptr<int> p = new int;  // 错误！
std::shared_ptr<int> p(new int);   // 合法！​​

2. std::string​​ 的构造函数接受 const char* 且为 explicit：

void print(const std::string& s);
print("hello");  // 合法！因为 C++17 起允许隐式转换
// 但早期版本可能需要显式转换。

​​7. 总结​​

• 核心作用​​：强制显式类型转换，避免隐式转换的潜在问题。
• ​​代码安全​​：减少因类型自动转换导致的 Bug。
• 代码清晰​​：让类型转换的意图更明确。

通过合理使用 explicit，可以写出更健壮、更易维护的 C++ 代码！