Quando un costruttore viene specificato come explicit non può essere fatta alcuna conversione automatica su quel costruttore, tuttavia i parametri passati al costruttore possono essere convertiti. Esempio:

class Foo {
 
    friend int bar( const Foo& );
 
    public:
    explicit Foo( int a )
       :var ( a )
    {}
 
    private:
    const int var;
};
 
int bar( const Foo& oggetto )
{
    return oggetto.var;
}
 
int main()
{
 
    bar( 1 );  // errore. Non è corretto. La key word prevede la conversione in modo esplicito e non in modo implicito, come in questo caso!
 
    bar( Foo( 1 ) );  // ok. Conversione esplicita
 
    bar( static_cast< Foo >( 1 ) );  // ok. Questo esempio produce lo stesso effetto dell'esempio precedente: conversione esplicita
 
    bar( Foo( 1.2 ) );  // ok. Questo esempio è legale. Nonostante sia corretto, il valore passato è di tipo float. Il costruttore accetta oggetti
                       //  interi, per questo che viene troncato, ottenendo un valore pari ad 1
    return 0;
}