C++构造函数中explicit详解

本文主要是介绍C++构造函数中explicit详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《C++构造函数中explicit详解》explicit关键字用于修饰单参数构造函数或可以看作单参数的构造函数,阻止编译器进行隐式类型转换或拷贝初始化,本文就来介绍explicit的使用,感兴趣的可以...

1. 什么是explicit

在 C++ 中，explicit 关键字用于修饰 单参数构造函数 或 可以看作单参数的构造函数，阻止编译器进行 隐式类型转换 或 拷贝初始化。

默认情况下，单参数构造函数既可以显式调用，也可以被编译器用来进行隐式类型转换。
explicit 告诉编译器：这个构造函数只能显式调用，不能用于隐式转换。

2. 隐式转换的问题

来看一个例子：

#include <IOStream>
using namespace std;

class Fraction {
private:
    int numerator;
    int denominator;

public:
    Fraction(int num, int den = 1) : numerator(num), denominator(den) {}
    void print() const {
        cout << numerator << "/" << denominator << endl;
    }
};

int main() {
    Fraction f1 = 5;  // 隐式调用 Fraction(5, 1)
    f1.print();       // 输出：5/1
}

在上面的例子中：

Fraction f1 = 5; 本质上是调用 China编程Fraction(5, 1)，因为编译器允许用 int 隐式转换成 Fraction。
虽然看似方便，但有时会带来 不可控的隐式转换，导致逻辑错误或二义性。

3.explicit的使用示例

基本用法

如果我们在构造函数前加上 explicit：

class Fraction {
private:
    int numerator;
    int denominator;

public:
    explicit Fraction(int num, int den = 1) : numerator(num), denominator(den) {}
    vo编程id print() const {
        cout << numerator << "/" << denominator << endl;
    }
};

int main() {
    Fraction f1(5);     // ✅ 显式调用，可以
    // Fraction f2 = 5; // ❌ 编译错误，不能隐式转换
}

Fraction f1(5); 依然可以显式调用。
但 Fraction f2 = 5; 会报错，因为 explicit 禁止了隐式转换。

多参数构造函数

有时构造函数有多个参数，但如果除第一个外的参数都有默认值，它依然算作 单参数构造函数，也可能引发隐式转换。

class Fraction {
public:
    explicit Fraction(int num, int den = 1) { /* ... */ }
};

这里如果没有 explicit，表达式 Fraction f = 5; 依然会成立。

4. C++11 之后的扩展

(1)explicit用于转换运算符

在 C++11 之前，类的类型转换函数（比如 operator bool）会允许隐式转换：

class Test {
public:
    operator bool() const { return true; }
};

int main() {
    Test t;
    if (t) {  // 隐式调用 operator bool()
        cout << "True" << endl;
    }
}

但有时我们并不希望这种隐式转换。C++javascript11 允许写成：

class Test {
public:
    explicit operator bool() const { return true; }
};

int main() {
    Test t;
    // if (t) { } // ❌ 错误，不能隐式转换
    if (static_cast<bool>(t)) {  // ✅ 必须显式转换
        cout << "True" << endl;
    }
}

(2) C++20 的explicihttp://www.chinasem.cnt(bool)

C++20 引入了更灵活的语法：explicit(bool)。
这让我们可以根据编译期常量决定是否允许隐式调用。

struct A {
    androidexplicit(true) A(int) {}   // 永远显式
    explicit(false) A(double) {} // 永远允许隐式
};

这种写法在模板编程中很有用。

5. 最佳实践

几乎总是给单参数构造函数加 explicit
这样可以避免隐式转换带来的混乱，除非你确实需要这种转换。
转换运算符应当尽量显式
尤其是 operator bool，因为隐式转换到 bool 可能导致奇怪的条件判断。
允许隐式转换的场景
如果你的类本质上就是包装某个类型（比如 string_view 可以从 const char* 隐式转换），那么允许隐式转换可以让使用更加自然。