IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

programme en c++


Sujet :

C++

  1. #1
    Membre à l'essai
    Inscrit en
    Février 2009
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 18
    Points : 12
    Points
    12
    Par défaut 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 : 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();    
    }

  2. #2
    Expert éminent sénior

    Profil pro
    Inscrit en
    Décembre 2004
    Messages
    19 647
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Décembre 2004
    Messages : 19 647
    Points : 32 889
    Points
    32 889
    Par défaut
    Bonjour,

    Citation Envoyé par simosiso1 Voir le message
    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

  3. #3
    Membre à l'essai
    Inscrit en
    Février 2009
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 18
    Points : 12
    Points
    12
    Par défaut
    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.

  4. #4
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    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
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  5. #5
    Membre à l'essai
    Inscrit en
    Février 2009
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 18
    Points : 12
    Points
    12
    Par défaut
    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??

  6. #6
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 612
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 612
    Points : 30 611
    Points
    30 611
    Par défaut
    Salut, et bienvenue sur le forum
    Citation Envoyé par simosiso1 Voir le message
    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
    Citation Envoyé par LittleWhite Voir le message
    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 )
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  7. #7
    Membre à l'essai
    Inscrit en
    Février 2009
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 18
    Points : 12
    Points
    12
    Par défaut
    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");
    }

  8. #8
    Membre éclairé

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juin 2007
    Messages
    373
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Royaume-Uni

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Santé

    Informations forums :
    Inscription : Juin 2007
    Messages : 373
    Points : 764
    Points
    764
    Par défaut
    Je vois un problème dans le destructeur de list :
    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;
        }
    }
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    for(int i=0;i<nb_mall;i++)
    .
    ... ou alors je viens d'apprendre quelque chose

  9. #9
    Membre à l'essai
    Inscrit en
    Février 2009
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 18
    Points : 12
    Points
    12
    Par défaut
    merci, mais le problème reste le même.

  10. #10
    Membre émérite
    Avatar de white_tentacle
    Profil pro
    Inscrit en
    Novembre 2008
    Messages
    1 505
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2008
    Messages : 1 505
    Points : 2 799
    Points
    2 799
    Par défaut
    As-tu corrigé le destructeur ? (je te laisse trouver l'erreur qui reste dans le code isolé par Kalith).

  11. #11
    Membre à l'essai
    Inscrit en
    Février 2009
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 18
    Points : 12
    Points
    12
    Par défaut
    oui vous avez raison; le problème est résolu

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Programme de boot qui passe la main à Windows
    Par Bob dans le forum Assembleur
    Réponses: 7
    Dernier message: 25/11/2002, 04h08
  2. [Kylix] Probleme d'execution de programmes...
    Par yopziggy dans le forum EDI
    Réponses: 19
    Dernier message: 03/05/2002, 15h50
  3. communication entre programmes
    Par jérôme dans le forum C
    Réponses: 12
    Dernier message: 16/04/2002, 09h05
  4. Comment débuter en programmation ?
    Par Marc Lussac dans le forum Débuter
    Réponses: 0
    Dernier message: 08/04/2002, 12h29
  5. [Kylix] icone associée à un programme
    Par Anonymous dans le forum EDI
    Réponses: 1
    Dernier message: 22/03/2002, 10h43

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo