explicit 关键字

explicit 是 C++ 中一个非常重要且常用的关键字，它用于修饰构造函数和转换函数，其核心作用是防止编译器进行隐式的自动类型转换。

---

1. 用于构造函数（最常见的使用场景）

问题：隐式转换的陷阱

我们先看一个没有 explicit 的例子：

cpp

class MyString {
private:
    char* m_data;
public:
    // 构造函数：从 const char* 创建 MyString
    MyString(const char* str) { // 注意：这里没有 explicit
        std::cout << "MyString 构造函数被调用\n";
        // ... 分配内存并复制字符串 ...
    }

    // 其他成员函数...
};

void printString(const MyString& str) {
    std::cout << "打印字符串\n";
}

int main() {
    MyString s1("Hello"); // 正确：显式调用构造函数

    printString(s1);      // 正确：传递 MyString 对象

    // 问题所在：隐式转换发生了！
    printString("World"); // 编译通过！编译器自动用 "World" 构造了一个临时的 MyString 对象

    return 0;
}

输出：

text

MyString 构造函数被调用
打印字符串
MyString 构造函数被调用  // 这一行是隐式转换产生的！
打印字符串

在上面的代码中，printString("World") 这行代码之所以能工作，是因为编译器悄悄地执行了以下步骤：

1. 发现 printString 需要一个 MyString 类型的参数。

2. 发现你提供了一个 const char* 类型的参数。

3. 发现 MyString 类有一个接受 const char* 的构造函数。

4. 自动调用这个构造函数，用 "World" 创建了一个临时的 MyString 对象。

5. 将这个临时对象传递给 printString 函数。

这种隐式转换可能带来问题：

• 性能开销：创建临时对象是有成本的（分配内存、复制数据）。

• 意料之外的行为：代码可能执行了开发者并未意识到的操作，导致逻辑错误，难以调试。

• 代码意图不清晰。

解决方案：使用 explicit

现在，我们在构造函数前加上 explicit：

cpp

class MyString {
private:
    char* m_data;
public:
    // 使用 explicit 关键字
    explicit MyString(const char* str) {
        std::cout << "MyString 构造函数被调用\n";
        // ... 分配内存并复制字符串 ...
    }
};

void printString(const MyString& str) {
    std::cout << "打印字符串\n";
}

int main() {
    MyString s1("Hello");     // 正确：显式调用，不受影响
    printString(s1);          // 正确：传递 MyString 对象

    // printString("World");   // 错误！编译不通过！
    // 不能再进行隐式转换了

    // 正确的做法：显式转换
    printString(MyString("World")); // 正确：显式创建临时对象
    printString(static_cast<MyString>("World")); // 正确：显式转换

    return 0;
}

通过添加 explicit，我们强制了代码的明确性。 调用者必须清楚地知道自己正在创建一个 MyString 对象，避免了潜在的误用和性能陷阱。

---

2. 用于转换函数（C++11 开始）

explicit 也可以用于修饰用户定义的类型转换运算符，防止隐式转换到其他类型。

没有 explicit 的转换函数：

cpp

class BoolWrapper {
    bool value;
public:
    BoolWrapper(bool b) : value(b) {}

    // 转换函数：将 BoolWrapper 转换为 bool
    operator bool() const { // 没有 explicit
        return value;
    }
};

void checkBool(bool b) {
    std::cout << (b ? "真" : "假") << std::endl;
}

int main() {
    BoolWrapper bw(true);

    checkBool(bw); // 隐式转换！BoolWrapper 被自动转换为 bool
    if (bw) {      // 隐式转换！在条件语句中被自动转换为 bool
        std::cout << "条件为真\n";
    }

    int i = bw;    // 可能很危险！先隐式转换为 bool，再转换为 int
    std::cout << i << std::endl; // 输出 1

    return 0;
}

使用 explicit 的转换函数：

cpp

class BoolWrapper {
    bool value;
public:
    BoolWrapper(bool b) : value(b) {}

    // 使用 explicit 的转换函数
    explicit operator bool() const {
        return value;
    }
};

int main() {
    BoolWrapper bw(true);

    // checkBool(bw);        // 错误！不能隐式转换为 bool
    checkBool(static_cast<bool>(bw)); // 正确：必须显式转换

    if (bw) {               // 正确：在 if/while/for 等上下文中是特例，允许 explicit 转换
        std::cout << "条件为真\n";
    }

    // int i = bw;          // 错误！不能隐式转换为 int
    int i = static_cast<bool>(bw); // 正确：必须显式转换

    return 0;
}

注意：explicit operator bool() 是一个非常重要的特例，它在逻辑上下文（如 if, while, for, !, &&, || 等）中可以被隐式使用，这使其非常适用于安全布尔 idiom，但在其他需要布尔值的场合（如函数参数、算术运算）则必须显式转换。