programme en c++

Version imprimable

programme en c++

bonjour, j'ai fais un programme en c++ et je ne sais pas le problème ,est ce que quelqu'un peut m'aider s'il vous plait et merci d'avance,

voici le programme:

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# include <iostream.h>
# include <conio.h>
#include <stdlib.h>
//------------------------------------------------
class maillon
{     
      friend class list;
      public:
      int donnee;
      maillon * suivant; 
      public:
             //------------------------------------constructeur-----------------
 
           maillon(int a){donnee=a;suivant=NULL;}
 
             //-----------------------------constructeur par recopie
 
             maillon(maillon &m)
             { if(this!=&m)
                           {donnee=m.donnee;
                             suivant=m.suivant;
                            }
              }
 
              //-----------------------------destructeur------------------------
 
              ~maillon()
              {delete suivant;
                        }
};
//------------------------------------------------------------------------------
class list 
{
      maillon* mall ;
      int nb_mall;
      public:
             //-----------------------------constructeur------------------------
 
             list()
             {mall=NULL;
             nb_mall=0;}  
 
             //---------------------constructeur par recopie
 
             list(list &l)
             {
             if(this!=&l)
             {
             maillon* ma=l.mall;
              while(ma!=NULL)           
                {
                insererfin(ma->donnee);
                ma=ma->suivant;                        
                };           
              }
             }
 
             //---------------------destructeur---------------------------------
 
              ~list(){delete mall;}
 
             //------------------insertion en fin du liste----------------------
 
           void  insererfin(int d)
             {
               maillon *p=new maillon(d);
               maillon*pi=mall;
               while(pi->suivant!=NULL)
               {
                  pi=pi->suivant;               
               };
               pi->suivant=p;  
 
             }     
 
             //-------------------affichage de la liste-------------------------
 
             void affich()
             {   maillon *g=mall; 
               	while(g!=NULL)
                 {	cout<<g->donnee<<endl;
                    	g=g->suivant;
                   };   
 
             }
 
 
 
};
int main()
{
  list li;
  li.insererfin(4);
  li.insererfin(5);
  li.affich();  
 
getch();    
}

14/02/2009, 23h31
Jannus

Bonjour,

Citation:

Envoyé par simosiso1

j'ai fais un programme en c++ et je ne sais pas le problème

Nous non plus :aie:
Si tu n'est pas plus explicite, ce sera difficile de t'aider
14/02/2009, 23h53
simosiso1

je veux créé une liste chainée en utilisant les classes donc j'ai créé deux classes :classe maillon et classe liste

le problème c'est qu'il n y a pas d'erreur (le compilateur que j'utilise DEC C++)
mais lorsque je compile le windows m'envoie qu'il a rencontré un problème et il doit fermer l' exécution et je ne sais pas le problème.
15/02/2009, 00h57
LittleWhite
Bonjour,

Je dirai premièrement , qu'il faut que tu passe ton programme dans un debuggeur pour savoir précisément quelle ligne plante.
Si tu n'as pas de debuggeur , tu peux rajouter des affichages ( std::cout << "trace" << std::endl ) pour savoir jusqu'ou va ton programme , ou là ou il ne va pas.

L'erreur que te fais windows, est équivalent à une erreur de segmentation, cela veut dire que soit tu essaie d'utiliser un pointeur qui ne pointe sur rien ( sur NULL ) , soit tu essaie de désallouer de la memoire que tu as déjà désalloué ( delete de quelque chose déjà deleté ).

Conseils:

Normalement on fait n fichier .hpp et un fichier .cpp par classe.
Le fichier .hpp contient les déclarations.
Le cpp le corps des fonctions ( le code pour ainsi dire )

On dirait un melange de C et de C++ ... comme code , normalement on inclu :
Code:

1 2 #include <iostream>
et non "iostream.h" ( je parle de normalement )

( Normalement , il manque le "using namespace std;" ; bizarre que ton code est compilé :s )

J'ai lancé le programme dans un debuggeur il bug à cette ligne là :
( ligne 68 ) while(pi->suivant!=NULL)

pi est égale à NULL ...
Maintenant tu peux aisément corriger l'erreur ;)

