Discussion :

[philo71]

bonjour,
Je travail avec code::Blocks 17.12, j'aimerais bien comprendre les pointeurs et les classes d'objets.
J'ai donc décidé de faire une liste chainée de pointeurs et je lis et enregistre dans un fichier des mots aux format texte, (chaine.txt).
j'ai construis un programme de deux fichiers : un header > ptr_Hmot.h et un main.cpp. j'ai pour sortie une VT ou une fenètre commande sous windows.
voici mon petit programme :
1/ header >> ptr_Hmot.h

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
#ifndef PTR_HMOT_H_INCLUDED
#define PTR_HMOT_H_INCLUDED
#include <iostream>
#include <string>
class PTR_Hmot
{
    public:
 
    PTR_Hmot();
    void ajouter_ptr (std::string nouveau_mot);
    void inserer_ptr(std::string nouveau_mot);
    void maj_ptr(std::string nouveau_mot);
    void supprimer_ptr():
    void afficher_ptr(std::string af_mots); // C::B s'arrête ici, je ne vois pas pourquoi
    void charger_fichier();
    void ecrire_fichier();
    ~PTR_Hmot();
 
    private:
 
    double debut *m_debut;
    std::string mot *m_mot;
    double *m_fin;
 
};

2/ le main.cpp mais pas totalement implémenté :

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
#include <iostream>
#include <fstream>
#include <string>
 
#include "ptr_Hmot.h"
using namespace std;
 
int main()
{
   string mot;
   string mots;
   char reponse='Z';
    PTR_Hmot::PTR_Hmot(m_debut(0),m_mot(""),m_fin(0));
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;   
        switch(reponse)
        {
        case 'A':
            PTR_Hmot::charger_fichier(af_mot);
            {
                       int i=0;
                       ifstream fichier("/home/phipo/C++/ptr_002/chaine.txt");
                       if(fichier)
                       {
                       string ligne; //Une variable pour stocker les lignes lues
                          while(getline(fichier, ligne))
                          {
                             cout << ligne << endl;
                             m_mot-> new mot(ligne);
                             m_debut->i+1;
                             m_fin->i+2;
                             i=i+1;
                          }
                       }
                       else
                       {
                          cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." << endl;
                       }
            }
        break;
        case 'B':
            PTR_Hmot::ajouter_ptr(mot);
            {
 
            }
        break;
        case 'C':
            PTR_Hmot::maj_ptr(mot);
            {
 
            }
       break;
       case 'D':
            PTR_Hmot::supprimer_ptr();
            {
 
            }
       break;
       case 'E':
            PTR_Hmot::inserer_ptr(mot);
            {
 
            }
       break;
       case 'F':
            PTR_Hmot::afficher_ptr(mots);
            {
 
            }
       break;
       case 'G':
            PTR_Hmot::ecrire_fichier(chaine);
            {
 
            }
       break;
 
        }
        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');
return 0;
 
}

dans un premier temps je voudrais lire mon fichier chaine.txt d'une dixaines de mots pour les charger en mémoire grâce aux pointeurs.
Lors de la compilation C::B s'arrête sur une ligne de mon header.
comment faut'il si prendre ?

Salutations
Philippe

[foetus]

Tu as mis un deux points au lieu d'un point virgule

Question : Pourquoi tu mets 1 bloc vide dans chacun des case (main) ?

[philo71]

Je les remplirais plustart deja je veux charger le fichier chaine.txt dans des pointeurs, aprés je ferais l'implémentation de mes méthodes (bloques vides).
Je veux savoir si je suis dans le bon chemin,
Je ne demande pas que l'on écrive a ma place le programme , si c'est cela ta question ?

[ddaime]

Bonjour.

Avant toute chose, C::B s'arrête sur une ligne de code de votre entête avec un message d'erreur ou un warning ?
Quel est ce message ?

Ensuite, vous avez déclaré votre objet PTR_Hmot dans un fichier entête mais vous n'implémentez pas les méthodes de PTR_Hmot dans un fichier source ptr_Hmot.cpp. Du coup lors du premier appel à une méthode d'un objet qui n'est pas implémentée vous vous faites rappeler à l'ordre par le compilo.

De plus aucune des méthodes de votre classe n'est déclarée static donc il n'est pas possible de les appeler sans instancier un objet.

[Bousk]

