C++中explicit关键字怎么用

发布时间：2021-12-24 11:33:58 作者：小新
来源：亿速云阅读：158

# C++中explicit关键字怎么用

## 1. 引言

在C++编程中，类型转换是一个重要的概念。编译器在某些情况下会自动执行隐式类型转换，虽然这种机制提供了便利，但也可能带来意想不到的问题。`explicit`关键字正是为了解决这类问题而设计的。本文将深入探讨`explicit`关键字的用法、原理以及实际应用场景。

## 2. explicit关键字的基本概念

### 2.1 什么是explicit关键字

`explicit`是C++中的一个关键字，用于修饰类的构造函数，表示该构造函数只能被显式调用，不能用于隐式转换。它的主要作用是防止编译器进行不期望的自动类型转换。

### 2.2 为什么需要explicit

在没有`explicit`关键字的情况下，C++编译器会在某些场合自动调用单参数构造函数进行隐式转换。例如：

```cpp
class MyClass {
public:
    MyClass(int x) { /*...*/ }
};

void func(MyClass obj) {}

int main() {
    func(10);  // 编译器会自动调用MyClass(10)
}

这种隐式转换可能导致代码难以理解和维护，甚至引入难以发现的错误。explicit关键字可以避免这种情况。

3. explicit的使用方法

3.1 基本语法

explicit关键字用于构造函数声明前：

class MyClass {
public:
    explicit MyClass(int x) { /*...*/ }
};

3.2 使用场景

3.2.1 单参数构造函数

最常见的用法是修饰单参数构造函数：

class String {
public:
    explicit String(int size);  // 禁止int到String的隐式转换
};

3.2.2 多参数构造函数(C++11起)

从C++11开始，explicit也可以用于多参数构造函数：

class Point {
public:
    explicit Point(int x, int y);  // 禁止{10,20}到Point的隐式转换
};

3.2.3 转换运算符(C++11起)

C++11还允许explicit用于转换运算符：

class Rational {
public:
    explicit operator double() const;  // 禁止Rational到double的隐式转换
};

3.3 使用示例

class Timer {
public:
    explicit Timer(int seconds) : duration(seconds) {}
    
    int getDuration() const { return duration; }

private:
    int duration;
};

void setTimer(Timer t) {
    std::cout << "Timer set for " << t.getDuration() << " seconds\n";
}

int main() {
    // setTimer(5);  // 错误：不能隐式转换int到Timer
    setTimer(Timer(5));  // 正确：显式构造
    setTimer(static_cast<Timer>(5));  // 正确：显式转换
}

4. explicit的实际应用

4.1 防止意外的类型转换

考虑一个表示文件路径的类：

class FilePath {
public:
    FilePath(const char* path) : path_(path) {}
    
    // 没有explicit可能导致问题
    // explicit FilePath(const char* path) : path_(path) {}
    
    std::string path_;
};

void openFile(const FilePath& path) {
    std::cout << "Opening: " << path.path_ << std::endl;
}

int main() {
    openFile("config.txt");  // 可能不是我们期望的行为
}

4.2 提高代码安全性

在智能指针设计中，explicit可以防止意外的所有权转移：

template<typename T>
class SmartPtr {
public:
    explicit SmartPtr(T* ptr) : ptr_(ptr) {}
    // ...
};

void process(SmartPtr<int> ptr);

int main() {
    int* raw = new int(42);
    // process(raw);  // 错误：需要显式转换
    process(SmartPtr<int>(raw));  // 明确的所有权转移
}

4.3 在STL中的应用

标准库中大量使用explicit，例如：

std::unique_ptr的构造函数是explicit的
std::shared_ptr的构造函数是explicit的
std::string的从const char*的构造函数在C++11后不是explicit的

5. explicit与类型转换的深入探讨

5.1 隐式转换的规则

C++中隐式转换发生在以下情况： 1. 函数参数传递 2. 函数返回值 3. 表达式求值 4. 初始化

5.2 explicit如何影响转换

explicit构造函数禁止以下隐式转换： 1. 从参数类型到类类型的转换 2. 在函数调用时的参数转换 3. 使用赋值语法初始化

5.3 显式转换的方式

即使构造函数是explicit的，仍然可以通过以下方式显式转换： 1. 直接初始化：T obj(arg) 2. 静态转换：static_cast<T>(arg) 3. C风格转换：(T)arg

6. explicit的最佳实践

6.1 何时使用explicit

建议在以下情况下使用explicit： 1. 单参数构造函数（除非明确需要隐式转换） 2. 多参数构造函数（C++11起） 3. 转换运算符（C++11起） 4. 任何可能导致歧义的构造函数

6.2 何时不使用explicit

在以下情况下可以不使用explicit： 1. 拷贝构造函数（通常不需要） 2. 移动构造函数（通常不需要） 3. 明确需要隐式转换的情况（如std::string从const char*的构造）

6.3 现代C++中的建议

现代C++风格指南（如Google C++ Style Guide）推荐： - 对所有单参数构造函数使用explicit - 对多参数构造函数考虑使用explicit - 对转换运算符使用explicit

7. explicit的高级用法

7.1 条件性explicit(C++20)

C++20引入了条件性explicit，可以根据模板参数决定是否explicit：

template<typename T>
class Wrapper {
public:
    explicit(!std::is_convertible_v<T, Wrapper<T>>) Wrapper(T) {}
};

7.2 与SFINAE结合

可以与SFINAE技术结合，创建更灵活的类型转换控制：

template<typename T>
class SmartHandle {
public:
    template<typename U, 
             typename = std::enable_if_t<std::is_convertible_v<U, T>>>
    explicit SmartHandle(U&& u) : handle(std::forward<U>(u)) {}
};

8. 常见问题与解答

8.1 explicit是否影响拷贝/移动构造函数？

通常不需要对拷贝/移动构造函数使用explicit，因为它们本来就是用于相同类型对象的构造/移动。

8.2 explicit能否用于转换函数模板？

可以，从C++11开始，转换函数模板也可以使用explicit：

class MyType {
public:
    template<typename T>
    explicit operator T() const;
};

8.3 explicit能否用于运算符重载？

不能直接用于运算符重载，但可以用于运算符重载中使用的构造函数或转换函数。

9. 总结

explicit关键字是C++类型系统中重要的安全机制，它通过禁止不期望的隐式转换，使代码更加清晰和安全。在现代C++编程中，合理使用explicit可以：

防止意外的类型转换
提高代码的可读性
减少潜在的运行时错误
明确表达设计意图

掌握explicit的正确用法，是成为高级C++程序员的重要一步。建议在大多数构造函数中使用explicit，只有在明确需要隐式转换时才省略它。

10. 进一步阅读

《Effective C++》条款24：了解explicit的作用
《C++ Primer》关于类型转换的章节
C++标准文档中的[class.conv.ctor]和[class.conv.fct]部分
C++ Core Guidelines: C.46, C.164

”`