显式关键字是什么意思？

时间：2008-09-23 13:58:46

标签： c++ constructor explicit c++-faq explicit-constructor

explicit关键字在C ++中的含义是什么？

11 个答案:

答案 0 :(得分：3011)

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

这是一个带有构造函数的示例类，可用于隐式转换：

class Foo
{
public:
  // single parameter constructor, can be used as an implicit conversion
  Foo (int foo) : m_foo (foo) 
  {
  }

  int GetFoo () { return m_foo; }

private:
  int m_foo;
};

这是一个采用Foo对象的简单函数：

void DoBar (Foo foo)
{
  int i = foo.GetFoo ();
}

这里是调用DoBar函数的地方。

int main ()
{
  DoBar (42);
}

参数不是Foo对象，而是int。但是，Foo存在一个带int的构造函数，因此可以使用此构造函数将参数转换为正确的类型。

允许编译器为每个参数执行一次。

将explicit关键字前缀到构造函数会阻止编译器将该构造函数用于隐式转换。将其添加到上面的类将在函数调用DoBar (42)处创建编译器错误。现在需要使用DoBar (Foo (42))

明确要求转换

您可能希望这样做的原因是为了避免可以隐藏错误的意外构造。举例：

  • 您有一个MyString(int size)类，其构造函数构造给定大小的字符串。您有一个功能print(const MyString&)，并且您致电print(3)（当实际上打算致电print("3")时）。你希望它打印“3”，但它会打印一个长度为3的空字符串。

答案 1 :(得分：1043)

假设您有一个班级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，然后将调用String(int)构造函数。但是，这不是用户可能想要的。因此，为了防止这种情况，我们将构造函数定义为explicit：

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

答案 2 :(得分：145)

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

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

另一方面，如果你有一个缓冲类，其构造函数Buffer(int size)以字节为单位取缓冲区的大小，你可能不希望编译器悄悄地将int转换为{{ 1}}秒。为防止这种情况，请使用Buffer关键字声明构造函数：

explicit

那样，

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

成为编译时错误。如果要传递临时void useBuffer(Buffer& buf); useBuffer(4); 对象，则必须明确地执行此操作：

Buffer

总之，如果您的单参数构造函数将参数转换为类的对象，您可能不希望使用useBuffer(Buffer(4)); 关键字。但是如果你有一个只需要一个参数的构造函数，你应该将它声明为explicit，以防止编译器因意外的转换而让你感到惊讶。

答案 3 :(得分：39)

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

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

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;生成编译器错误。

将单参数构造函数声明为explicit通常通常是良好做法，除非您的实现明确禁止它。

还要注意带

的构造函数
  • 所有参数的默认参数，或
  • 第二个参数的默认参数

都可以用作单参数构造函数。所以你可能也想要explicit。

一个例子，当你故意 不 想让你的单参数构造函数显式时，如果你正在创建一个仿函数（请查看声明的'add_x'结构在this回答）。在这种情况下，将对象创建为add_x add30 = 30;可能是有意义的。

Here是对显式构造函数的一个很好的写作。

答案 4 :(得分：37)

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

答案 5 :(得分：36)

关键字explicit伴随着

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

C ++ [class.conv.ctor]

     

1）在没有函数说明符explicit的情况下声明的构造函数指定从其参数类型到其类类型的转换。这样的构造函数称为转换构造函数。

     

2）显式构造函数与非显式构造函数一样构造对象，但仅在显式使用直接初始化语法（8.5）或强制转换（5.2.9,5.4）的情况下才这样做。默认构造函数可以是显式构造函数;这样的构造函数将用于执行默认初始化或valueinitialization   （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和非explicit转换之间的区别。

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

为什么要使用explicit转换函数或构造函数？

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

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

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

struct U { U(V) { } };

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

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

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

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

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

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

考虑打印一些矢量的函数：

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

如果向量的size-constructor不是显式的，则可以像这样调用函数：

print_intvector(3);

对这样的电话会有什么期望？一行包含3或三行包含0？ （第二个是发生的事情。）

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

正如Bjarne Stroustrup所说（关于C ++编程语言＆＃34;第4版，35.2.1，第1011页）关于为什么std::duration不能从平面隐式构造的问题号：

  

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

答案 6 :(得分：26)

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

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

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

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

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

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

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

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

答案 7 :(得分：26)

显式转换构造函数（仅限C ++）

  

显式函数说明符控制不需要的隐式类型   转换。它只能用于构造函数的声明   在一个类声明中。例如，默认值除外   构造函数，以下类中的构造函数是转换   构造

$t = 'wap long text[dv]netlong text';
$t_new = explode('[dv]',$t);
echo $t_new[0].'<br>'.$t_new[1];

以下声明是合法的：

class A
{
public:
    A();
    A(int);
    A(const char*, int = 0);
};

第一个声明相当于A c = 1; A d = "Venditti"; 。

如果将类的构造函数声明为A c = A( 1 );，则先前的声明将是非法的。

例如，如果您将类声明为：

explicit

您只能指定与类类型值匹配的值。

例如，以下陈述是合法的：

class A
{
public:
    explicit A();
    explicit A(int);
    explicit A(const char*, int = 0);
};

答案 8 :(得分：18)

已经讨论过这个问题（what is explicit constructor）。但我必须说，它缺乏这里的详细描述。

此外，如上所述，使用一个参数构造函数（包括那些具有arg2，arg3，...的默认值的构造函数）总是一个很好的编码实践。 和C ++一样：如果你不这样做 - 你会希望你做到......

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

答案 9 :(得分：18)

Cpp参考总是很有用!!!可以找到有关显式说明符的详细信息here。您可能还需要查看implicit conversions和copy-initialization。

快速浏览

  

显式说明符指定构造函数或转换函数（自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
}

答案 10 :(得分：5)

构造函数附加隐式转换。要禁止此隐式转换，需要使用显式参数声明构造函数。

在C ++ 11中，您还可以指定＆＃34;运算符类型（）＆＃34;使用此类关键字http://en.cppreference.com/w/cpp/language/explicit使用此类规范，您可以在显式转换和对象的直接初始化方面使用运算符。

P.S。当使用BY USER定义的转换（通过构造函数和类型转换运算符）时，只允许使用一级隐式转换。 但您可以将此转化与其他语言转换相结合

  • up integral rank（char to int，float to double）;
  • 标准转换（int to double）;
  • 将对象的指针转换为基类并转换为void *;
相关问题
最新问题