C++之explicit

在 C++ 中，explicit 关键字用于修饰类的构造函数，以防止编译器在某些情况下进行隐式转换或拷贝初始化。以下是对 explicit 关键字的详细解释和使用示例。

为什么使用 explicit

在 C++ 中，如果一个构造函数只有一个参数，那么该构造函数可以被用于隐式类型转换。例如：

class Foo {
public:
    Foo(int x) {
        // 构造函数的实现
    }
};

void doSomething(Foo f) {
    // 函数实现
}

int main() {
    doSomething(42); // 这里发生了隐式转换：int -> Foo
    return 0;
}

在上述代码中，调用 doSomething(42) 时，编译器会自动将 42 转换为 Foo 类型。这种隐式转换有时可能导致难以发现的错误。

为了解决这个问题，可以使用 explicit 关键字来禁止这种隐式转换：

cpp

class Foo {
public:
    explicit Foo(int x) {
        // 构造函数的实现
    }
};

void doSomething(Foo f) {
    // 函数实现
}

int main() {
    // doSomething(42); // 这将导致编译错误，因为隐式转换被禁止
    doSomething(Foo(42)); // 必须显式地创建 Foo 对象
    return 0;
}

使用 explicit 的场景

1. 单参数构造函数： 如果构造函数只有一个参数，且不希望它被用于隐式转换，则可以使用 explicit 关键字。

2. 防止意外的隐式转换： 在编写库或大型项目时，使用 explicit 可以避免意外的类型转换，增加代码的可读性和安全性。

示例代码

以下是一个更完整的示例：

#include <iostream>

class Foo {
public:
    explicit Foo(int x) : value(x) {
        std::cout << "Foo(int) constructor called with value: " << x << std::endl;
    }

    int getValue() const {
        return value;
    }

private:
    int value;
};

void doSomething(Foo f) {
    std::cout << "Doing something with Foo, value is: " << f.getValue() << std::endl;
}

int main() {
    // doSomething(42); // 错误：无法从 'int' 到 'Foo' 的转换

    Foo a(42);       // 合法：显式调用
    doSomething(a);  // 合法：传递 Foo 对象

    doSomething(Foo(58)); // 合法：显式创建 Foo 对象

    return 0;
}

在上述代码中，如果尝试将 int 类型直接传递给 doSomething 函数，会导致编译错误，因为 Foo 的构造函数被标记为了 explicit，从而禁止了隐式转换。

总结

explicit 关键字在 C++ 中非常有用，能够防止意外的隐式类型转换，增强代码的安全性和可读性。在定义单参数构造函数时，建议优先考虑使用 explicit，除非确实需要支持隐式转换。