Discussion :

[isidore]

Bonjour

j'ai un code sur les constructeur et destructeur et il y a qq truc que je n'ai pas compris sur dans le C++ :

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
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
 
#include<iostream.h>
#include<string.h>
 
 
class demo
{
	int x,y;
 
	public:
		//Constructeur 1
		demo(int abs=1, int ord=0)
		{
			x=abs;y=ord;
			cout << "Constructeur I : "<< x << " " << y << "\n";
		}
		//Constructeur 2 (par recopie)
		demo(demo&);
		//Destructeur
		~demo();
};
 
 
demo::demo(demo & d)
{
	cout<<"Constructeur II ( recopie ) : "<<d.x<<" "<<d.y<<"\n";
	x=d.x;y=d.y;
}
 
demo::~demo()
{
	cout<<"Destruction : "<<x<< " "<<y<<"\n";
}
 
void fct(demo d, demo *add)
{
	cout << "Entree fct\n";
	delete add;
	cout << "Sortie fct\n";
}
 
void main(void)
{
	cout << "Debut Main\n";
	demo a;
	demo b=2;
	demo c=a;
 
	demo *adr= new demo(3,3); // pointeur ici de type demo
	fct(a,adr);
 
	demo d = demo(4,4);
	c=demo(5,5);
	cout<<"Fin Main\n";
}

j'obtiens le résultat suivant à l'écran :



questions :

au 1er tirer rouge
pk y a t'il accès au constructeur par recopie? et pk t'a il les valeurs 1 et 0 au lieu de 3 et 3 ?

j'ai crée un objet avec (3,3) et je dis juste qu'il y a un pointeur (*adr ou adr?) de type demo qui pointe sur new demo(3,3)

ensuite qd j'entre dans la fonction "fct", j'efface "adr" donc j'efface le pointeur donc le programme va détrire l'objet demo(3,3) et je sors de la fonction et là il détruit l'objet (1,0) ! (2ème tiret rouge) je susi étonné étant donné que dans la fonction "fct" , j'ai remarqué que &d avait x et y avec 1 et 0 mais qu'à aucun moment dans cette fonction j'ai utilisé cet objet (1,0) donc je vois pk il serait détruit.

3ème tiret : pk à peine crée, l'objet (5,5) est détruit alors que la fonction main n'est pas encore terminée??

4ème tiret : je sais que la destruction se fait dans l'order inverse de création, donc (5,5) a été détruit, (4,4) aussi, mais d'où sort cet objet (5,5) détruit?


j'y pense, objet et classe c pareil?? j'ai utilisé le mot objet pour désigner les classe de types demo.

MERCI d'avance.

[Moucoulin]

Je vais essayer de regarder ça car j'ai des petites questions sur ce point moi aussi.

Je peux par contre répondre à la dernière question.

Un objet ou une instance est une utilisation ou occurence d' une classe.

Dans votre example, demo est la classe, a, b, c... en sont des objets.

[mdriesbach]

Bonjour.

En c++, les arguments de fonctions sont passés par recopie

La fonction fct reçoit un paramètre de type demo
Ce qui implique une copie locale de l'objet demo a (1,0) d'où l'appel du constructeur de recopie avec l'objet (1,0)
A la sortie de la fonction fct, la copie locale est détruite, d'où appel du destructeur de l'objet (1,0).
Pour le reste, mes souvenirs de C++ sont trop vagues.

Cordialement,

Mathieu Driesbach.

[Laurent Gomila]

pk y a t'il accès au constructeur par recopie? et pk t'a il les valeurs 1 et 0 au lieu de 3 et 3 ?

Lorsque tu déclares et affectes sur la même ligne (demo c=a) il y a appel au constructeur par copie. Il a les valeurs 1 et 0 car c'est une recopie de a que tu fais, qui a lui-même les valeurs 1 et 0.

ensuite qd j'entre dans la fonction "fct", j'efface "adr" donc j'efface le pointeur donc le programme va détrire l'objet demo(3,3) et je sors de la fonction et là il détruit l'objet (1,0) ! (2ème tiret rouge) je susi étonné étant donné que dans la fonction "fct" , j'ai remarqué que &d avait x et y avec 1 et 0 mais qu'à aucun moment dans cette fonction j'ai utilisé cet objet (1,0) donc je vois pk il serait détruit

