c++ 中 explicit 是什么

在 C++ 中，explicit 是用来修饰构造函数的关键字，用于防止隐式类型转换。当构造函数前加上 explicit 关键字时，表示该构造函数只能显式调用，不能被隐式调用。

例如，有一个类 A 和一个接收 A 类对象参数的函数 func：

class A {
public:
    explicit A(int x) : num(x) {}
private:
    int num;
};

void func(A a) {}

int main() {
    A a1 = 10; //编译错误，不能隐式将 int 转换为 A 类型
    A a2(10); //正确
    func(10); //编译错误，不能隐式将 int 转换为 A 类型
    func(A(10)); //正确
    return 0;
}

在上面的例子中，我们使用 explicit 关键字来修饰 A 类的构造函数，这样可以避免在调用构造函数时进行隐式类型转换。如果没有 explicit 关键字，则编译器会自动将 int 类型的值转换为 A 类型的对象。

相关问题

C++中explicit关键字是什么意思

在 C++ 中，`explicit` 是一个关键字，用于修饰类的构造函数。它的作用是防止编译器进行隐式类型转换，强制要求使用显式语法进行构造。

具体来说，如果一个构造函数被声明为 `explicit`，那么它就不能被用于隐式类型转换。例如，假设有一个类 `MyClass`：

class MyClass {
public:
    explicit MyClass(int x) : value(x) {}
private:
    int value;
};

在上面的代码中，构造函数 `MyClass(int x)` 被声明为 `explicit`。这意味着，如果你想创建一个 `MyClass` 对象，你必须使用显式语法进行构造，例如：

MyClass obj1(10); // 正确，使用显式语法
MyClass obj2 = 10; // 错误，不能进行隐式类型转换
MyClass obj3 = MyClass(10); // 正确，使用显式语法

在第二行代码中，编译器会尝试将整数 10 隐式转换为 `MyClass` 类型，但由于构造函数被声明为 `explicit`，所以编译器会报错。而在第四行代码中，我们使用了显式语法进行构造，因此是正确的。

总之，`explicit` 关键字可以帮助我们避免一些隐式类型转换可能带来的问题，增强代码的可读性和安全性。

c++中explicit

在 C 语言中，`explicit` 是一个关键字，用于修饰类的构造函数。通过使用 `explicit` 关键字，可以禁止隐式转换调用构造函数。当一个构造函数被声明为 `explicit` 时，只能通过显式地调用构造函数来创建对象，而不能通过隐式转换。

例如：

#include <stdio.h>

typedef struct {
    int value;
} MyType;

// 非 explicit 构造函数
MyType createMyType(int value) {
    MyType obj;
    obj.value = value;
    return obj;
}

// explicit 构造函数
explicit MyType createMyTypeExplicit(int value) {
    MyType obj;
    obj.value = value;
    return obj;
}

int main() {
    MyType obj1 = createMyType(10);  // 隐式转换调用构造函数
    MyType obj2 = createMyTypeExplicit(20);  // 显式调用构造函数

    printf("obj1: %d\n", obj1.value);
    printf("obj2: %d\n", obj2.value);

    return 0;
}

在上面的示例中，`createMyType` 是一个非 explicit 的构造函数，因此可以通过隐式转换来创建 `MyType` 对象。而 `createMyTypeExplicit` 是一个 explicit 的构造函数，只能通过显式调用来创建对象。