explicit-constructor

int value = 5; // this type of assignment is called an explicit assignment int value(5); // this type of assignment is called an implicit assignment What is the difference between those, if any, and in what cases do explicit and implicit assignment differ and how? http://weblogs.asp.net/kennykerr/archive/2004/08/31/Explicit-Constructors.aspx EDIT: I actually just found this article, which makes the whole thing a lot clearer... and it brings up another question, should you ( in general ) mark constructors taking a single parameter of a primitive type - numeric/bool/string - as explicit and

I recently noticed a class in C++0x that calls for an explicit default constructor. However, I'm failing to come up with a scenario in which a default constructor can be called implicitly. It seems like a rather pointless specifier. I thought maybe it would disallow Class c; in favor of Class c = Class(); but that does not appear to be the case. Some relevant quotes from the C++0x FCD, since it is easier for me to navigate [similar text exists in C++03, if not in the same places] 12.3.1.3 [class.conv.ctor] A default constructor may be an explicit constructor; such a constructor will be used to

Is it simply preference or are there specific instances where one is necessary over another? I'm refering to the following variants for initialization T t(e); // direct initialization T t = e; // copy initialization The actual names of the things you describe is not implicit and explicit assignment but : Copy-initialization : T x = a; Direct-initialization : T x(a); They are not equivalent, most notably in contexts where a conversion is required, for example when T is of class type and a is of a different type (see Alf comment for examples of contexts which don't even involve conversion).

In the C++ standard, §13.3.1.7 [over.match.list], the following is stated: In copy-list-initialization, if an explicit constructor is chosen, the initialization is ill-formed. This is the reason why we can't do, for example, something like this: struct foo { // explicit because it can be called with one argument explicit foo(std::string s, int x = 0); private: // ... }; void f(foo x); f({ "answer", 42 }); (Note that what happens here is not a conversion , and it would not be one even if the constructor was "implicit". This is initialization of a foo object using its constructor directly. Other