Ta fonction prend son premier paramètre par valeur, ce qui signifie qu'une copie (constructeur par copie) sera effectuée à chaque appel (pour ne pas copier les paramètres il y a le passage par référence). De la même manière, le temporaire généré sera détruit à la fin de la fonction.

3ème tiret : pk à peine crée, l'objet (5,5) est détruit alors que la fonction main n'est pas encore terminée??

"c = demo(5, 5)" va créer un temporaire non nommé initialisé à (5, 5), puis va l'affecter à c. Aussitôt cette ligne executée, le temporaire sera détruit.

4ème tiret : je sais que la destruction se fait dans l'order inverse de création, donc (5,5) a été détruit, (4,4) aussi, mais d'où sort cet objet (5,5) détruit?

c ?

j'y pense, objet et classe c pareil?? j'ai utilisé le mot objet pour désigner les classe de types demo

Rien à ajouter par rapport à la réponse de Moucoulin

[Stany]

J'ai deja eu ce probléme et il est traité sur le forum : http://www.developpez.net/forums/vie...761&highlight=
si ca peu vous aider

[Moucoulin]

Impossible d'exécuter le code dans l'état.

Les instanciations de type a= demo(1,0) ne passe pas.
Seuls demo a(1,2)... passent.

Pour plus de lisibilité sur les appels, vous pouvez inclure une sortie de l'autoréférencement this.
Ca peut aider pour le (5,5) que je n'ai pas pu réaliser pour cause de non initialisation par c=demo(5,5).

[isidore]

visual c++ 6.0
0 erreur 0 warning

[Moucoulin]

Ca passe avec le compilateur de visual C++ tool kit 2003.
Un peu bizarre tout ça.

[isidore]

ça passe pas du veux dire
je connais pas les nouvo trucs mais si c le machin.NET, fo ptet que tu mettes
using standart std ou un truc qui ressemble à ça , c'est dans la FAQ.
mais bon je dis ça au hasard, je m'y conais pas trop, j'ai visual c++ 6.0 et ça compile sans soucis donc ça me va.
sinon essaie dev-c++ ou borland...
@+

[Stany]

Ca passe avec le compilateur de visual C++ tool kit 2003.
Un peu bizarre tout ça.

Bien Visual C++ crée peu etre les opréreteur par copie ou recopie.
Alors pour les probléme c'est dans l'autre poste qu'il y a un peu une reponce, il faut mettre

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 demo
{
   int x,y;
 
   public:
      //Constructeur 1
      demo(int abs=1, int ord=0)
      {
         x=abs;y=ord;
         cout << "Constructeur I : "<< x << " " << y << "\n";
      }
      //Constructeur 2 (par recopie)
      demo([b]const[/b] demo&); ///ici
      //Destructeur
      ~demo();
};

enfin je crois j'ai lu ca dans le livre de visual basic 6.0 !!

[isidore]

Coucou

me revoilà, bon j'ai eu le tps de lire vos commentaire et mon code.

3ème tiret :
"c = demo(5, 5)" va créer un temporaire non nommé initialisé à (5, 5), puis va l'affecter à c. Aussitôt cette ligne executée, le temporaire sera détruit.

pk cela ne passe t'il pas par un constructeur par recopie? l'objet "c" existe déjà, et il y a affectation donc quelque part c une recopie des valeurs de l'élement temporaire vers c->x et c->y et ensuite l'élement temporaire est détruit.

4ème tiret :
on a (4,4) qui est crée, puis l'objet temporaire (5,5) et affecté à c(5,5)
puis destruction du temporaire (5,5), donc le dernier objet à détruire serait c(5,5) puis l'objet (4,4) et je sais que la destruction se fait dans l'ordre inverse de création alors pourquoi c l'objet (4,4) qui est détruit et l'objet c(5,5) après? ça devrait justement etre le (5,5) détruit puis le (4,4) de détruit.

Stany : à quoi ça sert de mettre cela ??

Code :

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

1
2
3
demo(const demo&);
et
demo::demo(const demo & d)