merci beaucoup pour la réponse.j'ai fais 2 modifications :
1) dans le constructeur du class list

Code:

1
2
3
4
           list(int a)
                     {mall->donnee=a;
                      mall->suivant=NULL;
                              nb_mall=1;}

pour annuler le probléme que mall soit NULL.

2)dans la fonction membre insererfin

Code:

1
2
3
4
5
6
7
8
9
10
11
12
            void  insererfin(int d)
             { 
                 maillon *p=new maillon(d);
               maillon*pi=mall;
               maillon*h;
               while(pi!=NULL)
               {  h=pi;
                  pi=pi->suivant;               
               };
               h->suivant=p;  
 
                   }

mais le problème reste le même . et je ne sais pas pourquoi??

Salut, et bienvenue sur le forum
Citation:
Envoyé par simosiso1
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 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 # include <iostream.h> # include <conio.h> #include <stdlib.h> //------------------------------------------------ class maillon { friend class list; public: int donnee; maillon * suivant; public: //------------------------------------constructeur----------------- maillon(int a){donnee=a;suivant=NULL;} //-----------------------------constructeur par recopie maillon(maillon &m) { if(this!=&m) {donnee=m.donnee; suivant=m.suivant; } } //-----------------------------destructeur------------------------ ~maillon() {delete suivant; } }; //------------------------------------------------------------------------------ class list { maillon* mall ; int nb_mall; public: //-----------------------------constructeur------------------------ list() {mall=NULL; nb_mall=0;} //---------------------constructeur par recopie list(list &l) { if(this!=&l) { maillon* ma=l.mall; while(ma!=NULL) { insererfin(ma->donnee); ma=ma->suivant; }; } } //---------------------destructeur--------------------------------- ~list(){delete mall;} //------------------insertion en fin du liste---------------------- void insererfin(int d) { maillon *p=new maillon(d); maillon*pi=mall; while(pi->suivant!=NULL) { pi=pi->suivant; }; pi->suivant=p; } //-------------------affichage de la liste------------------------- void affich() { maillon *g=mall; while(g!=NULL) { cout<<g->donnee<<endl; g=g->suivant; }; } }; int main() { list li; li.insererfin(4); li.insererfin(5); li.affich(); getch(); }
Le fait est que tu n'utilise que des fichiers d'en-tête qui sont soit dépréciés (iostream.h) soit qui sont issus du C (stdlib.h et conio.h) dont un (conio.h) qui n'est même pas portable car fournis à l'origine par borland et qui ne fait absolument pas partie de la norme...

En effet, les en-têtes "officielles" pour les fichiers standard en C++ ne prennent pas d'extension (on utilise <iostream> et non <iostream.h>, ou <cstdlib> pour indiquer que l'on souhaite utiliser le fichier issu du C "stdlib.h", qui est, de toutes manières inutile du fait de la présence de <iostream>).

Je sais que cela apporte l'énorme inconvénient (ou, du moins ce qui peut passer pour auprès des débutants) de déclarer l'ensemble des fonctions et classes fournies par le standard dans l'espace de noms std, mais les avantages que l'on en tire sont bien plus importants que le problème de devoir écrire std::cout ou std::cin ;)

Pour te permettre de te passer de conio.h que tu n'inclus que pour pouvoir utiliser get(), je te propose de faire un tour vers l'entrée de la faq qui présente la manière de créer une pause portable ;)

Ensuite, je ne peux que t'inciter très fortement à choisir la convention de "mise en forme" du code que tu préfère (il y a plusieurs possibilités) mais à la respecter de manière stricte...

Tu remarqueras à la longue que c'est une grande partie de ce qui permet d'obtenir un code facilement compréhensible ;)

