I am newbie in C++ 11. I found this term of explicit constructor. However I did not find any good explanation on explicit constructor. Can you please explain in what scenario I should use explicit constructor?
Thank you in advance.
2 Answers
A non-explicit one-argument constructor could be called a conversion constructor. That's because they allow the compiler to implicitly convert from another type (the type of the argument) to the object.
This implicit conversion is not always wanted, and can be disabled by marking the constructor explicit.
answered Apr 3, 2018 at 8:01
Some programmer dude
411k36 gold badges420 silver badges655 bronze badges
5 Comments
curiousguy
In retrospect, that implicit conversation would better be asked for explicitly with an "implicit" keyword.
Kadiam
So does that mean that the keyword "explicit" is used only for single argument constructors?
Some programmer dude
@Kadiam Yes, if a constructor has more than one arguments (without default values) then it can't be used as a conversion constructor.
Kadiam
@Someprogrammerdude your reply caused me to ask another question :) As you just mentioned, if a constructor with multiple arguments has default values for every argument except for one, then such constructor can be used as a conversion constructor. In that case, we can use the explicit keyword to prevent it happening. Am I right?
Some programmer dude
@Kadiam All correct. :)
An explicit constructor is a function that does not get called in implicit type conversion.
For example:
class A {
A( int a ) {}
};
void foo( A a ) {}
Here is totally legal to call foo(1) or use any variable of type int or that can be implicitly converted to an int. This is not always desirable, as it would mean that A is convertible from an integer, instead of being defined with an integer. Adding the explicit would avoid the conversion and, hence, give you a compilation error.
explicitconstructor prevents that constructor on being used for implicit type conversions.explicitcopy constructor (including move constructor). Typically, it's converting constructors (i.e. ones that accept an argument of different type) where the implicit/explicit distinction is important.