je vois pas l'intéret de mettre const ou à quoi ça sert (par contre le résultat est exactement le meme sur mon écran).

Merci à tous

[Stany]

pk cela ne passe t'il pas par un constructeur par recopie? l'objet "c" existe déjà, et il y a affectation donc quelque part c une recopie des valeurs de l'élement temporaire vers c->x et c->y et ensuite l'élement temporaire est détruit.

Là la reponce est simple il faut que tu définisse ton operator =(const demo& obj) de la class

Stany : à quoi ça sert de mettre cela ??

Code :

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

1
2
3
demo(const demo&);
et
demo::demo(const demo & d)

Bien le const sert a empécher un recopie!

[Stany]

Apres 10 min passer dessus ca marche correctement :

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
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
 
class demo
{
   int x,y;
 
   public:
      //Constructeur 1
      demo(int abs=1, int ord=0)
      {
         x=abs;y=ord;
         cout << "Constructeur I : "<< x << " " << y << "\n";
      }
      //Constructeur 2 (par recopie)
      demo(const demo&);
      void operator=(const demo & d)
      {
           cout<<"Reconstructeur II ( recopie = demo) : "<<d.x<<" "<<d.y<<"\n";
           x=d.x;y=d.y;
      }
      void operator=( int  d)
      {
           cout<<"Reconstructeur II ( recopie = int) : "<<endl;;
           x=d;y=d;
      }
      //Destructeur
      ~demo();
};
 
 
demo::demo(const demo & d)
{
   cout<<"Constructeur II ( recopie ) : "<<d.x<<" "<<d.y<<"\n";
   x=d.x;y=d.y;
}
 
demo::~demo()
{
   cout<<"Destruction : "<<x<< " "<<y<<"\n";
}
 
void fct(demo d, demo *add)
{
   cout << "Entree fct\n";
   delete add;
   cout << "Sortie fct\n";
}
 
void main1(void)
{
   cout << "Debut Main\n";
   demo a;
   demo b;
   b=2;
   demo c=a;
 
   demo *adr= new demo(3,3); // pointeur ici de type demo
   fct(a,adr);
 
   demo d = demo(4,4);
   c=demo(5,5);
   cout<<"Fin Main\n";
}

il y a 7 constructeurs et 7 deconstructeurs

[niglo]

Apres 10 min passer dessus ca marche correctement :

Alors utilise le tag résolu
Merci

[Stany]

Bien c'est a dire que je vai avoir du mal car y a pas le bouton quand c'est pas ton sujet !!!!!!

[isidore]

pour Niglo uniquement : je suis ptet débutant en C++ mais je sais encore utiliser un forum !
et je suis au courant du tag résolu que je met lorsque le problème est résolu !
----------------------------------------------------------------------------
revenons à nos moutons :-)

coucou stany, merci pour le temps passé à me répondre

tu as dit "Bien le const sert a empécher un recopie!" j'ai comparé le résultat à l'écran obtenu avec ou sans le const, ça n'a rien changé dans la pratique, j'ai le résultat que le 1er imprim écran que j'ai posté ! si je me souviens de mon cours, le prof m'avait dit que le const est mis par sécurité, comme ça on est sûr que y a pas de modification chgment de valeur non désiré, là je pense que j'ai raison vu que le résultat a pas changé du tout
Après vérification sur le net, c bien cela "En effet, lors de cette recopie, nous faisons appel à l'objet lui-même, et il n'y aurait aucun sens à vouloir le modifier ! "

Pour ma part, j'ai tout compris, sauf un seul point où je n'ai pas trouvé de réponse :

4ème tiret :
on a (4,4) qui est crée, puis l'objet temporaire (5,5) est affecté à c(5,5)
puis destruction du temporaire (5,5), donc le dernier objet à détruire serait c(5,5) puis l'objet (4,4) et je sais que la destruction se fait dans l'ordre inverse de création alors pourquoi c'est l'objet (4,4) qui est détruit et l'objet c(5,5) après? ça devrait justement etre le (5,5) détruit puis le (4,4) de détruit.

voilà, merci

[Stany]

