带多个参数的显式构造函数

Explicit constructor taking multiple arguments

构造具有多个参数的构造函数explicit有任何(有用的)效果吗?

示例:

class A {
    public:
        explicit A( int b, int c ); // does explicit have any (useful) effect?
};

你会偶然发现它用于大括号初始化(例如在数组中)

struct A {
        explicit A( int b, int c ) {}
};

struct B {
         B( int b, int c ) {}
};

int main() {
    B b[] = {{1,2}, {3,5}}; // OK

    A a1[] = {A{1,2}, A{3,4}}; // OK

    A a2[] = {{1,2}, {3,4}}; // Error

    return 0;
}

直到 C++11,是的,没有理由在多参数构造函数上使用 explicit

由于初始化列表,C++11 中发生了变化。基本上,使用初始化列表的复制初始化(但不是直接初始化)要求构造函数不被标记为 explicit.

示例:

struct Foo { Foo(int, int); };
struct Bar { explicit Bar(int, int); };

Foo f1(1, 1); // ok
Foo f2 {1, 1}; // ok
Foo f3 = {1, 1}; // ok

Bar b1(1, 1); // ok
Bar b2 {1, 1}; // ok
Bar b3 = {1, 1}; // NOT OKAY

@StoryTeller 和@Sneftel 的出色回答是主要原因。但是,恕我直言,这是有道理的(至少我这样做了),作为以后对代码进行更改的验证的一部分。考虑你的例子:

class A {
    public:
        explicit A( int b, int c ); 
};

此代码不直接受益于 explicit

一段时间后,您决定为 c 添加默认值,因此它变成了:

class A {
    public:
        A( int b, int c=0 ); 
};

执行此操作时,您关注的是 c 参数 - 回想起来,它应该有一个默认值。您不一定要关注 A 本身是否应该隐式构造。不幸的是,此更改使 explicit 再次相关。

因此,为了传达 ctor 是 explicit,在第一次编写方法时这样做可能是值得的。

这是我对这次讨论的五分钱:

struct Foo {
    Foo(int, double) {}
};

struct Bar {
    explicit Bar(int, double) {}
};

void foo(const Foo&) {}
void bar(const Bar&) {}

int main(int argc, char * argv[]) {
    foo({ 42, 42.42 }); // valid
    bar({ 42, 42.42 }); // invalid
    return 0;
}

如您所见,explicit 阻止将初始化列表与 bar 函数一起使用,因为 struct Bar 的构造函数被声明为 explicit.