Average Rating: 4.3/5 | Rate this item | 46 users have rated this item.

Expertise: Beginner
Language: C++

May 6, 1998

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

	}