chained list

hello, I develop under CodeBlocks 17.12, I want to make a chained list.
That is the use of Class and Pointers, I was helped a little on other forum, but I have trouble using the functions "operator".
My program reads in a text format file a list of words, and dynamically allocates a pointer, then afterwards I make next or prev, and move in my list chained, I do some simple operation: like search a word, update of a word and so on, then finally I write in my file the list of words, then freedom the memory of the computer.

Here is my source code:
1/ the header = liste.h
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
#ifndef LISTE_H_INCLUDED
#define LISTE_H_INCLUDED
#include <string>

struct Element{
    std::string value;
    Element * previous;
    Element * next;
};
class Liste{
public:
    Liste();
    Liste(Liste const & );
    Liste & operator = (Liste const &);
    ~Liste();
    Liste & add(std::string const &);
    void charger_fichier(Liste const &);
    void ajouter_ptr(Liste const &);
    void maj_ptr(Liste const &);
    void supprimer_ptr(Liste const &);
    void inserer_ptr(Liste const &);
    void afficher_ptr(Liste const &);
    void ecrire_fichier(Liste const &);
private:
    Element * first;
};

#endif // LISTE_H_INCLUDED 

2/ liste.cpp
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
115
#include <iostream>
#include <fstream>
#include <string>

#include "liste.h"
/* les fonctions "particulières": constructeur, constructeur
 * de copie et destructeur... elles n'ont pas de type de
 * retour
 */
char reponse='Z';
int i_max=0;
Liste::Liste(){
    /* rien à faire ici */
}
Liste::Liste(Liste const & other){
   /* copier le contenu de other dans this */
}
Liste::~Liste(){
   /* le destructeur, détruire tous les éléments de la liste*/
}
/* L'opérateur d'affectation, utilisera sans doute l'idiome
 * copy and swap pour la facilité
 */
Liste & operator =(Liste const & other){
    /* copier la liste recue en paramètre */
    Liste copy{other};
    /* intervertir le contenu de copy et de this */
    swap(copy); //à déclarer et à implémenter
    return *this;
} // copy est détruite ici
/* les autres fonctions que tu as déclarées */

Liste & Liste::add(std::string const &){
    /* ce qu'il faut faire */
}
void Liste::charger_fichier(Liste const &){
       int i=0;
                       ifstream fichier("/home/phipo/C++/ptr_chaine01/chaine.txt");
                       if(fichier)
                       {
                       string ligne; //Une variable pour stocker les lignes lues
                          while(getline(ligne)) //Tant qu'on n'est pas à la fin, on lit
                          {
                            Liste.add(ligne);
                            i= i+1;
                             cout << ligne << endl;
                             i_max =i;
                          }
                       }
                       else
                       {
                          cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." << endl;
                       }
}
void Liste::ajouter_ptr(Liste const &){
    /* ce qu'il faut faire */
}
void Liste::maj_ptr(Liste const &){
    /* ce qu'il faut faire */
}
void Liste::supprimer_ptr(Liste const &){
    /* ce qu'il faut faire */
}
void Liste:inserer_ptr(Liste const &){
    /* ce qu'il faut faire */
}
void Liste::afficher_ptr(Liste const &){
   char reponse_affiche='Z';
                do
                {
                    int i=0;
                    cout << "P/previous; N/next; Q/quit";
                    cin >> reponse_affiche;    // pointeur qui pointera sur la réponse choisie
                    switch(reponse_affiche)
                    {
                    case 'P':
                        {
                            i=i-1;
                            if (i>0)
                            {
                             Liste.previous;
                             cout << other.print() << endl;
                            }
                        }
                        break;
                        case 'N':
                        {
                            i=i+1;
                            if (i<=i_max)
                            {
                             Liste.next;
                             cout << other.print() << endl;
                            }
                        }
                        break;
                }while (reponse_affiche != 'Q');
            }
}
void Liste::ecrire_fichier()Liste const &{
               string const fichier("/home/phipo/C++/ptr_chaine01/chaine.txt");
               ofstream monFlux(nomFichier.c_str());
                if(monFlux)
                {
                 string ligne; //Une variable pour stocker les lignes lues
                 while(i_max<=i)) //Tant qu'on n'est pas à la fin, on lit
                  {
                    monFlux <<  other.print()<< endl;
                    cout << ligne << endl;
                  }
                }
                else
                {
                    cout << "ERREUR: Impossible d'ouvrir le fichier." << endl;
                }
}


3/ main
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
#include <iostream>
#include <string>
#include "liste.h"
#include "liste.cpp"

using namespace std;

int main()
{
      char reponse='Z';
    int i_max=0;
    Liste maListe; // on crée une liste
    {
    do
    {
        cout << "A-charger fichier; B-Ajouter ptr; C-maj ptr; D-supprimer ptr; E-inserer ptr; F-lire ptr; G-écrire fichier; Q-detruire/quit";
        cin >> reponse;    // pointeur qui pointera sur la réponse choisie
        switch(reponse)
        {
        case 'A':
            maListe.charger_fichier();
        break;
        case 'B':
            maListe.ajouter_ptr();
        case 'C':
            maListe.maj_ptr();
       break;
       case 'D':
            maListe.supprimer_ptr();
       break;
       case 'E':
            maListe.inserer_ptr();
       break;
       case 'F':
            maListe.afficher_ptr();

       case 'G':
           maListe.ecrire_fichier();



        cout << "A-charger fichier; B-Ajouter ptr; C-maj ptr; D-supprimer ptr; E-inserer ptr; F-lire ptr; G-écrire fichier; Q-detruire/quit";
        cin >> reponse;

}while (reponse != 'Q');
/* inutile: le destructeur de liste s'en charge while i<=i_max;
    {
    delete Liste:
    Liste(nullptr)
    cout << Destruction de la Liste terminée  << endl;
    }
*/

return 0;
}
}

I do not know if you understand French because the comments are in French, with Google translate is easy.
I can handle written French passably... (technical written French, lol)

In any case, in order to write the code for the copy constructor and add() method, you must consider how the list works. Pull out a piece of paper and a pencil and draw it.

First, all constructors must initialize first = nullptr;: an empty list.

Next, consider what you must do to add an element to the list:
 • find the last element
 • append a new node

For a doubly-linked list with common add() (append) operations, it might be worth the grief to also have a last pointer. This will make add()ing a new node very much more efficient.

With pictures:
initial state

 first
   ↓
nullptr
   ↑
  last
add("hello"):

            first
              ↓
          ┌───────┐
nullptr ← │"hello"│ → nullptr
          └───────┘
              ↑
             last
add("world"):

            first
              ↓
          ┌───────┐    ┌───────┐
nullptr ← │"hello"│ ←→ │"world"│ → nullptr
          └───────┘    └───────┘
                           ↑
                          last

Good luck!
Last edited on
Registered users can post here. Sign in or register to post.