显式关键字是什么意思？

Question

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

Answer 1

其他答案遗漏了我要在这里提到的一个重要因素。

与“delete”关键字一起，“explicit”允许您控制编译器生成特殊成员函数的方式 - 默认构造函数、复制构造函数、复制赋值运算符、析构函数、移动构造函数和移动赋值。

请参阅 https://learn.microsoft.com /en-us/cpp/cpp/explicitly-defaulted-and-deleted-functions

Answer 2

允许编译器进行一次隐式转换来解析函数的参数。 这意味着编译器可以使用可通过单个参数调用的构造函数从一种类型转换为另一种类型，以获得参数的正确类型。

下面是一个转换构造函数的示例，展示了其工作原理：

struct Foo {
    // Single parameter constructor, can be used as an implicit conversion.
    // Such a constructor is called "converting constructor".
    Foo(int x) {}
};
struct Faz {
    // Also a converting constructor.
    Faz(Foo foo) {}
};

// The parameter is of type Foo, not of type int, so it looks like
// we have to pass a Foo.
void bar(Foo foo) {};

int main() {
    // However, the converting constructor allows us to pass an int.
    bar(42);
    // Also allowed thanks to the converting constructor.
    Foo foo = 42;
    // Error! This would require two conversions (int -> Foo -> Faz).
    Faz faz = 42;
}

在构造函数中添加 explicit 关键字可防止编译器使用该构造函数进行隐式转换。 将其添加到上面的类中将在函数调用 bar(42) 处产生编译器错误。 现在需要使用 bar(Foo(42)) 显式调用转换。

您可能想要这样做的原因是为了避免可能隐藏错误的意外构造。
人为示例：

• 您有一个 MyString 类，其构造函数可以构造给定大小的字符串。 您有一个函数 print(const MyString&) （以及重载 print (char *string)），并且调用 print(3) code> （当您实际上打算调用print("3")时）。 您希望它打印“3”，但它却打印出长度为 3 的空字符串。

Answer 3

假设您有一个类 String：

class String {
public:
    String(int n); // allocate n bytes to the String object
    String(const char *p); // initializes object with char *p
};

现在，如果您尝试：

String mystring = 'x';

字符 'x' 将隐式转换为 int，然后 < code>String(int) 构造函数将被调用。 但是，这可能不是用户想要的。 因此，为了防止出现这种情况，我们将构造函数定义为显式：

class String {
public:
    explicit String (int n); //allocate n bytes
    String(const char *p); // initialize sobject with string p
};

Answer 4

关键字 explicit 伴随

• 类 X 的构造函数，该构造函数不能用于将第一个（任何唯一）参数隐式转换为类型 X

C++ [class.conv.ctor]

1) 未使用函数说明符显式声明的构造函数指定从其参数类型到其类类型的转换。 这样的构造函数称为转换构造函数。

2) 显式构造函数构造对象就像非显式构造函数一样，但仅在显式使用直接初始化语法 (8.5) 或强制转换 (5.2.9, 5.4) 时才这样做。 默认构造函数可以是显式构造函数； 这样的构造函数将用于执行默认初始化或值初始化
（8.5）。

• 或仅考虑直接初始化和显式转换的转换函数。

C++ [class.conv.fct]

2) 转换函数可以是显式的 (7.1.2)，在这种情况下，它仅被视为用于直接初始化 (8.5) 的用户定义转换。 否则，用户定义的转换不限于在赋值中使用
和初始化。

概述

显式转换函数和构造函数只能用于显式转换（直接初始化或显式强制转换操作），而非显式构造函数和转换函数可用于隐式和显式转换。

/*
                                 explicit conversion          implicit conversion

 explicit constructor                    yes                          no

 constructor                             yes                          yes

 explicit conversion function            yes                          no

 conversion function                     yes                          yes

*/

使用结构体 X, Y, Z 和函数 foo, bar, baz 的示例：

让我们看一下结构体和函数的一个小设置，看看 explicit< 之间的区别/code> 和非显式转换。

struct Z { };

struct X { 
  explicit X(int a); // X can be constructed from int explicitly
  explicit operator Z (); // X can be converted to Z explicitly
};

struct Y{
  Y(int a); // int can be implicitly converted to Y
  operator Z (); // Y can be implicitly converted to Z
};

void foo(X x) { }
void bar(Y y) { }
void baz(Z z) { }