4ème tiret :
on a (4,4) qui est crée, puis l'objet temporaire (5,5) est affecté à c(5,5)
puis destruction du temporaire (5,5), donc le dernier objet à détruire serait c(5,5) puis l'objet (4,4) et je sais que la destruction se fait dans l'ordre inverse de création alors pourquoi c'est l'objet (4,4) qui est détruit et l'objet c(5,5) après? ça devrait justement etre le (5,5) détruit puis le (4,4) de détruit.

Alors la bien c'est normal car le fonction crée un objet qui n'appelle pas ton constructeur mais ton déconstructeur donc c'est normal que tu as un défaut de 1 deconstructeur ( un en trop ) (normalement )

Code :

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

1
2
3
4
5
void operator=(const demo&  d)
      {
           cout<<"Reconstructeur II ( recopie = demo) : "<<d.x<<" "<<d.y<<"\n";
           x=d.x;y=d.y;
      }

Dans les argumment des fonction comme celle-ci il faut mettre const car (avec Dev-C++ ca ne marche pas si non ) c'est pour avoir a la foi un objet déja construit et tu objet temporaire demo!!

je code que 'ai donné marche tres bien y a trop rien a rajouter maintenant ou je ne voi pas quoi !

[Moucoulin]

La dernière occurence de (5, 5) correspond à la destruction résultant de l'opération demo c=a;.

On peut remarquer d'ailleurs que la construction de cet objet n'apparait pas à l'écran.
A ce moment là, on retrouve bien un ordre compréhensible.

A tester avec une surcharge de l'opérateur "=".

[JolyLoic]

const ne sert pas qu'à ça. Imagine les fonctions suivantes :

Code :

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

1
2
void f(int &i);
void g(int const &i);

Quand tu déclares f, tu indiques que la variable passée à f peut être modifiée. Donc tu dois lui passer une variable.

Code :

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

1
2
3
4
int i = 42;
f(i); // ok
f(12); // Pas bon, pas une variable
f(i*i) ; // Pas bon, pas une variable non plus

Maintenant, comme dans g, tu promet de ne pas modifier le paramètre, ce n'est pas grave si ce qu'on lui passe n'est pas une variable.

Code :

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

1
2
3
4
int i = 42;
g(i); //ok
g(12); //ok
g(i*i); // ok

J'avoue ne pas trop savoir pourquoi ton appel demo d = demo(4,4); peut être passé avec un constructeur par recopie ne prenant pas son argument en référence constante.

D'ailleurs, en mode conforme (/Za), mon visual C++ me crache ces erreurs :

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
 
testconstrefcopycstr\main.cpp(44) : warning C4326: return type of 'main' should be 'int' instead of 'void'
testconstrefcopycstr\main.cpp(47) : error C2616: 'initializing' : cannot implicitly convert a non-lvalue 'demo' to a 'demo &' that is not const
        while checking that elided copy-constructor 'demo::demo(demo &)' is callable
        testconstrefcopycstr\main.cpp(19) : see declaration of 'demo::demo'
        when converting from 'int' to 'demo'
testconstrefcopycstr\main.cpp(53) : error C2558: class 'demo' : no copy constructor available or copy constructor is declared 'explicit'
testconstrefcopycstr\main.cpp(54) : error C2440: 'argument' : cannot convert from 'demo' to 'demo &'
        A non-const reference may only be bound to an lvalue
        while checking that elided copy-constructor 'demo::demo(demo &)' is callable
        testconstrefcopycstr\main.cpp(19) : see declaration of 'demo::demo'
        when converting from 'demo' to 'const demo &'
testconstrefcopycstr\main.cpp(54) : error C2440: 'argument' : cannot convert from 'const demo' to 'demo &'
        A non-const reference may only be bound to an lvalue
        while checking that elided copy-constructor 'demo::demo(demo &)' is callable
        testconstrefcopycstr\main.cpp(19) : see declaration of 'demo::demo'
        when converting from 'const demo' to 'demo'

Pour ton problème non résolu, c a été avant crée d. Que par la suite, on lui affecte une autre valeur n'y change rien : Il est normal qu'il soit détruit après d.

[Moucoulin]

C'est tout à fait le cas.
Il ne compile pas avec une version de g++. Il n'accepte pas.

C'est le constructeur de recopie qui fait bloquer.

Merci pour toutes les explications.