Tout nouveau, j'arrive avec une question ^^

Version imprimable

Tout d'abord, salut :)
Je me suis finallement décider de me mettre au c++, et pour commcer j'ai tout bonnement eu l'idéé de faire un ptit jeux de pendu. Pour ceux qui conaissent pas, le principe est que quelqu'un essais de deviner un mot en donnant des lettres et si la lettre n'y est pas on dessine une tête, puis un corp, puis un bras etc. Jusqu'à ce qu'on arrive a un bonhomme complet. Bref le but est de deviner le mot ^_^.

Dans ma classe tout bonnement nommé Mot je tente de changer une lettre, je ne connais pas les subtilitées du C++ alors soyez indulgent :) Donc la méthode de ma classe qui plante lorsqu'on l'utilise est ChangerLettre.
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 #include <iostream.h> #include <string.h> class Mot { private: //<attributs> char *_mot; //</attributs> public: //<proprietes> //<get> char *Get_mot(void) { return _mot; } int unsigned Get_Len(void) { return strlen(_mot); } //</get> //<set> void Set_mot(char *mot) { _mot = new char[strlen(mot) + 1]; //+1 pour le \0 byte _mot = mot; } //</set> //<methodes> Mot(char *mot) { Set_mot(mot); } void ChangerLettre(unsigned int position, char nouvLettre) { _mot[position] = nouvLettre; } }; int main() { Mot motPendu("rotule"); motPendu.ChangerLettre(3, 'b');//RHONN FAIT PLANTER :( cout << motPendu.Get_Len(); return 0; }
Le tout a été compiler sans erreur avec Microsoft Visual C++ Toolkit 2003.

Michi d'avance ;)

Salut,
alors très rapide avant d'aller dodo et sans faire plus
Code:

1 2 3 4 5 6 void Set_mot(char *mot) { _mot = new char[strlen(mot) + 1]; //+1 pour le \0 byte // _mot = mot; // mauvais strcpy( _mot, mot ); // à utiliser }
Si tu commences le C++
Code:

1 2 #include <iostream.h>
remplacé par
Code:

1 2 3 #include <iostream> using namspace std; // je te laisse re renseigner pour savoir à quoi ça sert
Sinon utilise plutôt des std::string ( à toruver dans des tutos) au lieu des char[] ou des char*. c'est nettement plus simple et plus C++.

sur ce ... zzz ZZZ zzz

Ma version avec des std::string:

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
#include <iostream>
#include <string>
#include <assert.h>
 
class Mot
{
private:
        std::string mot;
public:
        std::string Get_mot() { return mot; }
        unsigned int Get_Len() { return mot.size(); }
 
        void Set_mot(const std::string & new_mot) { mot = new_mot; }
 
        Mot(const std::string & new_mot) : mot(new_mot) {}
 
        void ChangerLettre(unsigned int position, char nouvLettre)
        {
        assert(position < mot.size());
        mot[position] = nouvLettre;
        }
};
 
int main()
{
Mot motPendu("rotule");
motPendu.ChangerLettre(5, 'b');
std::cout << motPendu.Get_Len() << std::endl;
std::cout << motPendu.Get_mot() << std::endl;
 
return 0;
}

09/10/2005, 17h15
JolyLoic

Sans compter qu'avec std::string, je doute de l'utilité d'une classe Mot, surtout telle qu'elle a été décrite pour l'instant. std::string fait déjà directement l'ensemble des fonctions de la classe Mot.
09/10/2005, 18h26
petitedouceur

Citation:

Envoyé par JolyLoic

Sans compter qu'avec std::string, je doute de l'utilité d'une classe Mot, surtout telle qu'elle a été décrite pour l'instant. std::string fait déjà directement l'ensemble des fonctions de la classe Mot.

Non justement, elle va utiliser d'autres méthodes. Sans compter que ça m'apprend le c++ :lol:

Bon voilà apres une journee j'y suis arrivé à bout ^_^. Si vous avez le temps... j'aprécirais grandement que vous critiquiez ce qui est bon ou pas bon dans mon code :).

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
 
#include <iostream>
#include <string>
#include <algorithm>
 
using namespace std;
 
class Mot {
	private:
        //<attributs>
            string _mot;
        //</attributs>
    public:
        //<proprietes>
            //<get>
                string Get_mot(void) { return _mot; }
                unsigned int Get_len(void) { return _mot.length(); }
            //</get>
            //<set>
                void Set_mot(string mot) {
                    transform(mot.begin(), mot.end(), mot.begin(), toupper);
                    _mot = mot; 
                }
            //</set>
        //<methodes>
            Mot(string mot = "") { Set_mot(mot); }
 
            void ChangerLettre(unsigned int position, string nouvLettre) {
            	_mot.replace(position - 1, 1, nouvLettre);
            }
 
            char Lettre(unsigned int position) {
            	if ((position > 0) && (position <= Get_len())) {
            		return _mot.data()[position -1];
            	} else {
            		return ' ';
            	}
            }
 
            bool Contient(char caractere) {
            	if (_mot.find(caractere) == _mot.npos) {
            		return false;
            	} else {
            		return true;
            	}
            }
 
            bool Comparer(Mot mot) {
            	if (_mot == mot.Get_mot()) {
            		return true;
            	} else {
            		return false;
            	}
            }
        //</methodes>
};
 
class Pendu {
	private:
        //<attributs>
            Mot _motADeviner;
            Mot _motTirets;
            Mot _alphabet;
            unsigned short int _nbEssaisMax;
            unsigned short int _noEssai;
        //</attributs>
    public:
        //<proprietes>
            //<get>
                Mot Get_motADeviner(void) { return _motADeviner; }
                Mot Get_motTirets(void) { return _motTirets; }
                Mot Get_alphabet(void) { return _alphabet; }
                unsigned int Get_nbEssaisMax(void) { return _nbEssaisMax; }
                unsigned int Get_noEssai(void) { return _noEssai; }
            //</get>
            //<set>
 