有关构造函数的示例：

函数参数的转换：

foo(2);                     // error: no implicit conversion int to X possible
foo(X(2));                  // OK: direct initialization: explicit conversion
foo(static_cast<X>(2));     // OK: explicit conversion

bar(2);                     // OK: implicit conversion via Y(int) 
bar(Y(2));                  // OK: direct initialization
bar(static_cast<Y>(2));     // OK: explicit conversion

对象初始化：

X x2 = 2;                   // error: no implicit conversion int to X possible
X x3(2);                    // OK: direct initialization
X x4 = X(2);                // OK: direct initialization
X x5 = static_cast<X>(2);   // OK: explicit conversion 

Y y2 = 2;                   // OK: implicit conversion via Y(int)
Y y3(2);                    // OK: direct initialization
Y y4 = Y(2);                // OK: direct initialization
Y y5 = static_cast<Y>(2);   // OK: explicit conversion

有关转换函数的示例：

X x1{ 0 };
Y y1{ 0 };

函数参数的转换：

baz(x1);                    // error: X not implicitly convertible to Z
baz(Z(x1));                 // OK: explicit initialization
baz(static_cast<Z>(x1));    // OK: explicit conversion

baz(y1);                    // OK: implicit conversion via Y::operator Z()
baz(Z(y1));                 // OK: direct initialization
baz(static_cast<Z>(y1));    // OK: explicit conversion

对象初始化：

Z z1 = x1;                  // error: X not implicitly convertible to Z
Z z2(x1);                   // OK: explicit initialization
Z z3 = Z(x1);               // OK: explicit initialization
Z z4 = static_cast<Z>(x1);  // OK: explicit conversion

Z z1 = y1;                  // OK: implicit conversion via Y::operator Z()
Z z2(y1);                   // OK: direct initialization
Z z3 = Z(y1);               // OK: direct initialization
Z z4 = static_cast<Z>(y1);  // OK: explicit conversion

为什么使用显式转换函数或构造函数？

转换构造函数和非显式转换函数可能会引入歧义。

考虑一个结构体V，可转换为int，一个结构体U 可从 V 和分别为 U 和 bool 重载的函数 f 隐式构造。

struct V {
  operator bool() const { return true; }
};

struct U { U(V) { } };

void f(U) { }
void f(bool) {  }

如果传递 V 类型的对象，则对 f 的调用是不明确的。

V x;
f(x);  // error: call of overloaded 'f(V&)' is ambiguous

编译器不知道是使用U的构造函数还是转换函数将V对象转换为类型以传递给f。

如果 U 的构造函数或 V 的转换函数是显式，则不会有歧义，因为只有非显式转换才会发生予以考虑。 如果两者都是显式的，则必须使用显式转换或强制转换操作来使用 V 类型的对象调用 f。

转换构造函数和非显式转换函数可能会导致意外行为。

考虑一个打印某些向量的函数：

void print_intvector(std::vector<int> const &v) { for (int x : v) std::cout << x << '\n'; }

如果向量的大小构造函数不是显式的，则可以像这样调用该函数：

print_intvector(3);

人们对这样的电话会期待什么？ 一行包含 3 还是三行包含 0？ （第二个就是发生的情况。）

在类接口中使用显式关键字会强制接口的用户明确所需的转换。

正如 Bjarne Stroustrup 所说（在《C++ 编程语言》，第 4 版，35.2.1，第 1011 页）关于为什么 std::duration 不能从普通数字隐式构造的问题：

如果您知道自己的意思，请明确说明。

Answer 5

在 C++ 中，只有一个必需参数的构造函数被视为隐式转换函数。 它将参数类型转换为类类型。 这是否是一件好事取决于构造函数的语义。

例如，如果您有一个带有构造函数 String(const char* s) 的字符串类，那么这可能正是您想要的。 您可以将 const char* 传递给需要 String 的函数，编译器将自动为您构造一个临时 String 对象。

另一方面，如果您有一个缓冲区类，其构造函数 Buffer(int size) 接受缓冲区大小（以字节为单位），您可能不希望编译器悄悄地将 int< /code>s 到 Buffers 中。 为了防止这种情况，您可以使用 explicit 关键字声明构造函数：

class Buffer { explicit Buffer(int size); ... }

这样，

void useBuffer(Buffer& buf);
useBuffer(4);

就会出现编译时错误。 如果你想传递一个临时的 Buffer 对象，你必须明确地这样做：