Ainsi, ton code serait déjà beaucoup plus facile à suivre sous la forme (non corrigée, sauf la "mise en forme") de
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 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 # include <iostream.h> # include <conio.h> #include <stdlib.h> //------------------------------------------------ class maillon { friend class list; // [4] public: int donnee; maillon * suivant; public: // [2] maillon(int a){donnee=a;suivant=NULL;} //[3] maillon(maillon &m) { if(this!=&m) { donnee=m.donnee; //[4] suivant=m.suivant; } } ~maillon() { delete suivant; //[5] } }; class list { maillon* mall ; int nb_mall; public: list() //[3]... à nouveau { mall=NULL; nb_mall=0; } list(list &l) { if(this!=&l) { maillon* ma=l.mall; while(ma!=NULL) { insererfin(ma->donnee); ma=ma->suivant; }; } } ~list() { delete mall; // [5]... ou son implication ;) } void insererfin(int d) { maillon *p=new maillon(d); maillon*pi=mall; while(pi->suivant!=NULL) //[6] { pi=pi->suivant; }; // [7] pi->suivant=p; } void affich() { maillon *g=mall; while(g!=NULL) { cout<<g->donnee<<endl; g=g->suivant; }; // [7] ... de nouveau } }; int main() { list li; li.insererfin(4); li.insererfin(5); li.affich(); getch(); // [8] // [9] }
Et la liste des remarque que sa lecture m'inspire:

[1] L'amitié ne sert que pour permettre à une classe d'accéder aux membres et aux méthodes protégés ou privés d'une autre... or, dans le code que tu présente, la classe maillon n'a que des membres et méthodes publiques.

Il n'y a donc aucun intérêt à déclarer la classe list amie de maillon ;) (ou alors, il faut modifier l'accessibilité des membres de maillons, ce qui implique, au minimum l'ajout d'un accesseur pour suivant ;) )

[2]Une fois que tu as précisé une accessibilité, il ne sert à rien de la répéter si elle ne change pas... Le public ici ne sert donc à rien ;)

[3]Il est conseillé d'utiliser les listes d'initialisation chaque fois que possible...

Ce n'est pas "catastrophique" dans ton cas, mais dans d'autres, cela évitera au compilateur de faire quatre chose lorsqu'une seule est suffisante ;)

Le constructeur de la classe maillon serait donc bien mieux implémenté sous la forme de

Code:

maillon(int a):donnee(a),suivant(NULL){}

et celui de list sous la forme de

Code:

list():mall(NULL),nb_mall(){}

(les type primitifs ont des "pseudo constructeurs" qui permettent la zero-initialisation par défaut ;))

[4] Là, tu prend un risque énorme: le fait que deux maillons (l'original et la copie) aient tous les deux un pointeur vers le même maillon suivant...

je vais attendre d'avoir expliqué le [5] pour t'indiquer le problème que cela peut poser ;)

Le plus marrant de l'histoire, c'est que tu n'utilise même pas le constructeur par copie de maillon (vu que tu utilise la méthode insertfin en lui passant la donnée du maillon en cours de copie dans le constructeur par copie de liste)...

Du coup, ne pourrait-on pas envisager de rendre maillon non copiable et non assignable, par déclaration (sans définition) du constructeur par copie et de l'opérateur d'affectation dans une accessibilité privée :question:

[5] Il y a un problème de délégation de la responsabilité dans ton code...

Le destructeur de maillon ne doit se charger que de gérer les ressources propres... au maillon en cours de destruction...

Ce devrait plutôt être au destructeur de la liste de veiller à détruire correctement l'ensemble des maillons qui la composent, et cela nous amène à la fin de l'explication du [4]:

Le problème donc de ton constructeur par copie de maillon, c'est que tu te retrouve avec deux maillons qui font référence au même maillon suivant.

Du coup, lorsqu'un de ces maillons va être détruit, comme tu demande au destructeur de... détruire le maillon suivant, tous les maillons qui suivent celui que tu as copié vont... etre détruit (ainsi exposé, lapalisse n'aurait pas mieux dit :D)

Cela implique que le pointeur de la variable "survivante" est devenu invalide (il pointe vers une adresse qui a déjà été libérée)

Au final, lorsque la variable survivante sera détruite, elle essayera... de libérer de la mémoire... déjà libérée, et cela fera "planter" lamentablement le tout ;)

