explicit

Cuando un constructor en una clase es declarado como explicit, ese constructor no participa de las conversiones implícitas (automáticas) -- pero sus argumentos aún pueden ser convertidos.

Ejemplo:

    struct foo {
      explicit foo( int a )
        : a_( a )
      { }
      '' a_ es público
      int a_;
    };
 
    '' la siguiente función toma como argumento un foo
    int bar( const foo & f ) {
      return f.a_;
    }
 
    bar( 1 );  '' error de compilación: 
               '' no se puede convertir implícitamente de "int" a "foo".
 
    bar( foo( 1 ) );  '' funciona: se ha realizado la conversión explícitamente.
 
    bar( static_cast<foo>( 1 ) );  '' funciona: se puede llamar al constructor explícito.
 
    bar( foo( 1.0 ) );  '' funciona: el argumento de tipo "double" se puede convertir a "int"
                        '' el cual se pasa como argumento en la construcción explícita

El uso de explicit permite evitar que el compilador haga conversiones "silenciosas", difíciles de detectar, al usar clases en expresiones que involucran a valores o tipos de datos incorporados en el compilador.

C++11

En C++11, la palabra clave explicit será acoplable también a los operadores de conversión, de modo de evitar conversiones implícitas inversas:

    struct foo {
      explicit foo( int a )
        : a_( a )
      { }
      explicit operator double () const {
        return (double)a_;
        }
      '' a_ es público
      int a_;
    };
 
    '' la siguiente función toma como argumento un foo y retorna un double
    double bar( const foo & f ) {
      return f;  '' error de compilación:
                 '' no se puede convertir implícitamente de "foo" a "double".
      return (double)f;  '' funciona: se puede convertir explícitamente.
 
    }

Tópicos Relacionados: static_cast.