Explicit

Chewee wrote:

Salut tout le monde...
Quelqu'un pourrait expliquer de façon simple à quoi sert le mot clé EXPLICIT
placé devant la définition d'un constructeur de classe ?

Ca évite les conversions automatiques. Si tu as un MSDN, regarde dedans.
Bon, un exemple.

struct Toto
{
explicit Toto(int){}
};

void func(Toto);

int main(int argc, char *argv)
{
func(5);
return 0;
}

Sans explicit, l'appel à "func" va créer implicitement un "Toto"
temporaire (avec son constructeur qui prend un "int"). "explicit"
empêche la création automatique de ce "Toto" (donc erreur de compil)

Fabien

Fabien SK wrote:

Chewee wrote:

Salut tout le monde...
Quelqu'un pourrait expliquer de façon simple à quoi sert le mot clé
EXPLICIT placé devant la définition d'un constructeur de classe ?

Ca évite les conversions automatiques. Si tu as un MSDN, regarde
dedans.
Bon, un exemple.

struct Toto
{
explicit Toto(int){}
};

void func(Toto);

int main(int argc, char *argv)
{
func(5);
return 0;
}

Sans explicit, l'appel à "func" va créer implicitement un "Toto"
temporaire (avec son constructeur qui prend un "int"). "explicit"
empêche la création automatique de ce "Toto" (donc erreur de compil)

Fabien

Merci, je vais approfondir parce que j'ai pas tout capté là...

drkm <darkman_spam@yahoo.fr> wrote in message
news:<wkznimkiq7.fsf@yahoo.fr>...

"Chewee" <chewee@NOSPAMchewee.net> writes:

Quelqu'un pourrait expliquer de façon simple à quoi sert le mot clé
EXPLICIT placé devant la définition d'un constructeur de classe ?

À imposer à l'utilisateur d'appeler /explicitement/ le constructeur,
et interdire les conversions implicites.

Je sais que j'ai une tendance à le voir un peu comme toi, mais
techniquement, on ne peut jamais appeler le constructeur, et ce qu'il
faut dans le cas d'explicit, c'est une conversion explicite (et non
implicite).

struct A
{
A( int ) ;
} ;

struct B
{
explicit B( int ) ;
} ;

void f( A ) ;
void g( B ) ;

int main()
{
f( 1 ) ;
g( 2 ) ; // incorrect
}

L'appel à `f()´ va construire un objet temporaire de type `A´, en
appelant le constructeur prenant un entier en paramètre. Par contre,
l'appel à `g()´ n'est pas permis, puisque s'il y a effectivement un
constructeur acceptant un entier, ce constructeur est marqué
`explicit´.

La construction du temporaire de type `B´ pour l'appel de `g()´ doit
alors être /explicité/, ce qui est fait comme ceci :

g( B( 2 ) ) ;

Ou :
g( static_cast< B >( 2 ) ) ;
ou :
g( (B)2 ) ;

Les trois écritures signifie exactement la même chose. L'avantage des
deux dernières, c'est qu'elles ne peuvent pas être pris pour une
déclaration, même dans l'initialisation d'une variable.

--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16