In C++11 multi-parameter constructors can be implicitly converted to with brace initialization. However, before C++11 explicit only applied to single-argument constructors. For multiple-argument constructors, it was ignored and had no effect.
The traditional wisdom is that constructors taking one parameter (explicitly or effectively through the use of default parameters) should be marked explicit, unless they do define a conversion (std::string being convertible from const char* being one example of the latter). You’ve figured out the reasons yourself, in that implicit conversions can indeed make life harder … Read more
An explicit move constructors can affect compatibility with e.g. Standard algorithms. For instance, std::swap<T> requires that T be MoveConstructible. In turn, MoveConstructible is specified in terms of an expression, namely T u = rv; (where rv is an rvalue of type T). If there is neither a non-explicit copy constructor nor a non-explicit move constructor … Read more
The terms default and implicit, when talking about a constructor have the following meaning: default constructor is a constructor that can be called with no arguments. It either takes no arguments or has default values for each of the arguments taken. implicit constructor is a term commonly used to talk about two different concepts in … Read more
In C++11 multi-parameter constructors can be implicitly converted to with brace initialization. However, before C++11 explicit only applied to single-argument constructors. For multiple-argument constructors, it was ignored and had no effect.
This declares an explicit default constructor: struct A { explicit A(int a1 = 0); }; A a = 0; /* not allowed */ A b; /* allowed */ A c(0); /* allowed */ In case there is no parameter, like in the following example, the explicit is redundant. struct A { /* explicit is redundant. … Read more
One reason certainly is because it doesn’t hurt. One reason where it’s needed is, if you have default arguments for the first parameter. The constructor becomes a default constructor, but can still be used as converting constructor struct A { explicit A(int = 0); // added it to a default constructor }; C++0x makes actual … Read more
Conceptually copy-list-initialization is the conversion of a compound value to a destination type. The paper that proposed wording and explained rationale already considered the term “copy” in “copy list initialization” unfortunate, since it doesn’t really convey the actual rationale behind it. But it is kept for compatibility with existing wording. A {10, 20} pair/tuple value … Read more
The traditional wisdom is that constructors taking one parameter (explicitly or effectively through the use of default parameters) should be marked explicit, unless they do define a conversion (std::string being convertible from const char* being one example of the latter). You’ve figured out the reasons yourself, in that implicit conversions can indeed make life harder … Read more
This declares an explicit default constructor: struct A { explicit A(int a1 = 0); }; A a = 0; /* not allowed */ A b; /* allowed */ A c(0); /* allowed */ In case there is no parameter, like in the following example, the explicit is redundant. struct A { /* explicit is redundant. … Read more