Login | Register   
RSS Feed
Download our iPhone app
Browse DevX
Sign up for e-mail newsletters from DevX

Tip of the Day
Language: C++
Expertise: Beginner
May 6, 1998



Application Security Testing: An Integral Part of DevOps

The Explicit Keyword

A constructor taking a single argument is by default an implicit conversion operator:
	class C {
		int I;
		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;
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;
		//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

Danny Kalev
Comment and Contribute






(Maximum characters: 1200). You have 1200 characters left.



Thanks for your registration, follow us on our social networks to keep up-to-date