Au final, le destructeur de maillon ne ferait strictement rien, et le destructeur de list deviendrait:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 ~list() { while(mall) { // récupérons le maillon suivant maillon *temp = mall; // libérons le premier maillon delete mall; // le maillon suivant devient le premier mall = temp; } }
[6] La manière d'envisager les choses que tu utilises n'est pas mauvaise en soi...

Cependant, je voudrais attirer ton attention sur le fait que, à chaque insertion d'un élément dans la liste, tu va parcourir... l'ensemble des éléments de la liste pour trouver le dernier, ce qui risque, si ta liste est destinée à recevoir quelques (centaines de) milliers d'éléments, de prendre énormément de temps finalement pour... pas grand chose...

En effet, tu pourrais envisager de manipuler également un pointeur sur... le dernier élément de la liste, ce qui te permettrait, au prix d'un test pour savoir s'il est déjà défini sur un élément, d'obtenir une insertion en "temps constant", et de gagner à peu de frais énormément en termes de performances.

Je suis le premier à dire que les optimisations prématurées sont très mauvaises, mais ici, il s'agit d'une optimisation qui n'a rien de prématuré et qui ne risque absolument pas de rendre le code plus difficile à lire...

De plus, et c'est là que se situe réellement ton problème, tu ne prend pas la peine de vérifier qu'il y ait déjà un premier maillon...

Or, lorsque tu ajoute le premier maillon, lapalisse n'aurait encore une fois pas dit mieux, il n'y a pas encore de premier maillon ;)

Ainsi, en décidant de rajouter un pointeur sur maillon arbitrairement nommé last et initialisé à NULL dans le constructeur de list, insertfin prendrait la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 insertfin(int toadd) { /*créons le maillon à rajouter */ maillon *temp = new maillon(toadd); /* c'est peut-être le premier ajout */ if(! mall) mall = temp; /* s'il y a déjà un dernier maillon, celui-ci se rattache à temp */ if(last) last->suivant = temp; /* et le maillon créé devient le dernier, quoi qu'il arrive */ last = temp; /* n'oublions pas de mettre le nombre d'éléments à jour ;) */ ++nb_mall; }
[7] Le point virgule ";" n'est pas nécessaire ici...

Il n'y a qu'une structure de contrôle pour laquelle le point virgule soit nécessaire après l'accolade fermante (attention, il est obligatoire pour les définitions de type: après l'accolade fermante des définitions des structures, des classes, des unions et des énumérations ;)), c'est la boucle "jusque":
Code:

1 2 3 do { } while (test); //ici, il est obligatoire
[8] getch() n'est pas une fonction "standard"... reporte toi au lien donné plus haut pour savoir comment créer correctement une pause en "beau C++" ;)

[9] Tu signale au compilateur que la fonction main renvoie un entier en fin d'exécution, mais tu n'invoque aucun retour de valeur...

Je sais bien que la norme prévois que, dans le cas où l'on ne met rien, le compilateur considère (à titre exceptionnel pour la fonction principale) qu'un return 0 a été placé...

Mais il est toujours préférable de se placer dans une situation "de base" plutôt que dans une situation particulière ;)

Alors, comme cela ne demande pas énormément de temps, pourquoi ne pas ajouter un return 0; avant l'accolade fermante de main :question:

Citation:

Envoyé par LittleWhite

Bonjour,

Je dirai premièrement , qu'il faut que tu passe ton programme dans un debuggeur pour savoir précisément quelle ligne plante.
Si tu n'as pas de debuggeur , tu peux rajouter des affichages ( std::cout << "trace" << std::endl ) pour savoir jusqu'ou va ton programme , ou là ou il ne va pas.

Tu n'a pas forcément tord, mais l'utilisation de trace présente malgré tout pas mal d'inconvénients, d'autant plus qu'une approche un peu moins transversale du code t'aurait fait sauter au yeux que le problème se situait dans insertfin (exposé dans mon [6])
Citation:
L'erreur que te fais windows, est équivalent à une erreur de segmentation, cela veut dire que soit tu essaie d'utiliser un pointeur qui ne pointe sur rien ( sur NULL ) , soit tu essaie de désallouer de la memoire que tu as déjà désalloué ( delete de quelque chose déjà deleté ).

Conseils:

Normalement on fait n fichier .hpp et un fichier .cpp par classe.
Le fichier .hpp contient les déclarations.
Le cpp le corps des fonctions ( le code pour ainsi dire )

On dirait un melange de C et de C++ ... comme code , normalement on inclu :
Code:

1 2 #include <iostream>
et non "iostream.h" ( je parle de normalement )

