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
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
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
Up until C++11, yeah, no reason to use explicit on a multi-arg constructor. That changes in C++11, because of initializer lists. Basically, copy-initialization (but not direct initialization) with an initializer list requires that the constructor not be marked explicit. Example: struct Foo { Foo(int, int); }; struct Bar { explicit Bar(int, int); }; Foo f1(1, … Read more
This is an error message you see whenever you have a situation like the following: char* pointer_to_nonconst = “string literal”; Why? Well, C and C++ differ in the type of the string literal. In C the type is array of char and in C++ it is constant array of char. In any case, you are … Read more
The compiler is allowed to make one implicit conversion to resolve the parameters to a function. What this means is that the compiler can use constructors callable with a single parameter to convert from one type to another in order to get the right type for a parameter. Here’s an example class with a constructor … Read more