présence de #include fstream mais pas trace de fichier dans le code?!?

Version imprimable

Bonsoir,

J'essaie de comprendre un petit programme. C'est un pendu avec deux fichiers avec l'extension .h et .cpp et un main.cpp.
En plus il y a un fichier dictionnaire.txt qui contient les mots qu'il faudra trouver
Voila au début du fichier, il a le #include fstream pour l'ouverture et écriture pour un fichier. Je pense que c'est dictionnaire.txt, seulement je ne vois pas trace dans ce fichier de la mention dictionnaire.txt.
J'ai testé et pourtant ça marche. Pouvez vous m'éclairer!

Code:

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
 
#ifndef MYSTERE_H
#define MYSTERE_H
 
#include <iostream>
#include <vector>
#include <fstream>
 
using namespace std;
 
class Mystere
{
 
    public:
 
        //  Fonction de nettoyage
        void clear(void);
 
        //  Constructeur
        Mystere(void);
 
        //  Autres méthodes
        const void afficherMotTrouve(void);
        const void afficherLettresEntrees(void);
        const void afficherMotMystere(void);
        void testerLettre(char lettre);
        void assignerMot(vector< char > motSecret);
        const bool plusDeCoups(void);
        const bool victoire(void);
 
        //  Accesseur
        const long getCoupsRestants(void);
 
        //  Méthodes statiques
        static vector< char > motAleatoire(void);
        static vector< char > entreeJoueur(void);
        static void afficherTitre();
        static void activerMenu();
 
 
    private:
 
        vector< char > m_motSecret;
        vector< char > m_motTrouve;
        vector< char > m_lettresEntrees;
        long m_nombreCoupsRestants;
};
 
#endif // MYSTERE_H

02/06/2010, 19h13
skawll

