programme en c++

**simosiso1** · 14/02/2009, 23h29

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 :

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
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();    
}

**Jannus** · 14/02/2009, 23h31

Bonjour,

Envoy� par simosiso1

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

Nous non plus

Si tu n'est pas plus explicite, ce sera difficile de t'aider

**simosiso1** · 14/02/2009, 23h53

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.

**LittleWhite** · 15/02/2009, 00h57

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

**simosiso1** · 15/02/2009, 01h57

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

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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??

**koala01** · 15/02/2009, 03h01

Salut, et bienvenue sur le forum

Envoy� par simosiso1

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
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 :

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
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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

et celui de list sous la forme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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

[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

)

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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 :

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
 
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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

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])

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 :

S�lectionner tout - Visualiser dans une fen�tre � part

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

)

**simosiso1** · 15/02/2009, 10h29

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 :

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
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");
}

programme en c++

C++

Vue hybride

Discussions similaires

Partager

Partager