            //</set>
        //</proprietes>
        //<methodes>
            Pendu(string mot = "") {
            	_nbEssaisMax = 5;
            	_noEssai = 0;
            	_motADeviner.Set_mot(mot);
            	string tmp(_motADeviner.Get_len(), '_');
            	_motTirets.Set_mot(tmp);
            	_alphabet.Set_mot("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
            }
 
            void UnEssais(char lettre) {
            	if (_alphabet.Contient(lettre)) {
                    if (_motADeviner.Contient(lettre)) {
                        for (unsigned int i = 1; i <= _motADeviner.Get_len(); i++) {
                            if (_motADeviner.Lettre(i) == lettre) {
                                _motTirets.ChangerLettre(i, string(1, lettre));
                            }
                        }
                    } else {
                        _noEssai++;
                    }
 
                    for (unsigned int i = 1; i <= _alphabet.Get_len(); i++) {
                        if (_alphabet.Lettre(i) == lettre) {
                            _alphabet.ChangerLettre(i, "");
                        }
                    }
            	}
            }
 
            unsigned short int PartieTermine(void) {
            	if (_motTirets.Comparer(_motADeviner)) {
            		return 1;
            	} else if(_noEssai == _nbEssaisMax) {
            		return 0;
            	} else {
            		return 2;
            	}
            }
        //</methodes>
};
 
void ZePendu(unsigned short int courrant) {
    if (courrant == 0) {
        string pendu[7] = { ("   /-----|"),
                            ("   |"), 
                            ("   |"), 
                            ("   |"), 
                            ("   |"), 
                            ("   |"), 
                            ("  ¯¯¯")};
        for (unsigned short int i = 0; i < 7; i++) {
            cout << pendu[i] << endl;
        }
    } else if(courrant == 1) {
        string pendu[7] = { ("   /-----|"),
                            ("   |    ( )"),
                            ("   |"),
                            ("   |"),
                            ("   |"),
                            ("   |"),
                            ("  ¯¯¯")};
        for (unsigned short int i = 0; i < 7; i++) {
            cout << pendu[i] << endl;
        }
    } else if(courrant == 2) {
        string pendu[7] = { ("   /-----|"),
                            ("   |   ( )"),
                            ("   |    |"),
                            ("   |    |"),
                            ("   |"),
                            ("   |"),
                            ("  ¯¯¯")};
        for (unsigned short int i = 0; i < 7; i++) {
            cout << pendu[i] << endl;
        }
    } else if(courrant == 3) {
        string pendu[7] = { ("   /-----|"),
                            ("   |    ( )"),
                            ("   |    _|_"),
                            ("   |     |"),
                            ("   |"),
                            ("   |"),
                            ("  ¯¯¯")};
        for (unsigned short int i = 0; i < 7; i++) {
            cout << pendu[i] << endl;
        }
    } else if(courrant == 4) {
        string pendu[7] = { ("   /-----|"),
                            ("   |    ( )"),
                            ("   |    _|_"),
                            ("   |     |"),
                            ("   |    / \\"),
                            ("   |"),
                            ("  ¯¯¯")};
        for (unsigned short int i = 0; i < 7; i++) {
            cout << pendu[i] << endl;
        }
    } else if(courrant == 5) {
        string pendu[7] = { ("   /-----|"),
                            ("   |    (X)"),
                            ("   |    _|_"),
                            ("   |     |"),
                            ("   |    / \\"),
                            ("   |"),
                            ("  ¯¯¯")};
        for (unsigned short int i = 0; i < 7; i++) {
            cout << pendu[i] << endl;
        }
    }
}
 
void Affichage(void) {
	string mot;
	char essai;
 
	cout << "Inscrivez un mot : ";
	cin >> mot;
 
	Pendu pendu(mot);
 
	do
	{
		ZePendu(pendu.Get_noEssai());
		for (unsigned short int i = 1; i < pendu.Get_motTirets().Get_len(); i++) {
			cout << pendu.Get_motTirets().Lettre(i) << " ";
		}
        cout << pendu.Get_motTirets().Lettre(i) << endl;
		cout << "Lettres restantes : " << pendu.Get_alphabet().Get_mot() << endl;
		cout << "Faire un essai : ";
		cin >> essai;
		pendu.UnEssais(toupper(essai));
	} while (pendu.PartieTermine() == 2);
 
    ZePendu(pendu.Get_noEssai());
    for (unsigned short int i = 1; i < pendu.Get_motTirets().Get_len(); i++) {
        cout << pendu.Get_motTirets().Lettre(i) << " ";
    }
    cout << pendu.Get_motTirets().Lettre(i) << endl;
    cout << "Lettres restantes : " << pendu.Get_alphabet().Get_mot() << endl;
 
	if (pendu.PartieTermine() == 1) {
		cout << "Bravo tu a réussit!" << endl;
	} else {
		cout << "Sniffe tu n'a pas réussit!" << endl;
	}
 
	cout << "Le mot était " << pendu.Get_motADeviner().Get_mot() << "." << endl;
 
}
 
int main()
{
    string rejouer;
	do
    {
        Affichage();
        do
        {
            cout << "Voulez vous jouer une autre partie? (O/N) ";
            cin >> rejouer;
            transform(rejouer.begin(), rejouer.end(), rejouer.begin(), toupper);
        } while ((rejouer != "O") && (rejouer != "N"));
    } while (rejouer == "O");
 
    return 0;
}

Le tout a été compiler sans erreur (mais 15 warning que j'ai pas trop compris) avec Microsoft Visual C++ Toolkit 2003.

Voici ce que j'ai fait avec Borland C++ Builder 6:

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
#include <iostream>
#include <string>
#include <algorithm>
#include <assert.h>
 
//Je ne conseille pas d'utiliser cette directive...
//Il vaut mieux préfixer avec std::
//En effet, si un jour tu utilises une bibliothèque qui définit sa propre version de string, ça craint
//using namespace std;
 
namespace
{
        const enum Fin_Pendu { SUCCEEDED , FAILED , CONTINUE };
}
 
class Mot
{
private:
        //Là aussi ce n'est qu'une histoire de convention, mais autant éviter le caractère _
        //avant un membre... Tu peux avoir des conflits avec des variables globales (sous Windows principalement)
        std::string mot;
public:
        //Pas besoin de void quand tu n'as pas de paramètres à une fonction
        std::string Get_mot() { return mot; }
        unsigned int Get_len() { return mot.length(); }
 
        //Par défaut, une string est vide, donc pas besoin de string mot = ""
        Mot() { }
        //Par contre si tu veux pouvoir définir le mot, là aussi tu utilises une référence et une initialisation
        Mot(const std::string & new_mot) : mot(new_mot)
        {
        std::transform(mot.begin(), mot.end(), mot.begin(), std::toupper);
        }
 
        void ChangerLettre(unsigned int position, const std::string & nouvLettre)
        {
        assert(position < mot.length());
 
        mot.replace(position, 1, nouvLettre);
        }
 
        char Lettre(unsigned int position)
        {
        assert(position < mot.length());
 
        //return mot[position.data()[position -1];
        //Grâce aux assert, tu sais que 0 <= position < longueur, tu peux donc retourner
        //directement le caractère
        //Une chaine commence à la position 0 jusque length - 1, donc il faut que la position soit dans cet intervalle
        return mot[position];
        }
 
        bool Contient(char caractere)
        {
        return !(mot.find(caractere) == mot.npos);
        }
 
        //Idem, une référence
        bool Comparer(const Mot & new_mot)
        {
        return (mot == new_mot.Get_mot());
        }
};
 
class Pendu
{
private:
        Mot motADeviner;
        Mot motTirets;
        Mot alphabet;
 
        //unsigned short int nbEssaisMax;
        //Je ne suis pas sur, mais unsigned short int n'a pas le même effet que unsigned short... A vérifier
        unsigned short nbEssaisMax;
        unsigned short noEssai;
public:
        Pendu(const std::string & new_mot)
        : nbEssaisMax(5),noEssai(0),motADeviner(new_mot),
        alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ"),motTirets(std::string(new_mot.length(),'_'))
        {
        std::cout << motADeviner.Get_mot() << std::endl;
        }
 
        void Essai(char lettre)
        {
        if (alphabet.Contient(lettre))
        {
                if (motADeviner.Contient(lettre))
                {
                        for (unsigned int i = 0; i <= motADeviner.Get_len() -1; i++)
                        {
                                if (motADeviner.Lettre(i) == lettre)
                                {
                                        motTirets.ChangerLettre(i, std::string(1, lettre));
                                }
                        }
                }
                else
                        noEssai++;
 
                for (unsigned int i = 0; i <= alphabet.Get_len(); i++)
                        if (alphabet.Lettre(i) == lettre)
                        {
                                alphabet.ChangerLettre(i, "");
                                break;
                        }
        }
        }
 
        unsigned short PartieTermine()
        {
                if (motTirets.Comparer(motADeviner))
                        return SUCCEEDED;
                else if(noEssai == nbEssaisMax)
                        return FAILED;
                else
                        return CONTINUE;
        }
 
        //Autant tout mettre dans le même objet Pendu
        void Affichage_Pendu()
        {
        switch (noEssai)
        {
                case 0:
                        std::cout << "   /-----|" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "  ---" << std::endl;
                        break;
                case 1:
                        std::cout << "   /-----|" << std::endl;
                        std::cout << "   |    ( )" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "  ---" << std::endl;
                        break;
                case 2:
                        std::cout << "   /-----|" << std::endl;
                        std::cout << "   |    ( )" << std::endl;
                        std::cout << "   |     |" << std::endl;
                        std::cout << "   |     |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "  ---" << std::endl;
                        break;
                case 3:
                        std::cout << "   /-----|" << std::endl;
                        std::cout << "   |    ( )" << std::endl;
                        std::cout << "   |    _|_" << std::endl;
                        std::cout << "   |     |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "  ---" << std::endl;
                        break;
                case 4:
                        std::cout << "   /-----|" << std::endl;
                        std::cout << "   |    ( )" << std::endl;
                        std::cout << "   |    _|_" << std::endl;
                        std::cout << "   |     | " << std::endl;
                        std::cout << "   |    / \\" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "  ---" << std::endl;
                        break;
                case 5:
                        std::cout << "   /-----|" << std::endl;
                        std::cout << "   |    (x)" << std::endl;
                        std::cout << "   |    _|_" << std::endl;
                        std::cout << "   |     |" << std::endl;
                        std::cout << "   |    / \\" << std::endl;
                        std::cout << "   |" << std::endl;
                        std::cout << "  ---" << std::endl;
                        break;
        }
        }
 
        //Affiche les tirets
        void Affichage_Mots_Tirets()
        {
        for (int i=0; i < motTirets.Get_len(); i++)
                std::cout << motTirets.Lettre(i) << " ";
 
        std::cout << std::endl;
        }
 
        //Affiche les lettres restantes de l'alphabet
        void Affichage_Lettres_Restantes()
        {
        std::cout << "Lettres restantes : " << alphabet.Get_mot() << std::endl;
        }
 
        void Affichage_Mot_Cache()
        {
        std::cout << "Le mot était " << motADeviner.Get_mot() << "." << std::endl;
        }
};
 
 
int main()
{
        bool another_game = false;
 
        do
        {
                std::string mot;
                bool end_game = false;
 
                std::cout << "Inscrivez un mot : ";
                std::cin >> mot;
 
                Pendu pendu(mot);
 
                do
                {
                        pendu.Affichage_Pendu();
                        pendu.Affichage_Mots_Tirets();
                        pendu.Affichage_Lettres_Restantes();
 
                        switch (pendu.PartieTermine())
                        {
                                case CONTINUE:
                                        char essai;
                                        std::cout << "Faire un essai : ";
                                        std::cin >> essai;
 
                                        pendu.Essai(std::toupper(essai));
                                        break;
                                case FAILED:
                                        std::cout << "Sniffe tu n'a pas réussi!" << std::endl;
                                        pendu.Affichage_Mot_Cache();
                                        end_game = true;
                                        break;
                                case SUCCEEDED:
                                        std::cout << "Bravo tu a réussi!" << std::endl;
                                        pendu.Affichage_Mot_Cache();
                                        end_game = true;
                                        break;
                        }
                } while (!end_game);
 
                std::string rejouer;
 
                do
                {
                        std::cout << "Voulez vous jouer une autre partie? (O/N) ";
                        std::cin >> rejouer;
                        std::transform(rejouer.begin(), rejouer.end(), rejouer.begin(), std::toupper);
                } while ((rejouer != "O") && (rejouer != "N"));
 
                another_game = (rejouer == "O");
        } while (another_game);
return 0;
}

C'est pas parfait, mais c'est déjà mieux je pense...

10/10/2005, 14h00
petitedouceur

Merci, je vais étudier ce dont tu m'a fait pars :)... des que j'aurais une minute ^_^
10/10/2005, 15h12
julien.sagnard

Une petite remarque rapidement :
Toutes vos string sont passées et retournées par valeur. Cette façon de faire génère des copies inutiles. Il vaut mieux utiliser des références:

Code:

void Set_mot(string mot)

devrait être remplacé par

Code:

void Set_mot(const string & mot)

(Au passage, je n'ai pas trouvé ce point dans la FAQ)

Quand une méthode ne modifie pas la classe, ajoutez un const :

Code:

string Get_mot(void)

devient

Code:

const string & Get_mot(void) const
10/10/2005, 22h28
petitedouceur

Citation:

Une petite remarque rapidement :
Toutes vos string sont passées et retournées par valeur. Cette façon de faire génère des copies inutiles. Il vaut mieux utiliser des références

Pourtant, je croyais que tout comme en php, une fois la fonction/classe est terminé elle est déchargée en mémoire. non?
10/10/2005, 22h33
Médinoc

C'est l'action de copier qui bouffe sur les performances, pas trop la place mémoire utilisée par la copie.
10/10/2005, 23h25
petitedouceur
zoubidaman >> pourrais-tu m'expliquer l'utiliter de ce namespace :
Code:

1 2 3 4 5 namespace { const enum Fin_Pendu { SUCCEEDED , FAILED , CONTINUE }; }
Car selon ce que la faq me dit sur les namespace (http://c.developpez.com/faq/cpp/?page=namespace) ben je comprend pas trop. Car je n'ai vu de procédure Fin_Pendu...

Ps merci encore une fois ;)
10/10/2005, 23h57
petitedouceur

Citation:

Envoyé par Médinoc

C'est l'action de copier qui bouffe sur les performances, pas trop la place mémoire utilisée par la copie.

D'accord merci de l'explication

Citation:
Envoyé par petitedouceur
zoubidaman >> pourrais-tu m'expliquer l'utiliter de ce namespace :
Code:

1 2 3 4 5 namespace { const enum Fin_Pendu { SUCCEEDED , FAILED , CONTINUE }; }
Car selon ce que la faq me dit sur les namespace (http://c.developpez.com/faq/cpp/?page=namespace) ben je comprend pas trop.
namespace te permet de définir un espace de nom dans ton programme...

std:: par exemple est un espace de nom, c'est à dire que tout ce qui se trouve à l'intérieur de ce code:
Code:

1 2 3 4 namespace std { //blabla }
Devra être utilisé en préfixant avec std::, comme par exemple std::cout, std::string...

Ca permet d'identifier une librairie par exemple (quand tu utiliseras boost, ou Loki, les fonctionalités qu'ils proposent doivent être préfixés, ex: boost::scoped_ptr)

Imagines qu'un jour tu utilises une bibli. qui te propose une classe string... S'il n'y avait pas les namespaces, comment le compilateur ferait-il la différence entre std::string et truc::string?

Ca c'est pour les espaces de nom...

Maintenant là j'utilise un namespace anonyme... C'est à dire que la portée de ce qui se trouve dedans est limitée à ce seul fichier...

Ex:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 //Unit1.h namespace { int toto; } struct foo { int i; foo() : i(toto) {} }; //Unit2.h #include "Unit1.h" struct foo2 { int i; foo2() : i(toto) {} //Erreur, parce que toto est limité à Unit1.h };
Par contre le code suivant fonctionne:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 //Unit1.h namespace A { int toto; } struct foo { int i; foo() : i(A::toto) {} }; //Unit2.h #include "Unit1.h" struct foo2 { int i; foo2() : i(A::toto) {} //C'est OK, on a défini l'espace de nom };
Quand dans ton premier code tu utilisais la directive:

Code:

using namespace std;

Ca te permet de spécifier au compilo que dans le fichier dans lequel tu travailles, pas besoin de préfixer avec std::...

Tu peux utiliser la directive comme suit également:

Code:

using std::string;

Ce qui ici t'oblige à préfixer ce qui appartient à la STL avec std::, sauf pour les string...

Citation:

Envoyé par petitedouceur

Car je n'ai vu de procédure Fin_Pendu...

C'est une énumération... Ca permet de définir des constantes avec des noms plus explicites...

Tu ne l'as pas vu, parce que tu peux utiliser les constantes telles qu'elles...

Mais tu peux la retrouver en tant que paramètre de fonction par ex:
Code:

1 2 3 4 5 void toto(Fin_Pendu conclusion) { if (conclusion == SUCCEEDED) //bla bla }
Citation:

Envoyé par petitedouceur

Ps merci encore une fois ;)

De rien ;)

Ahhh michi :)

Bon maintenant j'arriver avec une question d'ordre de compilation (comme quoi on arrete pas les erreures ;))
Bon j'ai chipouiller mon code pour le "rafiner" si on peut ainsi dire. Bref j'ai une bibliothèque « mot.hxx » :
mot.hxx

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
 
class Mot {
	private:
		std::string m_mot;
		std::string UCase(std::string chaine) {
			std::transform(chaine.begin(), chaine.end(), chaine.begin(), toupper);
			return chaine;
		}
 