( Normalement , il manque le "using namespace std;" ; bizarre que ton code est compilé :s )
cf début de ma réponse pour savoir comment "c'est possible" (iostream.h a été écrit avant que le standard ne décide de permettre l'utilisation des espaces de noms, ou, en tout cas, avant de décider de tout mettre dans std ;) )

Que ce soit la trace ou le débuggeur, ce sont deux choses qui sont très utiles pour travailler...

Cependant, le fait d'avoir un code facilement lisible et donc de facilement pouvoir comprendre ce qui est fait permet bien souvent de s'éviter le recours à ces méthodes qui, malgré tout, sont très gourmandes en temps de mises en oeuvre (il est bien connu que le gros du retard se prend en phase de débuggage ;))

merci beaucoup, vraiment c'est le meilleur forum,j'ai compris mes erreurs et je l'ai corrigé et le problème reste le même. voici le code après correction:

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include <iostream>
#include <stdlib>
//------------------------------------------------
using namespace std;
class maillon
{     
      friend class list;
      int donnee;
      maillon * suivant; 
      public:
             //------------------------------------constructeur-----------------
 
         maillon(int a):donnee(a),suivant(NULL){}
 
             //-----------------------------constructeur par recopie------------
 
             maillon(maillon &m)
             { if(this!=&m)
                           {donnee=m.donnee;
                             suivant=m.suivant;
                            }
                            }
 
 
};
//------------------------------------------------------------------------------
class list 
{
      maillon* mall ;
      int nb_mall;
      public:
             //-----------------------------constructeur------------------------
 
           list():mall(NULL),nb_mall(){}  
 
             //---------------------constructeur par recopie--------------------
 
             list(list &l)
             {
             if(this!=&l)
             {
             maillon* ma=l.mall;
              while(ma!=NULL)           
                {
                insererfin(ma->donnee);
                ma=ma->suivant;                        
                };           
              }
             }
 
             //---------------------destructeur---------------------------------
 
             ~list()
{
    while(mall)
    {
        // récupérons le maillon suivant
        maillon *temp = mall;
        // libérons le premier maillon
        delete mall;
        // le maillon suivant devient le premier 
        mall = temp;
    }
}
 
 
 
             //------------------insertion en fin du liste----------------------
 
           void  insererfin(int d)
             { 
                 maillon *p=new maillon(d);
                 maillon *pi;
                 if (mall==NULL)
                 {
                 mall=p; 
                 ++nb_mall;             
                 }
                 else
                 {
                  while(pi->suivant!=NULL)
               {
                  pi=pi->suivant;               
               };
               pi->suivant=p;
                 ++nb_mall;        
                 }    
                 } 
 
             //-------------------affichage de la liste-------------------------
 
             void affich()
             {   maillon *g;
                 g=mall; 
               	for(int i=0;i++;i<nb_mall)
               	{
                        cout<<g->donnee<<endl;
                        g=g->suivant;
                }
 
             }
 
 
 
};
int main()
{
  list li;
  li.insererfin(4);
  li.insererfin(5);
  li.affich();  
    return 0;
	system("pause");
}

Je vois un problème dans le destructeur de list :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 ~list() { while(mall) { // récupérons le maillon suivant maillon *temp = mall; // libérons le premier maillon delete mall; // le maillon suivant devient le premier mall = temp; } }
Tu as oublié un petit quelque chose pour la première ligne dans le while...

Et dans le code pour afficher le contenu de la list :
Code:

1 2 3 4 5 6 7 8 9 10 void affich() { maillon *g; g=mall; for(int i=0;i++;i<nb_mall) { cout<<g->donnee<<endl; g=g->suivant; } }
Tu as inversé les deux dernières instructions du contenu du for() :

Code:

for(int i=0;i<nb_mall;i++)

.
... ou alors je viens d'apprendre quelque chose :)

16/02/2009, 10h38
simosiso1

merci, mais le problème reste le même.
16/02/2009, 10h48
white_tentacle

As-tu corrigé le destructeur ? (je te laisse trouver l'erreur qui reste dans le code isolé par Kalith).
17/02/2009, 21h29
simosiso1

oui vous avez raison; le problème est résolu:yaisse2::king: