Discussion :

[tonio_a_588]

Bonjour,
le titre n'est pas clair désolé...
j'ai une classe B qui a comme attribut un objet de la classe A. la classe A a plusieurs constructeurs, mais dans le constructeur de la classe B, c'est le constructeur par defaut de A qui est appelé :

Code :

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

1
2
3
4
5
6
 
class A
{
public :
A(int a, int b);
}

Code :

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

1
2
3
4
5
6
7
 
class B
{
public :
A objet_a;
B();
}

Comment, dans le constructeur de B, forcer le passage dans l'un des constructeurs de A ? Faut il raisonner par pointeur ? de la sorte, on peut utiliser :
objet_a=new A(a,b) dans le constructeur de B ? quelles sont les autres méthodes ?
Merci, j'espère que ma question est à la fois claire et pas trop ridicule, je suis un intermittent du C++ !

[Isythiel]

Et si tu faisais un constructeur de B par initialisation ?

Lorsque tu implémentes ce constructeur, tu peux ainsi faire appel au constructeur autre que par défault de A.

Edit : J'efface avant de me faire lyncher

[Arzar]

Non, pas besoin de new, il faut utiliser la liste d'initialisation :

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
class A
{
   A(int a, float b)
   {
   }
};
 
class B
{
public :
   B(int a, float b) : objet_a(a, b) 
   {
   }
private:
   A objet_a;
};

[Isythiel]

Exact, il va falloir que je révise

[koala01]

Salut,

Et si tu faisais un constructeur de B par initialisation ?

Lorsque tu implémentes ce constructeur, tu peux ainsi faire appel au constructeur autre que par défault de A.

Code :

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

1
2
3
B::B(int a, int b) {
   A = new A(a,b);
}

Malheureux...

On ne fait pas un new pour initialiser un membre qui n'est pas un pointeur

Pour répondre à ta question...

Si tu as un membre qui est de type non défaut-constructible, tu dois utiliser les listes d'initialisation, c'est à cela qu'elle servent

Soit la classe A qui se présente sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
class A
{
    public:
        A(int a, int b):a(a),b(b){} /* ( * ) */
        /*...*/
    private:
        int a;
        int b;
};

( (*) Et oui, il est possible d'utiliser un pseudo constructeur pour les types primitifs )
Pour laquelle il n'est pas opportun de définir un constructeur par défaut.

Si la classe B utilise un membre de type A, tu peux envisager trois constructeurs différents:

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
class B
{
    private: 
        A le_A;
    public:
        explicit B(A const& a):a(a){} /* utilisation du constructeur par
                                       * copie de A ( 1 )
                                       */
       B(int i1, int i2):a(i1, i2){} /* utilisation du constructeur "normal"
                                      *  de A  
                                      */
       B():a(10,24){} /* une construction par défaut de B qui fournit des
                       * valeurs fixe pour construire le A (pour autant que ca
                       * ait un sens :P )
                       */
};

Pour le premier constructeur présenté ( 1 ), il faut noter que:

1. le constructeur par copie est automatiquement créé par le compilateur si tu ne le déclare pas toi-même: le compilateur implémente une copie membre à membre, qui est suffisante dans cet exemple, mais qui peut ne pas être adéquat (entre autre si la classe A venait à gérer des pointeurs )
2. Il faut déclarer ce constructeur explicit de manière à éviter qu'il ne serve d'opérateur de conversion de A en B, ce qui peut apporter des soucis dans certaines circonstances

[tonio_a_588]

Merci !

[tonio_a_588]

J'ai deux classes A et B.
A a un attribut qui est un objet de la classe B.
Pour construire un objet A, je vais lire les valeurs des attributs dans un fichier ; je ne peux donc pas utiliser les listes d'initialisation pour construire B, puisque je ne connais pas à priori les valeurs de ses attributs (avant de les avoir lues dans le fichier).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
class A {
public :
B b;
float z;
...
A::A(ifstream f){ float x,y;
f >> x >> y >> z;
b.x=x;
b.y=y;}
};

Code :

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

1
2
3
4
5
6
7
 
class B {
public :
float x;
float y;
B::B(float xx,float yy){x=xx; y=yy;}
};

Est ce propre ? Comment pourrais je utiliser les listes d'initialisation ? en construisant un constructeur B::B(ifstream f) et en faisant dériver A de B ?
A::A(ifstream f) : B(ifstream f)
Mon problème est que ma classe B est supposée être assez générale, et ça m'ennuie de faire un constructeur juste pour ce type de fichier (quid si je dois faire la même chose avec d'autres fichiers?).
Je pense que ma façon de coder n'est pas terrible... mais je suis un peu aveuglé à force de tourner en rond.
Merci d'avance

[hiura]

1) Tu dois passer le flux par référence.
2) Créer un opérateur d'affection ( = ) ?

[3DArchi]

Petite lecture de ce matin.