useBuffer(Buffer(4));

总之，如果你的单参数构造函数将参数转换为你的类的对象，你可能不希望使用explicit关键字。 但是，如果您的构造函数恰好采用单个参数，则应该将其声明为显式，以防止编译器因意外转换而让您感到意外。

Answer 6

这个答案是关于使用/不使用显式构造函数的对象创建，因为其他答案中没有涵盖它。

考虑以下没有显式构造函数的类：

class Foo
{
public:
    Foo(int x) : m_x(x)
    {
    }

private:
    int m_x;
};

可以通过两种方式创建 Foo 类的对象：

Foo bar1(10);

Foo bar2 = 20;

根据实现的不同，实例化 Foo 类的第二种方式可能会令人困惑，或者不是程序员想要的。 在构造函数前添加 explicit 关键字会在 Foo bar2 = 20; 处生成编译器错误。

将单参数构造函数声明为显式通常是一种很好的做法，除非您的实现明确禁止这样做。

另请注意，

• 所有参数都具有默认参数的构造函数或
• 第二个参数及之后的默认参数

的构造函数都可以用作单参数构造函数。 因此，您可能想让这些也变得显式。

您故意不想要使单参数构造函数显式的一个例子是，如果您正在创建一个仿函数（查看 这个答案）。 在这种情况下，创建一个对象为 add_x add30 = 30; 可能是有意义的。

这里是关于显式的很好的文章构造函数。

Answer 7

explicit 关键字可用于强制显式调用构造函数。

class C {
public:
    explicit C() =default;
};

int main() {
    C c;
    return 0;
}

构造函数 C() 前面的 explicit 关键字告诉编译器只允许显式调用此构造函数。

explicit - 关键字也可以用在用户定义的类型转换运算符中：

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

int main() {
    C c;
    bool b = static_cast<bool>(c);
    return 0;
}

这里， explicit - 关键字强制只有显式转换才有效，因此 bool b =在这种情况下，c; 将是无效的转换。 在这些情况下，explicit 关键字可以帮助程序员避免隐式的、意外的强制转换。 此用法已在 C++11 中标准化。

Answer 8

explicit 关键字将转换构造函数转换为非转换构造函数。 因此，代码不易出错。

Answer 9

Cpp 参考总是有帮助的！ 有关显式说明符的详细信息可以在此处找到。 您可能需要查看隐式转换和复制初始化 也是如此。

快速查看

显式说明符指定构造函数或转换函数（自 C++11 起）不允许隐式转换或复制初始化。

示例如下：

struct A
{
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (C++11)
    operator bool() const { return true; }
};

struct B
{
    explicit B(int) { }
    explicit B(int, int) { }
    explicit operator bool() const { return true; }
};

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3 {4, 5};   // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast
    if (a1) cout << "true" << endl; // OK: A::operator bool()
    bool na1 = a1; // OK: copy-initialization selects A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization

//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3 {4, 5};   // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization does not consider B::B(int,int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast
    if (b5) cout << "true" << endl; // OK: B::operator bool()
//  bool nb1 = b2; // error: copy-initialization does not consider B::operator bool()
    bool nb2 = static_cast<bool>(b2); // OK: static_cast performs direct-initialization
}

Answer 10

如前所述，创建单参数构造函数（包括具有 arg2、arg3...默认值的构造函数）始终是一种良好的编码实践。
与 C++ 一样：如果你不这样做 - 你会希望你这样做...

类的另一个好习惯是使复制构造和赋值私有（也称为禁用它），除非你确实需要实现它。 这可以避免在使用 C++ 默认为您创建的方法时最终产生指针副本。 另一种方法是从 boost::noncopyable 派生。

Answer 11

构造函数附加隐式转换。 要抑制这种隐式转换，需要显式声明带有参数的构造函数。

在 C++11 中，您还可以使用关键字 http 指定“operator type()”： //en.cppreference.com/w/cpp/language/explicit 通过这样的规范，您可以在显式转换和对象的直接初始化方面使用运算符。

PS 当使用由用户定义的转换（通过构造函数和类型转换运算符）时，只允许使用一级隐式转换。
但是您可以将此转换与其他语言转换结合起来，

• 提高整数级别（char 到 int、float 到 double）；
• 标准转换（int 到 double）；
• 将对象指针转换为基类和 void*；