显式关键字在C++中意味着什么?


当前回答

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

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

另一方面,如果您有一个缓冲类,其构造函数buffer(int size)以字节为单位表示缓冲区的大小,那么您可能不希望编译器悄悄地将int转换为Buffers。为了防止这种情况,可以使用显式关键字声明构造函数:

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

这样,

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

成为编译时错误。如果要传递临时缓冲区对象,必须显式执行以下操作:

useBuffer(Buffer(4));

总之,如果单参数构造函数将参数转换为类的对象,则可能不希望使用显式关键字。但是,如果您有一个构造函数恰好接受一个参数,那么应该将其声明为显式的,以防止编译器意外地进行转换。

其他回答

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
}

使单参数构造函数(包括具有arg2、arg3、…的默认值的构造函数)如前所述始终是一种良好的编码实践。就像C++一样:如果你不这样做,你会希望你这样做。。。

类的另一个好做法是将副本构造和赋值设为私有(也就是禁用它),除非你真的需要实现它。这避免了在使用C++默认为你创建的方法时,指针的最终副本。另一种方法是从boost::noncopyable派生。

构造函数附加隐式转换。若要抑制此隐式转换,需要使用显式参数声明构造函数。

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

P.S.当使用USER定义的转换(通过构造函数和类型转换运算符)时,只允许使用一级隐式转换。但您可以将这种转换与其他语言转换结合起来

向上整数列(char到int,float到double);标准转换(int到double);将对象指针转换为基类和void*;

显式关键字将构造函数转换为非转换构造函数。因此,代码不太容易出错。

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

下面是一个带有构造函数的示例类,可以用于隐式转换:

class Foo
{
private:
  int m_foo;

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

  int GetFoo () { return m_foo; }
};

下面是一个接受Foo对象的简单函数:

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

这里是DoBar函数的调用位置:

int main ()
{
  DoBar (42);
}

该参数不是一个Foo对象,而是一个int。但是,Foo有一个构造函数,它接受一个int,因此可以使用该构造函数将参数转换为正确的类型。

编译器允许对每个参数执行一次此操作。

在构造函数前面加上显式关键字可以防止编译器将该构造函数用于隐式转换。将其添加到上述类将在函数调用DoBar(42)时产生编译器错误。现在需要使用DoBar显式调用转换(Foo(42))

您可能希望这样做的原因是为了避免可能隐藏错误的意外构造。有争议的例子:

您有一个MyString类,该类具有构造给定大小字符串的构造函数。您有一个函数print(const MyString&)(以及一个重载print(char*string)),并调用print(3)(当您实际想要调用print(“3”)时)。您希望它打印“3”,但它打印长度为3的空字符串。