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