	public:
		const std::string Get_mot() { return m_mot; }
		const unsigned int Get_len() { return m_mot.length(); }
 
		void Set_mot(std::string mot) {
			m_mot = UCase(mot);
		}
 
		Mot(std::string mot) { Set_mot(mot); }
 
		char Lettre(const unsigned int &position) {
			if ((position > 0) && (position <= Get_len())) {
				return m_mot.data()[position -1];
			} else {
				return ' ';
			}
		}
 
		void ChangerLettre(const unsigned int &position, std::string nouvLettre) { 
			if (position > 0) {
				m_mot.replace(position - 1, 1, nouvLettre);
			}
		}
 
		bool Contient(const char &caractere) { return (m_mot.find(caractere) != m_mot.npos); }
 
		unsigned int Cherche(char &occurence) {
			if (Contient(occurence)) {
				return m_mot.find(occurence) + 1;
			} else {
				return 0;
			}
		}
 
		bool Comparer(Mot &mot) { return (m_mot == mot.Get_mot()); }
};

Et voici le début de
main.cpp

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
 
#include <iostream>
#include <string>
#include <algorithm>
#include "mot.hxx"
 
class Pendu {
	private:
		Mot m_motADeviner;
		Mot m_motTirets;
		Mot m_alphabet;
		unsigned short int m_nbEssaisMax;
		unsigned short int m_noEssai;
 