PTR_Hmot::PTR_Hmot(m_debut(0),m_mot(""),m_fin(0)); Qu'espères-tu réaliser avec cette syntaxe en plein milieu du main ?
Ce n'est pas du tout la façon d'implémenter une fonction - ou ici un constructeur,.

[foetus]

@Bousk, philo71 se croit en JavaScript et pouvoir définir des fonctions dans des fonctions

D'ailleurs, si tu regardes bien, il a fait une entête ptr_Hmot.h avec les "include guards" : bonne action.
Moi, j'ai cherché les définitions/ implémentations parce que philo71 nous demande notre avis. Bien, c'est simple, ptr_Hmot.cpp et mixé avec le main, et ce sont tous les blocs vides dans le switch.


philo71 un conseil : Regarde un hello world même en C pour commencer. Ton code c'est n'importe quoi

[koala01]

Salut,

Je dois t'avouer que ta classe me laisse perplexe...:

• De deux choses, l'une: ou bien elle va te servir pour représenter les éléments d'une liste chainée, ou bien, elle va te servir pour représenter la liste chainée en elle-même. Mais, en l'état, je n'arrive pas à déterminer dans quel cas nous sommes;
• La présence d'un élément nommé m_debut semble indiquer que nous serions peut-être face à la liste chainée, mais, dans ce cas, pourquoi avoir appelé ta classe PTR_Hmot, et non quelque chose comme ListeMots ou comme WordList
• Mais, si cette donnée est sensée représenter le premier mot de la liste, pourquoi lui avoir donné le type "pointeur sur double" Cela n'a absolument aucun sens!
• De même, la donnée m_fin pourrais avoir du sens, mais, pourquoi en avoir fait un pointeur sur double Cela n'a pas d'avantage de sens!
• Enfin, pourquoi avoir un pointeur sur std::string pour la donnée m_mot
• D'ailleurs, la notation hongroise n'as pas vraiment d'intérêt dans le cas présent, sans oublier que, si on peut assez facilement déduire que PTR représente ... un pointeur, on va se demander à quoi correspond le H (serait-ce Holder )

Je conçois que ton souhait soit de t'amuser avec les pointeurs, mais cela n'empêche de travailler un tout petit peu correctement...

Si tu veux créer une liste chainée de chaines de caractères, tu as besoin de deux notions:

1. la notion d'élément et
2. la notion de liste chainée.

Tu devrais donc avoir quelque chose proche 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
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 readFromFile(std::string const &);
    void writeToFile(std::string const &) const;
    void print() const;
private:
    Element * first;
};

(je te laisse le soin d'implémenter les différentes fonctions )
qui te permettra une utilisation proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int main(){
    Liste liste;
    liste.add("salut")
         .add("hello")
         .add("monde")
         .add("world");
    liste.writeToFile("fichier.txt");
    Liste other;
    other.readFromFile("fichier.txt");
    other.print();
    return 0;
}

[philo71]

bonjour koala01, et la team developpez.
Première chose je te remerci koala01 pour ton aide car tu es le seul dans ce forum de débutant a m'avoir aider, les autres apart avoir des propos de Sir C++ qui n'avance a rien.
chose faite j'ai remanié le code selon tes indications koala01, mais j'ai encore quelque problème a voir le codage en C++, je veux particulièrement connaitre les fondamentaux des classes avec pointeurs cela est certainement le nerf de C++ et deplus cela me change de java ou l'on travail avec des matrices.
Lire des tutos c'est bien beau mais il vaut mieux prendre le problème.
voila mon code dit moi ce que tu en penses !
j'ai fait un header et deux .cpp :

le Header :

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
#ifndef LISTE_H_INCLUDED
#define LISTE_H_INCLUDED
 
 
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 readFromFile(std::string const &);
    //void writeToFile(std::string const &) const;
    void Liste::charger_fichier(Liste const &);
    void Liste::ajouter_ptr(Liste const &);
    void Liste::maj_ptr(Liste const &);
    void Liste::supprimer_ptr(Liste const &);
    void Liste:inserer_ptr(Liste const &);
    void Liste::afficher_ptr(Liste const &);
    void Liste::ecrire_fichier()Liste const &;
    //void print() const;
    ~Liste();
private:
    Element * first;
};
 
 
#endif // LISTE_H_INCLUDED

Le liste.cpp

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include <iostream>
#include <fstream>
#include <string>
 
#include "Liste.h"
 
 
using namespace std;
char reponse='Z';
int i_max=0;
 
