Explicit keyword in C++

When a class has just a single parameter constructor, the compiler is allowed to make an implicit conversion to resolve the parameters to a function. It is used to convert from one type to another in order to get the right type for a parameter.

For example, if we have the class Foo that has a single parameter constructor that receives and saves an int foo:

class Foo
{
public:
  Foo (int foo) {m_foo = foo;}
  GetFoo () {return m_foo;}
private:
  int m_foo;
};

And here is a function that takes and prints a Foo object:

void DoBar (Foo foo)
{
  int f = foo.GetFoo();
  cout << "DoBar: " << f << endl;
}

So, if DooBar is called like:

DoBar (12);
DoBar (22.6f);
DoBar ('A');

In each call of “DoBar”, the parameter is not a Foo object. In the first call is an int, the second is a float and the third call is a char. Though, there exists a constructor for Foo that takes an int so that constructor can be used to convert the parameter to the correct type. This example compiles and prints the following result:

DoBar: 12
DoBar: 22
DoBar: 65

Prefixing the explicit keyword to the constructor prevents the compiler from using that constructor for implicit conversions. Adding it to the above class will create a compiler error at the function call DoBar.