C++ implicit/explicit constructor
The Explicit Keyword
A constructor taking a single argument is by default an implicit conversion operator:
class C {
int I;
//...
public:
C(int i);//constructor and implicit conversion operator
//as well
};

void f() {
C c(0);
c = 5; //implicit conversion of 5 to a C object and
//then assignment
}

The compiler re-edits the above sample as if the programmer had written:
//////////////////////////////////////////////////////////////////////////////////////////
//"c=5;" transformed by the compiler into something like this:
/////////////////////////////////////////////////////////////////////////////////////////
C temp(5);//temporary object instantiated,
c = temp; //assigned using operator =
temp.C::~C(); //temp's destructor activated

In many cases, this conversion is intentional and well-behaved. But there are cases where such automatic conversion is undesirable, like the following:
class String {
int size;
char *p;
//..
public:
String (int sz); //constructor & implicit conversion
//operator; undesirable in this case
};
void f ()
{
String s(10);
//the following is a programmer's typo; yet it is not
//detected since it has an unexpected interpretation:
s = 100; //bad; 100 is converted to a String and then
//assigned to s.
}

In order to avoid such implicit conversions, a constructor taking one argument should be declared as explicit:
class String {
int size;
char *p;
//..
public:
//no implicit conversion
explicit String (int sz); //no implicit conversion
String (const char *s, int size n = 0); //implicit conv.
};
void f ()
{
String s(10);
s = 100; //now compile time error; explicit conversion
//required now:
s = String(100); //fine; explicit conversion
s = "st";//fine; implicit conversion allowed in this case
}

Written by Danny Kalev
http://www.devx.com/tips/Tip/12493
- posted by Pop @ 7:20 PM