{
    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':
            Liste::charger_fichier();
            {
                       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);
                             cout << ligne << endl;
                             i_max =i;
                          }
                       }
                       else
                       {
                          cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." << endl;
                       }
            }
        break;
        case 'B':
            Liste::ajouter_ptr();
            {
                cout << "je remplirais plus tard" << endl;
            }
        break;
        case 'C':
            Liste::maj_ptr();
            {
               cout << "je remplirais plus tard" << endl;
            }
       break;
       case 'D':
            Liste::supprimer_ptr();
            {
               cout << "je remplirais plus tard" << endl;
            }
       break;
       case 'E':
            Liste:inserer_ptr();
            {
               cout << "je remplirais plus tard" << endl;
            }
       break;
       case 'F':
            Liste::afficher_ptr();
            {
                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');
            }
       break;
       case 'G':
           Liste::ecrire_fichier();
            {
               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;
                }
            }
       break;
        }
        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');
while i<=i_max;
    {
    delete Liste:
    Liste(nullptr)
    cout << Destruction de la Liste terminée  << endl;
    }
return 0;
}

enfin le main.cpp :

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
#include <iostream>
 
#include "liste.h"
#include "liste.cpp"
 
 
using namespace std;
 
int main()
{
    Liste Liste;
    Liste other;
 
    return 0;
}

Les méthodes que j'ai ajoutées sont des sources d'erreur mais je ne vois pas comment contourner le problème !

si tu peux ajouter quelques comentaires et / ou code pour que j'avance rapidement seront bienvenues.
n'oublions pas que nous sommes dans un furom débutant et que tout le monde a ca chance.

Salutations
Philippe

[koala01]

Il y a cinq principes fondamentaux connus sous l'acornyme SOLID qu'il faut impérativement veiller à respecter.

Le premier de ces principes est représenté par le S pour SRP (Single Responsability Principle ou principe de la responsabilité unique), et tu ne le respecte absolument pas:

En gros, ce principe te dit que chaque fonction ne devrait s'occuper que d'une seule et unique chose. De cette manière, tu pourras la tester très facilement, et, surtout, tu pourras l'utiliser sous différentes combinaisons pour créer des comportements plus complexes.

A priori, on considère qu'une fonction qui fait plus d'une trentaine (*) de lignes est sans doute déjà une fonction qui fait trop de choses. Du coup, ta fonction de ... 130 lignes est a priori au moins quatre fois trop longue. Et cela se vérifie d'ailleurs, car chaque case de ta fonction mériterait d'être défini dans une fonction particulière. Comme tu as deux boucles qui se suivent des case qui vont de A à F, tu te retrouve a priori à faire... 9 choses différentes, ce qui en fait huit de trop.

(*) Le nombre est très variable, mais il oscille généralement entre 20 à l'heure actuelle et 50 pour des raisons "historiques".

En plus, tu devrais revoir la syntaxe de création de fonction, car, j'ai considéré qu'il y avait une fonction qui commencait à la ligne 9 et qui continuait jusqu'à la ligne 130 de list.cpp, mais la syntaxe ne correspond absolument à rien: l'implémentation d'une foncton prend systématiquement la forme de

Code :

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

1
2
3
TypeDeRetour nomDeLaFonction(/*listeDesParamètres */){
    /* ce qui doit être fait */
}

et, lorsqu'il s'agit d'une fonction membre d'une classe, elle prend la forme de

Code :

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

1
2
3
TypeDeRetour NonDeLaClasse::nomDeLaFonction(/*listeDesParamètres */){
    /* ce qui doit être fait */
}

quant à l'appel des fonction, il se fait sous la forme de

Code :

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

1
2
3
4
5
6
7
8
 
/* une fonction d'exemple */
void foo(){
    std::cout<<"Hello world";
}
int main(){
    foo(); // on appelle la fonction foo
}

ou, quand il s'agit d'une fonction membre de classe, par exemple

Code :

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

1
2
3
4
5
6
7
8
class MaClasse{
public:
    void bar();
}
 
void MaClasse::bar(){
    std::cout<<"Salut le monde";
}

il faut (généralement) disposer d'une variable du type de la classe en question (MaClasse, dans le cas présent) pour pouvoir appeler la fonction depuis cette instance particulière, sous une forme proche de

Code :

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

1
2
3
4
5
6
int main(){
    /*je crée une variable de type (AKA une instance de) MaClasse */
    MaClasse c;
   /*j'appelle foo depuis l'instance de MaClasse dont je dispose */
   c.bar();
}