Discussion :

[Noste]

Bonjour,

J'ai le code suivant qui compile parfaitement avec g++ (4.4.5 et 4.5.3 avec les options -W -Wall -ansi -pedantic) mais je trouve cela bizarre !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct Foo {
    Foo(const int& n) : m_foo(n) {};
    int m_foo;
};
 
struct Bar {
    Bar(const Foo& f) : m_foo(f)  {};
    Foo m_foo;
};
 
int main(void) {
    Bar a(456);  // bizarre que ça marche et que g++ ne me dise rien
    Foo b(1999);  
    Bar c(b); // ça marche et c'est normal
}

Normalement je devrais pouvoir créer un objet Bar à partir d'un objet Foo ou comme copie d'un autre objet Bar. Mais là, en utilisant un entier, ça marche ! J'imagine que g++ crée un objet Foo en douce lors de la construction de l'objet a.

J'ai remplacé la liste d'initialisation par une affectation dans le corps du constructeur de Bar et là la compilation échoue.

J'ai eu beau chercher je n'ai pas trouvé de référence à ce comportement. Est-ce dans la norme C++ ? Est-ce un comportement propre à g++ ?

[Invité]

Bonsoir,
Pour avoir une erreur il faudrait que le constructeur de Fou soit explicit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
struct Foo
{
    explicit Foo(int n) m_foo(n) {}
   //...
};

Ce comportement (la conversion implicite) peut être assez pratique dans certains cas, voir par exemple le constructeur de std::string qui prend un const char*

[gbdivers]

Un constructeur qui prend qu'un seul argument (différent du type construit, sinon c'est un constructeur par copie) est appelé un constructeur de conversion et peut être utilisé automatiquement par le compilateur, sauf si ce constructeur est précédé de explicit. Souvent, on conseille de mettre par défaut le explicit (pour éviter les surprises) sauf quand on souhaite explicitement que le constructeur soit un constructeur de conversion.

2 choses importantes : il ne peut pas y avoir plusieurs conversion implicite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct A {
    A(int i) {}
};
 
struct B {
    B(A a) {}
};
 
struct C {
    C(B b) {}
};
 
main() {
    A a(1); // ok
    B b(1); // ok : conversion
    C c(1); // erreur : nécessite 2 conversions (A et B)
}

Le compilateur recherche dans un premier temps s'il trouve un constructeur avec le bon type. Et seulement s'il ne trouve pas, il recherche une conversion.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A {
    A(int i) {}
};
 
struct B {
    B(int i) {}
    B(A a) {}
};
 
main() {
    A a(1); // ok
    B b(1); // ok : pas de conversion ; le compilateur ne choisit pas entre B(int) et B(A(int))
}