C++11：explicit 关键字

在 C++ 中，explicit关键字用于防止类的构造函数或转换运算符进行隐式类型转换。

默认情况下，如果一个构造函数只需要一个参数，或者一个转换运算符只转换为一个特定类型，编译器会自动使用它们进行隐式转换。虽然这可以使代码更加简洁，但有时也会导致意料之外的行为，尤其是在类型转换不明显或不期望发生时。

通过在构造函数或转换运算符前添加explicit关键字，可以要求编译器只在显式转换时使用这些函数，从而增加代码的清晰度和安全性。

explicit 构造函数

在构造函数前使用explicit关键字可以防止编译器自动使用该构造函数进行隐式转换。

防止隐式转换的构造函数的代码示例：

MyClass 类有一个接受 int 类型参数的构造函数：

class MyClass {
public:
    int value;
    
    // 没有 explicit 关键字，允许隐式转换
    MyClass(int v) : value(v) {}
};

void func(MyClass mc) {
    // ...
}

int main() {
    MyClass obj = MyClass(10); // 正确，直接初始化
    MyClass obj2 = 10; // 正确，隐式类型转换
    func(10); // 正确，隐式类型转换，将 int 类型的 10 转换为 MyClass 类型
    return 0;
}

在上面的代码中，调用 func 时，int 类型的 10 被隐式转换为 MyClass 类型。这是因为 MyClass 的构造函数允许隐式转换。

现在，我们通过在构造函数前添加explicit关键字来修改MyClass，防止这种隐式转换：

class MyClass {
public:
    int value;
    
    // 使用 explicit 关键字，禁止隐式转换
    explicit MyClass(int v) : value(v) {}
};

void func(MyClass mc) {
    // ...
}

int main() {
    MyClass obj = MyClass(10); // 正确，直接初始化
    // MyClass obj2 = 10; // 错误，禁止隐式类型转换
    // func(10); // 错误：不能隐式转换 int 为 MyClass
    func(MyClass(10)); // 正确：显式转换
    return 0;
}

通过将构造函数声明为explicit，编译器将不再自动将 int 类型的值隐式转换为 MyClass 类型。这样，只有当显式进行类型转换时，编译器才会调用该构造函数，从而避免了可能的错误或混淆。

explicit 转换运算符

C++11 引入了能够将对象转换为某种类型的转换运算符，并且可以通过explicit关键字防止这些转换运算符的隐式使用。

防止隐式转换的转换运算符代码示例：

class BoolWrapper {
public:
    bool value;
    BoolWrapper(bool v) : value(v) {}
    
    // 使用 explicit 关键字，禁止隐式转换
    explicit operator bool() const {
        return value;
    }
};

void check(bool flag) {
    // ...
}

int main() {
    BoolWrapper bw(true);
    // check(bw); // 错误：不能隐式转换 BoolWrapper 为 bool
    check(static_cast<bool>(bw)); // 正确：显式转换
    return 0;
}

在这个例子中，BoolWrapper 类有一个转换为 bool 类型的转换运算符。通过在该转换运算符前添加explicit关键字，我们阻止了其隐式转换的可能性。

explicit 关键字的重要性

使用explicit关键字可以避免因隐式类型转换而引入的潜在错误，增加代码的清晰度和类型安全性。

尤其是在设计类库或 API 时，合理使用explicit关键字可以使得类的使用者更加清楚地了解类型转换的行为，避免不必要的逻辑错误。

总之，explicit关键字是 C++ 提供的一个重要特性，它可以帮助开发者编写出更加安全、清晰的代码。