Explicit constructor taking multiple arguments

Question

Does any (useful) effect have a constructor that has multiple explicit arguments?

Example:

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

Answer 1

As long as C ++ 11, yes, there is no reason to use explicit in the multi-arg constructor.

This changes in C ++ 11 due to initializer lists. Basically, copy initialization (but not direct initialization) using a list of initializers requires that the constructor not be explicit marked.

Example:

 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 

Answer 2

You stumbled upon it to initialize a bracket (e.g. in arrays)

 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; } 

Answer 3

Great answers from @StoryTeller and @Sneftel are the main reason. However, IMHO, this makes sense (at least I do it), as part of a future check later changes the code. Consider your example:

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

This code does not directly use explicit .

After a while, you decide to add the default value for c so that it becomes the following:

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

In doing so, you focus on the c parameter - in retrospect, it should have a default value. You do not necessarily focus on whether A itself should be implicit. Unfortunately, this change is again explicit .

So, in order to report that ctor is explicit , he can pay for it the first time he writes a method.

Answer 4

Here are my five cents for this discussion:

 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; } 

As you can easily see, explicit prevents the use of the initializer list along with the bar function, since the struct Bar constructor is declared as explicit .