Discussion :

[petitedouceur]

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 :

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
#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

[David Fleury]

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

Code :

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

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 :

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

1
2
 
#include <iostream.h>

remplacé par

Code :

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

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

[zoubidaman]

Ma version avec des std::string:

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

[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.

[petitedouceur]

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++

[petitedouceur]

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 :

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
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.

[zoubidaman]

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

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
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...

[petitedouceur]

Merci, je vais étudier ce dont tu m'a fait pars ... des que j'aurais une minute ^_^

[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 :

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

void Set_mot(string mot)

devrait être remplacé par

Code :

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

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 :

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

string Get_mot(void)

devient

Code :

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

const string & Get_mot(void) const

[petitedouceur]

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?

[Médinoc]

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

[petitedouceur]

zoubidaman >> pourrais-tu m'expliquer l'utiliter de ce namespace :

Code :

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

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

[petitedouceur]

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

[zoubidaman]

zoubidaman >> pourrais-tu m'expliquer l'utiliter de ce namespace :

Code :

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

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 :

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

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 :

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
//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 :

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
//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 :

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

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 :

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

using std::string;

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

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 :

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

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

Ps merci encore une fois

De rien

[petitedouceur]

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 :

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
 
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 :

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
 
#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 :

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

[zoubidaman]

Code :

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

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

Et voici le début de
main.cpp

Code :

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

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 :

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 :

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

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!

Code :

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

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...

[zoubidaman]

Code :

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

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 :

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

[petitedouceur]

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)

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.

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

Quand on écrit :

Code :

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

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???

/*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

//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,

[julien.sagnard]

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 ?

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 ?

(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

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.

[petitedouceur]

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