Classes imbriquées

Version imprimable

Bonjour à tous.

J'ai une grosse incertitude concernant l'utilisation de constructeurs et destructeurs dans des classes imbriquées.

Imaginons 3 classes A, B , C comme suit :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 class A { public : A() { } }; class B { public : B(int valeur) { } }; class C { private : A instanceA; B instanceB; public : C() { instanceA = new A(); instanceB = new A(55); } ~C() { delete instanceA; delete instanceB; } };
Je voudrais savoir si l'utilisation de l'opérateur new est correcte pour faire appel aux constructeurs (par défaut et paramétré).

J'ai vu dans des exemples que le seul fait de faire le code ci-dessous construisait l'instance :

http://www.tutorialspoint.com/cplusp...destructor.htm
Code:

1 2 A instanceA;
Enfin d'après ce lien http://www.cplusplus.com/reference/cstdlib/free/

la fonction free accepte comme paramètre un pointeur, devrais je donc plutôt remplacer ceci :
Code:

1 2 3 4 A instanceA; B instanceB;
par cela ? :
Code:

1 2 3 4 A * instanceA; B * instanceB;
Merci de votre aide.

29/07/2013, 14h59
guilhemleflo
Bonjour, je croit bien qu'il faut les déclarer dans :
Code:

1 2 3 private : A * instanceA; B * instanceB;
Avec les pointeur.
Ensuite dans le constructeur de la class C, tu fait :

Code:

instanceA = new A

A vérifier je suis pas expert mais sous QT je fait comme ça me semble
29/07/2013, 15h24
metagoto

Le mieux c'est que tu lises la FAQ C++ http://cpp.developpez.com/faq/cpp/
Plus particulièrement les chapitres 4, 5, 6 et 10

Salut,

Tu peux aussi éviter de passer par des pointeurs en faisant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class C
{
  private :
 
  A instanceA;
  B instanceB;
 
  public :
 
  C()
  : /* instanceA(), // <-- Ne sert à rien, le constructeur par défaut sera appelé par défaut. */
    instanceB(55)
  {
  }
//...
};

Et ensuite tu peux instancier comme ceci ta classe :

Code:

1
2
ClasseC objetC;
//ClasseC objetC();  <-- Pas bon car le compilateur confondra ta déclaration par défaut et l'entête d'une fonction.

Donc pour résumer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
 
class A
{
    public :
 
	A()
	{
           printf("naissance de A");
	   printf("\n");
	}
 
	~A()
	{
	   printf("mort de A");
	   printf("\n");
	}
 
};
 
class B
{
	public :
 
	B(int valeur)
	{ 
           printf("naissance de B avec ");
	   printf("%d", valeur);
	   printf("\n");
	}
 
	~B()
	{
	   printf("mort de B");
	   printf("\n");
	}
};
 
class C
{
  private :
 
  A * instanceA;
  B * instanceB;
 
  public :
 
  C()
  {
        printf("naissance de C");
	printf("\n");
 
    instanceA = new A;
    instanceB= new B(55);
  }
 
  ~C()
  {
     delete instanceA;
     delete instanceB;
 
	 printf("mort de C");
	 printf("\n");
  }
 
};

Avec comme main :

Code:

1
2
3
4
5
6
7
8
 
 
int main(int argc, char* argv[])
{
	 C objetC;
 
	 return 0;
}

Ce qui donne :

Citation:

naissance de C
naissance de A
naissance de B avec 55
mort de A
mort de B
mort de C

j'étais franchement pas certain de l'utilisation du "new".