	public:
		Mot Get_motADeviner() { return m_motADeviner; }
		Mot Get_motTirets() { return m_motTirets; }
		Mot Get_alphabet() { return m_alphabet; }
		unsigned int Get_nbEssaisMax() { return m_nbEssaisMax; }
		unsigned int Get_noEssai() { return m_noEssai; }
 
		Pendu(std::string mot) {
			m_nbEssaisMax = 5;
			m_noEssai = 0;
			m_motADeviner.Set_mot(mot);
			m_motTirets.Set_mot(std::string(m_motADeviner.Get_len(), '_'));
			m_alphabet.Set_mot("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
		}
...

Donc l'erreur que je reçois à ma compilation c'est :

Citation:

Envoyé par Microsoft Visual C++ Toolkit 2003

main.cpp 21 error C2512: 'Mot' : no appropriate default constructor available

C'est l'erreur qui me « hante » depuis que j'ai troucher à mon code ^_^, si vous avez une idée merci de me le faire savoir :)

11/10/2005, 03h04
zoubidaman
Citation:
Envoyé par petitedouceur

Code:

1 2 3 4 5 6 class Mot { //... Mot(std::string mot) { Set_mot(mot); } //... };

Et voici le début de
main.cpp

Code:

1 2 3 4 5 6 7 8 //... class Pendu { private: Mot m_motADeviner; Mot m_motTirets; Mot m_alphabet; //...

Donc l'erreur que je reçois à ma compilation c'est :

Citation:

Envoyé par Microsoft Visual C++ Toolkit 2003

main.cpp 21 error C2512: 'Mot' : no appropriate default constructor available

C'est l'erreur qui me « hante » depuis que j'ai troucher à mon code ^_^, si vous avez une idée merci de me le faire savoir :)
Il tente d'initialiser m_motADeviner, m_motTirets et m_alphabet avec le constructeur par défaut de Mot, qui n'existe pas...

Tu dois donc ajouter

Code:

Mot() {}

dans la déclaration de Mot

Sinon je t'ai montré l'initialisation des membres dans le constructeur, pourquoi est-ce que tu en fait encore l'affectation?

Et on t'a plusieurs fois conseillé de passer les std::string par référence! :evil:
Code:

1 2 3 4 Pendu(const std::string & mot) : m_nbEssaisMax(5), m_noEssai(0),m_motADeviner(mot),m_motTirets(std::string(mot.length(), '_')),m_alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ") { }
(Bien sûr la même chose pour Mot)

C'est mieux comme ça, c'est plus rapide, parce que tu initialises directement tes membres avec la valeur.
Avec ta méthode, tu dois d'abord construire le membre, puis changer sa valeur...

Sinon pourquoi préfixer toutes tes variables avec m_? Je n'en vois pas l'utilité, ça rallonge inutilement le code...

Citation:

Envoyé par petitedouceur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
char Lettre(const unsigned int &position) {
			if ((position > 0) && (position <= Get_len())) {
				return m_mot.data()[position -1];
			} else {
				return ' ';
			}
		}
 
		void ChangerLettre(const unsigned int &position, std::string nouvLettre) { 
			if (position > 0) {
				m_mot.replace(position - 1, 1, nouvLettre);
			}
		}

Les index des strings commencent à 0 jusqu'à length()-1, comme je te l'ai déjà dit...
Et pour accéder directement à un caractère du string, pas besoin de passer par la fonction data(). Utilise directement operator[]...
Et enfin utilise directement m_mot.length() plutôt que de passer par Mot::Get_Len(), vu que tu travailles directement sur un membre...

Donc je pense que c'est mieux de faire:

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
char Lettre(unsigned int position)
{
if (position < m_mot.length())
{
	return m_mot[position];
}
else
        return ' ';
 
/*J'aime bien dans ce genre de cas utiliser l'operateur ternaire
return position < m_mot.length() ? m_mot[position] : '';
*/
}
 
//A confirmer, mais je crois que c'est inutile de passer par une référence constante pour les types intégrés...
void ChangerLettre(unsigned int position, const std::string & nouvLettre)
{ 
//Pas besoin de cette condition, position est fatalement > 0 puisque c'est un unsigned int!
//if (position > 0) 
if (position < m_mot.length())
{
		m_mot.replace(position, 1, nouvLettre);
}
}

11/10/2005, 06h35
petitedouceur
Citation:

Et on t'a plusieurs fois conseillé de passer les std::string par référence!

Oh pardon, c'est parceque lors de mes tests, je créait une classe mot de cette façon : Mot mot("bleebloublah"); et puisque ce n'est pas considérer comme étant une variable ça plantait ^_^. Bref il faut ajouter Mot mot(std::string("bleebloublah"));.
Or, j'en viens à la réflexion, c'est p-e une idée puriste ou préconscue et complètement sans fondements. Mais je me disais quand on créé une classe basé sur des référence il se pouvait que celle-ci devienne instable. (bref c'est surment des idées mal-fondées (c'est qu'on m'a enseigner à travailler le moins possible avec des références)

Citation:

Sinon pourquoi préfixer toutes tes variables avec m_? Je n'en vois pas l'utilité, ça rallonge inutilement le code...

Afin de différencier les données membres de mes autres variables, question d'habitude. C'est une mauvaise habitude? J'aimeriais bien qu'on m'explique pourquoi.

Citation:

Et enfin utilise directement m_mot.length() plutôt que de passer par Mot::Get_Len(), vu que tu travailles directement sur un membre...

Ok, c'est encore qqch venant de mon enseignement :oops:

Quand on écrit :
Code:

1 2 3 4 5 Pendu(const std::string & mot) : m_nbEssaisMax(5), m_noEssai(0),m_motADeviner(mot),m_motTirets(std::string(mot.length(), '_')),m_alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ") { }
Afin de confirmer ce que je crois avoir compris. Est-ce que ce qui viens entre : et { sont une sotre de "pré-procédure" à appliquer avant le reste de l'exécution de la procédure???

Citation:

/*J'aime bien dans ce genre de cas utiliser l'operateur ternaire
return position < m_mot.length() ? m_mot[position] : '';
*/

Merci je ne conaissait pas :D

Citation:

//Pas besoin de cette condition, position est fatalement > 0 puisque c'est un unsigned int!

Pas fier de cette erreur ^_^

J'aimerais ajouter que tu m'as fait réaliser le but lorsqu'on programme n'est pas nécessairement que ceux qui utiliserons où lirons notre code le comprenne nécessairement sans commentaires mais qu'il soit performant,
11/10/2005, 14h50
julien.sagnard

Citation:

Oh pardon, c'est parceque lors de mes tests, je créait une classe mot de cette façon : Mot mot("bleebloublah"); et puisque ce n'est pas considérer comme étant une variable ça plantait ^_^. Bref il faut ajouter Mot mot(std::string("bleebloublah"));.

Normalement, ton "bleebloublah" aurrait du être convertie automatiquement en string. Est ce que tu n'aurrais pas fait une autr erreur ailleur ?

Citation:

Or, j'en viens à la réflexion, c'est p-e une idée puriste ou préconscue et complètement sans fondements. Mais je me disais quand on créé une classe basé sur des référence il se pouvait que celle-ci devienne instable.

Pourquoi ?

Citation:

(bref c'est surment des idées mal-fondées (c'est qu'on m'a enseigner à travailler le moins possible avec des références)

Je te conseille d'aller lire le chapitre 4 de ce cours:
http://cpp.developpez.com/cours/cpp/
Et au passage, un tour sur la partie référence de la FAQ ne ferra pas de mal:
http://c.developpez.com/faq/cpp/?page=references

Citation:

Afin de confirmer ce que je crois avoir compris. Est-ce que ce qui viens entre : et { sont une sotre de "pré-procédure" à appliquer avant le reste de l'exécution de la procédure???

Non. Ca permet d'initialiser les attributs en même temps que tu alloues l'espace mémoire. Au passage, utiliser cette technique te permet d'aviter d'avoir à définir un constructeur par défaut pour Mot.
11/10/2005, 17h26
petitedouceur

Merci, j'appréci vraiment ce temps que tu as pris à m'expliquer tout cela :). Jvais p-e refaire des erreures, mais moins ^^

Allo, ben ouais je crois progresser dans la correction de mon codes ^_^... voici ce que ça donne jusqu'à maintenant :

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
 
//main.cpp
#include <iostream>
#include <string>
#include <windows.h>
#include "pendu.h"
 
//code trouvé à http://cpp.enisoc.com/articles/clrscr/
void clear()
{
  HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
  COORD coord = {0, 0};
  DWORD count;
 
  CONSOLE_SCREEN_BUFFER_INFO csbi;
  GetConsoleScreenBufferInfo(hStdOut, &csbi);
 
  FillConsoleOutputCharacter(hStdOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count);
 
  SetConsoleCursorPosition(hStdOut, coord);
}
 
unsigned int count(const std::string &chaine, const char &caractere) {
	unsigned int combien = 0;
	for (unsigned int i = 0; i < chaine.length(); i++) {
		if (caractere == chaine[i]) combien++;
	}
 
	return combien;
}
 
unsigned short int main() {
	std::string rejouer;
 
	do {
		bool temoin = true;
		Mot alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
		std::string mot;
		do {
			std::cout << "Inscrivez un mot pour faire une partie de pendu : ";
			std::cin >> mot;
			for (unsigned int i = 0; i < mot.length(); i++) {
				if ((temoin && !alphabet.Contient(toupper(mot[i]))) || (mot.length() < 2) || (count(mot, mot[0]) == mot.length())) temoin = false;
			}
		} while (!temoin);
 
    Pendu pendu(mot);
    std::string essai;
    while(pendu.PartieTermine() == ETAT_PENDU::ENCOURS) {
    	clear();
			pendu.Affichage(AFFICHAGE::PENDU);
			pendu.Affichage(AFFICHAGE::MOTTIRETS);
			pendu.Affichage(AFFICHAGE::ALPHABET);
			std::cout << "Faire un essai : ";
			std::cin >> essai;
			pendu.UnEssai(essai[0]);
    }
    clear();
    pendu.Affichage(AFFICHAGE::PENDU);
 
    if (pendu.PartieTermine() == ETAT_PENDU::GAGNEE) {
    	std::cout << "Bravo! Le mot était bel et bien ";
    } else {
    	std::cout << "Désolé! Le mot était ";
    }
    std::cout << pendu.Get_motADeviner().Get_mot() << "." << std::endl;
 
    do {
			std::cout << "Souhaîtez vous rejouer une partie? (O/N) ";
			std::cin >> rejouer;
			rejouer = std::string(1, rejouer[0]);
			transform(rejouer.begin(), rejouer.end(), rejouer.begin(), toupper);
    } while ((rejouer != "O") && (rejouer != "N"));
    clear();
	} while (rejouer == "O");
 
	return 0;
};

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
 
//mot.h
#include <string>
#include <algorithm>
 
class Mot {
	private:
		std::string m_mot;
		std::string UCase(std::string chaine) {
			std::transform(chaine.begin(), chaine.end(), chaine.begin(), toupper);
			return chaine;
		}
 
	public:
		const std::string Get_mot() { return m_mot; }
		const unsigned int Get_len() { return m_mot.length(); }
 
		void Set_mot(std::string mot) {
			m_mot = UCase(mot);
		}
 
		Mot() {}
		Mot(const std::string &mot) { Set_mot(mot); }
 
		char Lettre(const unsigned int &position) {
			if (position < m_mot.length()) return m_mot[position];
			else return ' ';
		}
 
		void ChangerLettre(const unsigned int &position, const char &nouvLettre) { 
			if (position < m_mot.length()) m_mot.replace(position, 1, UCase(std::string(1, nouvLettre)));
		}
 
		bool Contient(const char &caractere) { return (m_mot.find(caractere) != m_mot.npos); }
 
		unsigned int Cherche(char &occurence) {
			if (Contient(occurence)) {
				return m_mot.find(occurence);
			} else {
				return 0;
			}
		}
 
		bool Comparer(Mot &mot) { return (m_mot == mot.Get_mot()); }
};

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
 
//pendu.h
#include <string>
#include <algorithm>
#include <iostream>
#include "mot.h"
 
namespace AFFICHAGE
{
	const enum AFFICHER { PENDU, MOTTIRETS, ALPHABET };
}
 
namespace ETAT_PENDU
{
	const enum STATUS_PARTIE { ENCOURS, GAGNEE, PERDUE };
}
 
class Pendu {
	private:
		Mot m_motADeviner;
		Mot m_motTirets;
		Mot m_alphabet;
		unsigned short int m_nbEssaisMax;
		unsigned short int m_noEssai;
 
	public:
		Mot Get_motADeviner() { return m_motADeviner; }
		Mot Get_motTirets() { return m_motTirets; }
		Mot Get_alphabet() { return m_alphabet; }
		unsigned int Get_nbEssaisMax() { return m_nbEssaisMax; }
		unsigned int Get_noEssai() { return m_noEssai; }
 
		void Set_mot(const std::string &mot) { m_motADeviner.Set_mot(mot); }
 
		Pendu () {}	
		Pendu(const std::string &mot)
		:	m_nbEssaisMax(5), m_noEssai(0), m_motADeviner(mot), 
			m_motTirets(std::string(mot.length(), '_')), 
			m_alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
		{
			UnEssai(m_motADeviner.Lettre(0));
		}
 
		void UnEssai(char lettre) {
			lettre = toupper(lettre);
			if ((lettre != ' ') && (m_alphabet.Contient(lettre))) {
				if (m_motADeviner.Contient(lettre)) {
					for (unsigned int i = 0; i < m_motADeviner.Get_len(); i++) {
						if (m_motADeviner.Lettre(i) == lettre) {
							m_motTirets.ChangerLettre(i, lettre);
						}
					}
				} else {
					m_noEssai++;
				}
				m_alphabet.ChangerLettre(m_alphabet.Cherche(lettre), char(' '));					
			}
		}
 
		ETAT_PENDU::STATUS_PARTIE PartieTermine() {
			if (m_motTirets.Comparer(m_motADeviner)) {
				return ETAT_PENDU::GAGNEE;
			} else if(m_noEssai == m_nbEssaisMax) {
				return ETAT_PENDU::PERDUE;
			} else {
				return ETAT_PENDU::ENCOURS;
			}
		}
 
		void Affichage(const AFFICHAGE::AFFICHER &quoi) {
			switch(quoi)
			{
				case AFFICHAGE::PENDU:
					switch(m_noEssai)
					{
						case 0:
							std::cout << "_______Pendu_______" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|   |_____        |" << std::endl;
							std::cout << "|   |/   |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |________     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "___________________" << std::endl;
							break;
						case 1:
							std::cout << "_______Pendu_______" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|   |_____        |" << std::endl;
							std::cout << "|   |/   |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |   ( )       |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |             |" << std::endl;
							std::cout << "|   |________     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "___________________" << std::endl;
							break;
						case 2:
							std::cout << "_______Pendu_______" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|   |_____        |" << std::endl;
							std::cout << "|   |/   |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |   ( )       |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |________     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "___________________" << std::endl;
							break;
						case 3:
							std::cout << "_______Pendu_______" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|   |_____        |" << std::endl;
							std::cout << "|   |/   |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |   ( )       |" << std::endl;
							std::cout << "|   |   _|_       |" << std::endl;
							std::cout << "|   |  / | \\      |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |________     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "___________________" << std::endl;
							break;
						case 4:
							std::cout << "_______Pendu_______" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|   |_____        |" << std::endl;
							std::cout << "|   |/   |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |   ( )       |" << std::endl;
							std::cout << "|   |   _|_       |" << std::endl;
							std::cout << "|   |  / | \\      |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |___/_\\__     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "|   |       |     |" << std::endl;
							std::cout << "___________________" << std::endl;
							break;
						case 5:
							std::cout << "_______Pendu_______" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|                 |" << std::endl;
							std::cout << "|   |_____        |" << std::endl;
							std::cout << "|   |/   |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |   (x)       |" << std::endl;
							std::cout << "|   |  /_|_\\      |" << std::endl;
							std::cout << "|   |    |        |" << std::endl;
							std::cout << "|   |___ | __     |" << std::endl;
							std::cout << "|   |  \\/ \\ |     |" << std::endl;
							std::cout << "|   |  \|    |     |" << std::endl;
							std::cout << "___________________" << std::endl;
					}
					break;
				case AFFICHAGE::MOTTIRETS:
					std::cout << "[Lettres trouvées]" << std::endl;
					std::cout << " -";
					for (unsigned short int i = 0; i < m_motTirets.Get_len(); i++) {
						std::cout << "--";
					}
					std::cout << " " << std::endl;
 
					std::cout << "| ";
					for (unsigned short int i = 0; i < m_motTirets.Get_len(); i++) {
						std::cout << m_motTirets.Lettre(i) <<" ";
					}
					std::cout << "|" << std::endl;
 
					std::cout << " -";
					for (unsigned short int i = 0; i < m_motTirets.Get_len(); i++) {
						std::cout << "--";
					}
					std::cout << " " << std::endl;
					break;
				case AFFICHAGE::ALPHABET:
					std::cout << "[Lettres disponibles]" << std::endl;
					std::cout << " -------------------------- " << std::endl;
					std::cout << "|" << m_alphabet.Get_mot() << "|" << std::endl;
					std::cout << " -------------------------- " << std::endl;
 
			}
	}
};

Bref, j'ai remarquer un bug, si lorsque le programme demande à l'utilisateur d'inscrire un mot et qu'il écrit des chiffres mêlés à des lettres. La boucle lui redemande d'inscrire un mot (juske là c'est OK). Mais suite à cela si il entre un mot valide (c-a-d constitué de lettres). La boucle continu. Ah... j'oubliais... on parle de cette boucle :

Code:

1
2
3
4
5
6
7
8
 
		do {
			std::cout << "Inscrivez un mot pour faire une partie de pendu : ";
			std::cin >> mot;
			for (unsigned int i = 0; i < mot.length(); i++) {
				if ((temoin && !alphabet.Contient(toupper(mot[i]))) || (mot.length() < 2) || (count(mot, mot[0]) == mot.length())) temoin = false;
			}
		} while (!temoin);

Pour faire encors plus court je crois que le bug se produit dans ces lignes :

Code:

1
2
3
4
 
			for (unsigned int i = 0; i < mot.length(); i++) {
				if ((temoin && !alphabet.Contient(toupper(mot[i]))) || (mot.length() < 2) || (count(mot, mot[0]) == mot.length())) temoin = false;
			}

Donc, je patauge, p-e demain je vais y voir plus clair sur ce nenuit :)

Puah! Une erreure tout bête, un oubli ^_^
dans ça :

Code:

1
2
3
4
5
6
7
8
9
 
 
      do {
         std::cout << "Inscrivez un mot pour faire une partie de pendu : ";
         std::cin >> mot;
         for (unsigned int i = 0; i < mot.length(); i++) {
            if ((temoin && !alphabet.Contient(toupper(mot[i]))) || (mot.length() < 2) || (count(mot, mot[0]) == mot.length())) temoin = false;
         }
      } while (!temoin);

Je devait ajouter : temoin = true; apres le do

Code:

1
2
3
4
5
6
7
8
9
10
 
 
      do {
         temoin = true;
         std::cout << "Inscrivez un mot pour faire une partie de pendu : ";
         std::cin >> mot;
         for (unsigned int i = 0; i < mot.length(); i++) {
            if ((temoin && !alphabet.Contient(toupper(mot[i]))) || (mot.length() < 2) || (count(mot, mot[0]) == mot.length())) temoin = false;
         }
      } while (!temoin);

05/11/2005, 19h14
petitedouceur

Rebonjour!!! Voilà j'ai eu quelques problemes avec mon pc et je suis de retour :D... sauf que là je voulais esseyer gcc (downloader à l'aide de delorie)... bref il est installer et tout et là j'arrive pour compiler mon pendu et je recois cette erreur

Citation:

E:\DVELOP~1\C__~1\pendu>gxx main.cpp
pendu.h:9: error: qualifiers can only be specified for objects and functions
pendu.h:14: error: qualifiers can only be specified for objects and functions

Bah, je me demandais ce que cela signifiait o_O
Voici les lignes de codes de 1 à 14

Citation:

//main.cpp
#include <iostream>
#include <string>
#include "pendu.h"

unsigned int count(const std::string &chaine, const char &caractere) {
unsigned int combien = 0;
for (unsigned int i = 0; i < chaine.length(); i++) {
if (caractere == chaine[i]) combien++;
}

return combien;
}

Par le fait même, j'ai remarquer qu'il n'y avais pas de librarie sock ou winsock2 cela veux-t-il dire qu'il me faut aller les downloader par moi-même?
05/11/2005, 21h51
Médinoc

les erreurs sont dans pendu.h, pas dans pendu.c... :roll:
05/11/2005, 22h35
Le Bisounours

Bonjour,

Je n'ai pas spécialement regardé ton code, mais pour le C++, tu devrais plutôt utiliser g++ qui est inclu dans l'installation de gcc (normalement).

Cordialement,
Bisounours.
06/11/2005, 00h48
petitedouceur

Citation:

Envoyé par Médinoc

les erreurs sont dans pendu.h, pas dans pendu.c... :roll:

lol ctait pas fort ^^!

je viens de toruver mon erreur, elle était dans le fait que j'appelais un name space identique dans deux fichiers...