Const void afficherMotTrouve(void) ça veut bien dire que c'est une fonction qui ne doit pas être modifiée et qui est vide!
02/06/2010, 20h04
Kalith
La référence à dictionnaire.txt se trouve très certainement dans un des fichiers .cpp (le main ou l'autre).

Quand à la fonction :

Code:

const void afficherMotTrouve(void);

... le mot const indique que la fonction ne modifiera pas l'objet sur lequel avec lequel elle est appelée :
Code:

1 2 3 4 Mystere m; // "m" est dans un état donné m.afficherMotTrouve(); // on est sûrs que "m" est toujours dans le même état
... le premier void indique que la fonction ne retourne rien, et le second (qui ne sert à rien, on peut l'enlever) indique que la fonction n'a pas besoin d'arguments.

Oui c'est vrai, dans un des fichiers .cpp, il y a la présence du fichier, seulement je pensais qu'on utilisait un include dans le fichier quand on en avait besoin.
Là ici on en a pas besoin à première vue!
Dans ce fichier, il n'y a pas d'include faisant référence au fichier,bizarre

Code:

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
#include "Mystere.h"
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  NETTOYAGE DES ATTRIBUTS
void Mystere::clear(void)  {
    m_nombreCoupsRestants = 8;
    m_motSecret.clear();
    m_motTrouve.clear();
    m_lettresEntrees.clear();
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  CONSTRUCTEUR
Mystere::Mystere(void)
{
    clear();
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  AFFICHAGE DU MOT A TROUVER
const void Mystere::afficherMotTrouve(void)  {
    for(unsigned long i=0; i!=m_motTrouve.size(); i++)  {
        cout << "  " << m_motTrouve[i];
    }
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  AFFICHAGE DES LETTRES DEJA ENTREES
const void Mystere::afficherLettresEntrees(void)  {
    for(unsigned long i=0; i!=m_lettresEntrees.size(); i++)  {
        cout << "  " << m_lettresEntrees[i];
    }
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  TEST D'UNE LETTRE POTENTIELLE
void Mystere::testerLettre(char lettre)  {
 
    bool reussite = false;
 
    //  On met en majuscule la lettre qui fut entree
    lettre = toupper(lettre);
 
    //  On vérifie si la lettre se trouve dans le MotMystere et on change motTrouve en conséquence
    for(unsigned long i=0; i!=m_motSecret.size(); i++)  {
        if(lettre == m_motSecret[i])  {
             m_motTrouve[i] = m_motSecret[i];
             reussite = true;
             }
    }
 
    //  On retire si nécessaire un coup au joueur
    if(reussite == false)  m_nombreCoupsRestants--;
 
    //  On rajoute la lettre entree au lettres deja rentrees
    m_lettresEntrees.push_back(lettre);
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  ASSIMILATION D'UN MOT AU MOT MYSTERE
void Mystere::assignerMot(vector< char > motSecret)  {
 
    //  On met en majuscules motSecret
    for(unsigned long i=0; i!=motSecret.size(); i++)  {
        motSecret[i] = toupper(motSecret[i]);
    }
 
    //  On l'assigne au mot Mystere
    m_motSecret = motSecret;
 
    //  On adapte la taille du mot trouve à celle de celui recherché
    m_motTrouve = m_motSecret;
 
    //  On lui assigne le symbole '_' à chaque entree
    for(unsigned long i=0; i!=m_motSecret.size(); i++)  {
        m_motTrouve[i] = '_';
    }
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  METHODE PERMETTANT DE DETERMINER S'IL RESTE OU NON DES COUPS AU JOUEUR
const bool Mystere::plusDeCoups(void)  {
    if(m_nombreCoupsRestants == 0)  return true;
    else return false;
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  METHODE POUR VERIFIER SI LE JOUEUR A TROUVE LE MOT MYSTERE OU PAS
const bool Mystere::victoire(void)  {
    if(m_motTrouve == m_motSecret)  return true;
    else return false;
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  ACCESSEUR AU NOMBRE DE COUPS RESTANTS
const long Mystere::getCoupsRestants(void)  {
    return m_nombreCoupsRestants;
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  AFFICHAGE DU MOT SECRET
const void Mystere::afficherMotMystere(void)  {
    for(unsigned long i=0; i!=m_motSecret.size(); i++)  {
        cout << m_motSecret[i];
    }
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  METHODE STATIQUE POUR DETERMINER UN NOMBRE ALEATOIRE
vector< char > Mystere::motAleatoire(void)  {
 
    //  Declaration des variables
    string motPiocheString;
    unsigned long nombreMots = 0;
    unsigned long nAleatoire = 0;
 
    //  Ouverture du fichier Dictionnaire.txt
    ifstream fichierDictionnaire("Dictionnaire.txt");
 
    //  Si l'ouveture du fichier a fonctionné
    if(!fichierDictionnaire.fail())  {
 
        //  On compte le nombre de mots dans le fichier
        while(!fichierDictionnaire.eof())  {
            motPiocheString.clear();
            fichierDictionnaire >> motPiocheString;
            nombreMots++;
        }
 
        //  On détermine un nombre aléatoire compris entre 0 et le nombre de mots dans le fichier
        nAleatoire = (rand()%(nombreMots))+1;
 
        //  On remet les flags du fichier Dictionnaire.txt à 0
        fichierDictionnaire.clear();
        fichierDictionnaire.close();
        fichierDictionnaire.open("Dictionnaire.txt");
        fichierDictionnaire.clear();
 
        //  On pioche le mot correspondant à ce nombre aléatoire
        for(unsigned long i=0; i!=nAleatoire; i++)  {
            motPiocheString.clear();
            fichierDictionnaire >> motPiocheString;
        }
 
        //  On ferme proprement le fichier Dictionnaire.txt
        fichierDictionnaire.clear();
        fichierDictionnaire.close();
 
        //  On transforme les accents en lettres normales et on met en majuscule motPioche
        for(unsigned long i=0; i!=motPiocheString.size(); i++)  {
            switch (motPiocheString[i])  {
                case 'é': motPiocheString[i] = 'e'; break;
                case 'è': motPiocheString[i] = 'e'; break;
                case 'à': motPiocheString[i] = 'a'; break;
                case 'ù': motPiocheString[i] = 'u'; break;
                case 'ç': motPiocheString[i] = 'c'; break;
                }
            motPiocheString[i] = toupper(motPiocheString[i]);
        }
 
        //  On stocke dans le vecteur
        vector< char > motPioche(motPiocheString.size(), ' ');
        for(unsigned long i=0; i!=motPiocheString.size(); i++)  {
            motPioche[i] = motPiocheString[i];
        }
 
        //  On retourne motPioche
        return motPioche;
    }
    //  Si l'ouverture du fichier échoue, on ne retourne rien
    else  {
        vector< char > machin;
        machin.clear();
        return machin;
    }
}
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//  METHODE STATIQUE POUR QU'UN JOUEUR RENTRE UN MOT AU HASARD
vector< char > Mystere::entreeJoueur(void)  {
 
    string motEntreString;
 
    cout << "²²²²²²²²²²  JOUEUR 1" << endl << endl << endl;
    cout << " Entrez un mot pour le joueur 2 :  ";
    cin >> motEntreString;
 
    vector< char > motEntre(motEntreString.size(), '0');
 
    for(unsigned long i=0; i!=motEntre.size(); i++)  {
        motEntre[i] = motEntreString[i];
    }
    return motEntre;
}
 
 
 
//  METHODE STATIQQUE POUR AFFICHER LE TITRE DU JEU
void Mystere::afficherTitre()  {
    system("CLS");
    cout << "²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²  LE JEU DU PENDU  ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²" << endl << endl;
}
 
//  METHODE STATIQUE POUR AFFICHER LE MENU DU JEU
void Mystere::activerMenu()  {
    cout << "²²²²²²²²²²  MENU PRINCIPAL" << endl << endl << endl;
    cout << " 1 . Joueur VS Ordinateur" << endl << endl;
    cout << " 2 . Joueur VS Joueur" << endl << endl;
    cout << " 3 . Fermer l'application" << endl << endl << endl;
    cout << "      Votre choix :  ";
}

02/06/2010, 21h53
skawll
Jene comprends pas pourquoi long est employé, j'ai niché surle net, c'est toujours affilié à int
Code:

1 2 3 // Accesseur const long getCoupsRestants(void);
03/06/2010, 11h02
nikko34

ben fstream c'est pour le ifstream, et normalement il devrait être inclus dans le .cpp mais si tu l'inclus dans le .h ça marche aussi...

D'ailleurs le ifstream est mal utilisé, voir la FAQ.

Comme ton code est pas terrible, ne t'étonne pas de trouver des trucs qui ne sont pas nécessaire
03/06/2010, 11h07
Invité

Je ne comprends pas ton histoire d'include : tu voudrais avoir quelque chose du genre #include "dictionnaire.txt" ? Les includes servent uniquement à inclure des fichiers source (en très gros, l'include fait office de simple copier-coller).

Pour l'utilisation du long, c'est simple : puisque la variable membre de la classe "m_nombreCoupsRestants" est un long, alors son accesseur ne fait pas de conversion et renvoie aussi un long.

La différence entre un "simple" int et un long est qu'un long peut théoriquement couvrir une plus large plage de chiffres.
En pratique, sur beaucoup de compilateurs, il n'y a pas de différence et les deux sont identiques (codés sur 32 bits). Ici une liste, pas forcément exhaustive.
03/06/2010, 16h13
atttchoum
Citation:
Envoyé par Kalith

Quand à la fonction :

Code:

const void afficherMotTrouve(void);

... le mot const indique que la fonction ne modifiera pas l'objet sur lequel avec lequel elle est appelée :

Code:

1 2 3 4 Mystere m; // "m" est dans un état donné m.afficherMotTrouve(); // on est sûrs que "m" est toujours dans le même état

... le premier void indique que la fonction ne retourne rien, et le second (qui ne sert à rien, on peut l'enlever) indique que la fonction n'a pas besoin d'arguments.
Tu confond avec :

Code:

void afficherMotTrouve(void) const;

en fait

Code:

const void afficherMotTrouve(void);

signifie que la fonction ne renvoi rien mais que ce rien est constant :D
et donc ça ne sert a rien :P (d'après moi)

Citation:

Envoyé par atttchoum

Tu confond avec :

Code:

void afficherMotTrouve(void) const;

Effectivement! J'avais pas fait attention. Faut dire que renvoyer un void constant, c'est pas courant :)
Ceci dit ça doit être une erreur de l'auteur du code, parce que c'est clairement une fonction membre constante.

@ skawll :
Je sais pas si ça t'aidera mieux à comprendre le système d'include, mais si tu as ceci :

fichier.h :
Code:

1 2 3 4 5 6 7 8 9 10 11 #include <string> #include <iostream> class UneClasse { public : UneClasse(); void UneFonction(); };
fichier.cpp :
Code:

1 2 3 4 5 6 7 8 9 10 11 #include "fichier.h" UneClasse::UneClasse() { std::string s = "hello"; } void UneClasse::UneFonction() { std::cout << "fonction" << std::endl; }
... alors "fichier.cpp" est strictement équivalent à :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #include <string> #include <iostream> class UneClasse { public : UneClasse(); void UneFonction(); }; UneClasse::UneClasse() { std::string s = "hello"; } void UneClasse::UneFonction() { std::cout << "fonction" << std::endl; }
Comme l'a dit ElGat0, un "include" c'est un simple "copier-coller", y a pas de magie!

En fait, le compilateur (en réalité c'est le pré-processeur) s'occupe de remplacer tous les #include "truc" par le contenu du fichier "truc", que ça soit un fichier .h, .cpp, ...

Au final, même si un fichier .cpp ne contient que quelques lignes, il contient en fait beaucoup plus de choses du point de vue du compilateur.
Tu peux t'amuser à ouvrir les fichiers "string" et "iostream" et copier leur contenu dans "fichier.cpp", puis faire de même avec les nouvelles "include" qui apparaissent au fur et à mesure. Au final, ça fait quand même pas mal de code à compiler, mine de rien!