petit souci expected

Version imprimable

Bonjour

Avant tout, il faut que je vous dise que je suis un apprenti "CPPlusseur", apprenti des premiers jours ou de la dernière pluie comme vous l'entendrez.

J'apprends par un tuto qui me propose un petit TP qui m'a fait transpirer à grosse goutte. Le tuto donne la solution et propose d'améliorer à notre convenance cet exercice. Dont acte.

Mon programme fonctionnant très bien, je me suis décidé à le moduler et placer mes fonctions dans une classe ".h et .cpp". Houlala quelle drôle d'idée j'ai eu là. A force de chercher et fouiller partout, j'ai réussi à régler presque tous les problèmes sauf un. celui-ci qui s'affile lors de la compilation.

Citation:

expected constructor, destructor, or type conversion '::' token

et ce problème il me le souligne sur la ligne

Code:

return

du main.

Je suis sous Qt Creator qui m'a fait à la création du projet une page main de cette manière.

Code:

1
2
3
4
5
6
7
8
9
10
 
#include <QtCore/QCoreApplication>
 
int main(int argc, char *argv[])//Lancement du programme
{
    QCoreApplication a(argc, argv);
 
 
  return a.exec();// C'est sur cette ligne qu'il coince...
 }

J'ai cherché sur pas mal de forums ce genre de prob. J'ai trouvé presque à l'identique, mais seulement presque. j'ai beau chercher je ne vois pas de '::' dans le message d'erreur. Entre les apostrophes il y a de tout sauf mes deux points de suspensions accolés.

Le code du main est ci-dessous (il est plutôt long). Quelqu'un de plus instruit que moi dans ce langage, et c'est plutôt du genre très, mais alors très, très, très facile, saurait-il me dire ce qui se passe...

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
 
  QCoreApplication a(argc, argv);
 
MaClasse appelClasse;
 
        /*
    transform(s.begin(), s.end(), s.begin(), my_tolower()); //Commande pour convertir les mots ou lettres en minuscules
       cout << s; // affiche "abcdef"
 
    transform(s.begin(), s.end(), s.begin(), my_toupper());//Commande pour convertir les mots ou lettres en majuscules
       cout << s; // affiche "ABCDEF"
*/
 
    /************************************************************************************************************/
    /* DECLARATION DES VARIABLES */
    /************************************************************************************************************/
    char rejouer;
    string  leMot, leMotMelange, motUtilisateur, joueur, pourIndice ;
    int compteurRejouer(0), compteurTrouveMot(0);
    unsigned int numeroLigne; //un entier non signé pour être sûr qu'on puisse atteindre les 300 000 mots, voir plus avec un dico modifié...
    vector <string> tableauDico; //Un tableau dynamique pour stocker tous les mots du dicos (plus de 300000 !!!!)
    vector <string> tableauPhrases; //Un tableau dynamique pour stocker tous les phrases à choisir pour répondre toutes les fois que le joueur à faux
    string ligne; //Pour récupérer chaque ligne
 
    /************************************************************************************************************/
    /*   INITIALISER  LE GENERATEUR DE NOMBRE ALEATOIRE*/
    /************************************************************************************************************/
    srand(time(NULL));
 
    /************************************************************************************************************/
    /*  COMMENCE LE PROGRAMME  */
    /************************************************************************************************************/
    cout << "Ah que c'est quoi ton prenom mec ? " << endl;
    cin >> joueur;
    transform(joueur.begin(), joueur.end(), joueur.begin(), my_toupper());//Met le nom en majuscule
    cout  << "C'est ca ton prenom ? " << joueur <<" ! ! !  Phfffffffffooooouuuuu Wouaaaaaaa ha ha ha ha ha ha !  \nBon c'est pas grave, on va faire avec hein... Bien oblige de toute facon..." << endl;
 
    /************************************************************************************************************/
    /* OUVERTURE DU FICHIER  TEXTE*/
    /************************************************************************************************************/
    ifstream dico("dico.txt");
 
/************************************************************************************************************/
/*   RECUPERATION DE TOUTES LES LIGNES DU FICHIER TEXTE DANS UN TABLEAU  */
/************************************************************************************************************/
if (dico) //La condition pour le cas où il n'y aurait pas de fichier texte
     {
         while (getline(dico,ligne))
             {
                 tableauDico.push_back(ligne); //On met les lignes dans le tableau.
             }
 
         /************************************************************************************************************/
        /*  BOUCLE  POUR DONNER LA POSSIBLITE AU JOUR DE REJOUER S'IL LE DESIRE  */
        /************************************************************************************************************/
         do
            {
 
                /************************************************************************************************************/
                /* COMPTE LE NOMBRE DE FOIS QUE LE JOUEUR REJOUE*/
                /************************************************************************************************************/
                compteurRejouer ++;
                compteurRejouer -= 1;
                /************************************************************************************************************/
                /* RECUPERER  UN MOT DANS LE TABLEAU  */
                /************************************************************************************************************/
                // Récupérer un mot aléatoire du tableau
                numeroLigne = rand () % tableauDico.size(); //Choisir un numéro au hasard plus petit que la taille du tableau.
                leMot = tableauDico[numeroLigne]; //On met dans mot, le mot trouvé dans le tableau à la case numéroLigne.
                transform(leMot.begin(), leMot.end(), leMot.begin(), my_toupper());//Met le mot en majuscule
 
                /************************************************************************************************************/
                /* MELANGER LES LETTRE  */
                /************************************************************************************************************/
                leMotMelange = appelClasse.melangeLeMot(leMot);//Mélange le mot
 
                /************************************************************************************************************/
                /* MET EN PLACE LES TIRETS POUR LES INDICES  */
                /************************************************************************************************************/
                pourIndice = appelClasse.donneDesIndices(leMot);
 
                /************************************************************************************************************/
                //DEMANDE AU JOUEUR DE REMETTRE EN PLACE LES LETTRES DU MOT A TROUVER  */
                /************************************************************************************************************/
                cout << "\nBon allez au boulot " << joueur << "  Remets-moi ce mot en place stp  << " << leMotMelange << " >>" << endl;
                cin >> motUtilisateur;
 
                /************************************************************************************************************/
                /* BOUCLE  DE COMPARAISON DU MOT A TROUVER ET REJOUER TANT QUE LE JOUEUR NE L'AURA PAS TROUVE */
                /************************************************************************************************************/
                do
                    {
                        /************************************************************************************************************/
                        /* COMPTE EN COMBIEN DE COUPS LE MOT SERA TROUVE*/
                        /************************************************************************************************************/
                        compteurTrouveMot++;
 
                        /************************************************************************************************************/
                        /* MET LE MOT EN MAJUSCULE*/
                        /************************************************************************************************************/
                        transform(motUtilisateur.begin(), motUtilisateur.end(), motUtilisateur.begin(), my_toupper());//Met le mot en majuscule
 
                       /************************************************************************************************************/
                       /*  SI LE MOT EST TROUVE */
                       /************************************************************************************************************/
                        if (motUtilisateur == leMot)
                            {
                                cout << "\nOuais super " << joueur <<  " ! C'est bien le mot qu'il fallait trouver" << endl;
                                cout << " Bon qu'est-ce que tu veux faire ? Tu rejoues ? O/N" << endl;
                                cin >> rejouer;
                            }
 
                        /************************************************************************************************************/
                        /* SI LE MOT N'EST PAS TROUVE */
                        /************************************************************************************************************/
                        else
                            {
                                string laPhrasesChoisie;
                                int numeroPhrase(0);
                                string  lettreAAfficher;
                                /************************************************************************************************************/
                                /* OUVERTURE DU FICHIER  TEXTE DANS LEQUEL LE PROGRAMME TROUVERA
                                    QUELQUES PHRASES NEGATIVES  A AFFICHER AU HAZARD*/
                                /************************************************************************************************************/
                                ifstream dicoPhrases("PhrasesChoisies.txt");
 
                                /************************************************************************************************************/
                                /*   RECUPERATION DE TOUTES LES LIGNES DU FICHIER TEXTE DANS UN TABLEAU  */
                                /************************************************************************************************************/
                                if (dicoPhrases) //La condition c'est pour le cas où il n'y aurait pas de fichier texte
                                     {
                                            while (getline(dicoPhrases,ligne))//Tant que trouve des lignes
                                                {
                                                    tableauPhrases.push_back(ligne); //les copier dans le tableau.
                                                }
 
                                            /************************************************************************************************************/
                                            /* RECUPERER  UNE PHRASE DANS LE TABLEAU  */
                                            /************************************************************************************************************/
                                            // Récupérer une phrase aléatoire du tableau
                                            numeroPhrase = rand () % tableauPhrases.size(); //Choisir un numéro au hasard plus petit que la taille du tableau.
                                            laPhrasesChoisie = tableauPhrases[numeroPhrase]; //et placer la phrase qui se trouve à cet emplacemet, dans la variable "laPhraseChoisie"
 
                                        }
                                else
                                        {
                                        cout << "Je ne peux pas ouvrir le fichier << PhrasesChoisies >>, je ne le trouve pas ";// Si le fichiers des phrases choisies ne se trouve pas dans le bon répertoire
                                                                                                                                                                 // ou s'il a disparu, le prog l'affiche.
                                        }
 
                        int const nbLettreDansMot(leMot.size());
 
                        if (nbLettreDansMot == compteurTrouveMot)
                                {
                                    cout << "Perdu il n'y a plus de lettres dans le mot a trouver" << endl;
                                    cout << "Le mot a trouver etait " << leMot << endl;
                                    cout << " Bon qu'est-ce que tu veux faire ? Tu rejoues ? O/N" << endl;
                                    cin >> rejouer;
                                    compteurTrouveMot = 0;//Réinitialise ce compteur
                                    break;
                                }
                        else
                                    {
                                        /************************************************************************************************************/
                                        /*  AFFICHE POUR LE JOUEUR  SON MAUVAIS CHOIX ET  L'INVITE A REFAIRE UN NOUVEAU CHOIX */
                                        /************************************************************************************************************/
                                        cout << laPhrasesChoisie << "  ";
                                        cout << endl << "Allez !  Recommence..." << "  << " <<  leMotMelange << " >>"  << endl;
                                        cout << "\nTiens pour t'aider un brin, voici un indice... " ;
 
                                        lettreAAfficher= appelClasse.choixLettreIndice(leMot, leMotMelange, pourIndice);//Va chercher une nouvelle lettre pour aider le joueur
                                        pourIndice = lettreAAfficher;// "pourIndice" doit prendre la configuration actuelle pour le prochain coup
                                        cout << " << "  << lettreAAfficher << " >> en " << appelClasse.emplacementTirets << endl;//Affiche les tirets ainsi que la nouvelle lettre comme aide pour trouver le mot
                                        cout  << endl << "Nombre de coups : [ " << compteurTrouveMot << " ]" <<  endl;
                                        cin >> motUtilisateur;
                                    }
 
                        }
 
                /************************************************************************************************************/
                /*  FIN DE LA BOUCLE DE COMPARAISON DU MOT */
                /************************************************************************************************************/
                }while (motUtilisateur != leMot);
 
        /************************************************************************************************************/
        /* FIN DE A BOUCLE  REJOUER */
        /************************************************************************************************************/
        }while  (rejouer  == 'o');//Tant que le joueur veut rejouer alors on continue
 
        cout << endl << "\nAlors si tu veux plus jouer bye  "  << joueur << " !" << endl;// Fin du jeu
     }
else
    {
        cout << " \n\nJe ne trouve pas le fichier  (dico.txt) " << endl;
    }
 
 
    return a.exec();// C'est ici que le pro en compilant coince...

Par avance je vous remercie.

16/08/2011, 16h19
Médinoc

Un tel message me fait penser à un nombre d'accolades ouvrantes/fermantes incorrect.
16/08/2011, 16h55
3DArchi

1er conseil : redécoupe car il y a jusqu'à 7 niveaux d'imbrications. Je comprends que toi et ton compilateur ayez du mal à vous entendre.

2ème conseil : une fois cela fait, reposte ton main.cpp en entier. Car là où tu as bêtement oublié main() ou tu n'as copié/collé que son corps mais il n'y a pas de problème de compilation (d'autres choses, mais on verra ensuite)
16/08/2011, 17h06
3DArchi

J'arrive à reproduire ton erreur ... en enlevant le main :aie:
int main(int argc, char *argv[]), c'est pas facultatif pour mettre ton programme dedans :roll:

Allez j'ose : c'est ou ça ou ça.
16/08/2011, 18h54
spiranenc

Merci Medinoc et 3Darchi pour vos réponses.

J'avais déjà vérifié aussi minutieusement qu'un néophyte peut le faire, les accolades, les parenthèses et les points virgules.
Ce programme tel quel, fonctionnait bien avec un fichier .h, un fichier cpp du même nom et le main cpp.

Mon souci est apparu tel des nuages d'orage dans un ciel pur à partir du moment où j'ai eu cette idée vaguement saugrenue de me frotter à une classe.

J'ai gentiment viré le fichier .h et le cpp correspondant, au préalablement vidés de leur contenu et recopiés dans les fichiers de la classe fraîchement arrivée.

Bien sûr que j'ai eu monstres problèmes qui sont apparus. A force de persévérance, de probité et de travail, pas moins de quatre jours pour y arriver, j'ai finit par les kouiker tous un par un. Tous ? Pas vraiment puisqu'il me reste celui-ci que je vous ai exposé.

3DArchi, évidemment que tu peux te permettre d'oser, ayant osé moi même il y a quelque temps déjà sur le lien que tu mets dans "ça".

Quant à la définition de l'acide acétylsalicylique, je la connais depuis belle lurette, tu penses bien. On avance pas dans la vie sans en connaître ses bienfaits, bien qu'aujourd'hui, je lui préfère les propriétés de certaines huiles essentielles telle celle de la menthe poivrée qui est à mon sens, plus efficace et moins agressive. mais c'est un avis qui n'engage que moi.

Le redécoupage de mon prog... Ayayayayaïe ! Pour faire ça il faut que je revienne en arrière et le remette en l'état de son fonctionnement de naguère. Puis que je me creuse salement les méninges pour voir comment faire ça.
En fait, et c'est là tout le secret, comme je suis en découverte de ce langage, quand j'ai réussi ce miracle d'une routine fonctionnelle, (alléluia !) je passe à une autre tout simplement sans avoir de plans préconçus. Voilà pourquoi il se trouve que mon programme s'imbrique et encore et encore.

Il est évident que si "ma" création est allergique à la fonction présidentielle main elle est mal barrée. La question tout de même qui me turlupine très beaucoup, et cela ne m'empêchera pas de redécouper le code, c'est le pourquoi de ce souci avec une classe .h et .cpp alors qu'avec un fichier .h et un autre .cpp ordinaire il n'y en a pas... Mmmmm...

Présentement, dans le code que tu proposes, il suffit de rajouter :
les différentes directives d'inclusions (vector, string, iostream, fstream, algorithm, maclasse.h, les cochonneries de Qt, cmath, ctime), quelques using std::vector et autres ou un malheureux using namespace std, puis:

Code:

1
2
int main(int argc, char *argv[])
{

puis tout ton 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
QCoreApplication a(argc, argv);
 
MaClasse appelClasse;
 
        /*
    transform(s.begin(), s.end(), s.begin(), my_tolower()); //Commande pour convertir les mots ou lettres en minuscules
       cout << s; // affiche "abcdef"
 
    transform(s.begin(), s.end(), s.begin(), my_toupper());//Commande pour convertir les mots ou lettres en majuscules
       cout << s; // affiche "ABCDEF"
*/
 
    /************************************************************************************************************/
    /* DECLARATION DES VARIABLES */
    /************************************************************************************************************/
    char rejouer;
    string  leMot, leMotMelange, motUtilisateur, joueur, pourIndice ;
    int compteurRejouer(0), compteurTrouveMot(0);
    unsigned int numeroLigne; //un entier non signé pour être sûr qu'on puisse atteindre les 300 000 mots, voir plus avec un dico modifié...
    vector <string> tableauDico; //Un tableau dynamique pour stocker tous les mots du dicos (plus de 300000 !!!!)
    vector <string> tableauPhrases; //Un tableau dynamique pour stocker tous les phrases à choisir pour répondre toutes les fois que le joueur à faux
    string ligne; //Pour récupérer chaque ligne
 
    /************************************************************************************************************/
    /*   INITIALISER  LE GENERATEUR DE NOMBRE ALEATOIRE*/
    /************************************************************************************************************/
    srand(time(NULL));
 
    /************************************************************************************************************/
    /*  COMMENCE LE PROGRAMME  */
    /************************************************************************************************************/
    cout << "Ah que c'est quoi ton prenom mec ? " << endl;
    cin >> joueur;
    transform(joueur.begin(), joueur.end(), joueur.begin(), my_toupper());//Met le nom en majuscule
    cout  << "C'est ca ton prenom ? " << joueur <<" ! ! !  Phfffffffffooooouuuuu Wouaaaaaaa ha ha ha ha ha ha !  \nBon c'est pas grave, on va faire avec hein... Bien oblige de toute facon..." << endl;
 
    /************************************************************************************************************/
    /* OUVERTURE DU FICHIER  TEXTE*/
    /************************************************************************************************************/
    ifstream dico("dico.txt");
 
/************************************************************************************************************/
/*   RECUPERATION DE TOUTES LES LIGNES DU FICHIER TEXTE DANS UN TABLEAU  */
/************************************************************************************************************/
if (dico) //La condition pour le cas où il n'y aurait pas de fichier texte
     {
         while (getline(dico,ligne))
             {
                 tableauDico.push_back(ligne); //On met les lignes dans le tableau.
             }
 
         /************************************************************************************************************/
        /*  BOUCLE  POUR DONNER LA POSSIBLITE AU JOUR DE REJOUER S'IL LE DESIRE  */
        /************************************************************************************************************/
         do
            {
 
                /************************************************************************************************************/
                /* COMPTE LE NOMBRE DE FOIS QUE LE JOUEUR REJOUE*/
                /************************************************************************************************************/
                compteurRejouer ++;
                compteurRejouer -= 1;
                /************************************************************************************************************/
                /* RECUPERER  UN MOT DANS LE TABLEAU  */
                /************************************************************************************************************/
                // Récupérer un mot aléatoire du tableau
                numeroLigne = rand () % tableauDico.size(); //Choisir un numéro au hasard plus petit que la taille du tableau.
                leMot = tableauDico[numeroLigne]; //On met dans mot, le mot trouvé dans le tableau à la case numéroLigne.
                transform(leMot.begin(), leMot.end(), leMot.begin(), my_toupper());//Met le mot en majuscule
 
                /************************************************************************************************************/
                /* MELANGER LES LETTRE  */
                /************************************************************************************************************/
                leMotMelange = appelClasse.melangeLeMot(leMot);//Mélange le mot
 
                /************************************************************************************************************/
                /* MET EN PLACE LES TIRETS POUR LES INDICES  */
                /************************************************************************************************************/
                pourIndice = appelClasse.donneDesIndices(leMot);
 
                /************************************************************************************************************/
                //DEMANDE AU JOUEUR DE REMETTRE EN PLACE LES LETTRES DU MOT A TROUVER  */
                /************************************************************************************************************/
                cout << "\nBon allez au boulot " << joueur << "  Remets-moi ce mot en place stp  << " << leMotMelange << " >>" << endl;
                cin >> motUtilisateur;
 
                /************************************************************************************************************/
                /* BOUCLE  DE COMPARAISON DU MOT A TROUVER ET REJOUER TANT QUE LE JOUEUR NE L'AURA PAS TROUVE */
                /************************************************************************************************************/
                do
                    {
                        /************************************************************************************************************/
                        /* COMPTE EN COMBIEN DE COUPS LE MOT SERA TROUVE*/
                        /************************************************************************************************************/
                        compteurTrouveMot++;
 
                        /************************************************************************************************************/
                        /* MET LE MOT EN MAJUSCULE*/
                        /************************************************************************************************************/
                        transform(motUtilisateur.begin(), motUtilisateur.end(), motUtilisateur.begin(), my_toupper());//Met le mot en majuscule
 
                       /************************************************************************************************************/
                       /*  SI LE MOT EST TROUVE */
                       /************************************************************************************************************/
                        if (motUtilisateur == leMot)
                            {
                                cout << "\nOuais super " << joueur <<  " ! C'est bien le mot qu'il fallait trouver" << endl;
                                cout << " Bon qu'est-ce que tu veux faire ? Tu rejoues ? O/N" << endl;
                                cin >> rejouer;
                            }
 
                        /************************************************************************************************************/
                        /* SI LE MOT N'EST PAS TROUVE */

puis

Code:

}

et ça devrait compiler.

16/08/2011, 20h41
spiranenc

Merci Archi pour ton aide. En fait j'ai fait la bêtise de ne poster que l'intérieur du main.
Tous les includes que tu cites plus quelques autres, ainsi qu'un using namespace std, sont présent dans le fichier ainsi que le main bien sûr avec ses accolades.
En fait tout y est, mais j'ai cette erreur.
Enfin pour l'instant j'en suis à ce que tu m'as demandé, le découpage, et effectivement cela réduit le main singulièrement. Je le posterai quand j'en aurai terminé. Demain sûrement.

Merci encore pour ton attention et bonne soirée.

Bonjour,
Comme promis voici mon main découpé

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
 
#include <QtCore/QCoreApplication>
#include "maclasse.h"
 
using namespace std;
 
 
 
 
/************************************************************************************************************/
/* FONCTION QUI CONVERTIT UN MOT EN MINUSCULE */
/************************************************************************************************************/
struct my_tolower // Converti en minuscule
{
    char operator()(char c) const
    {
        return tolower(static_cast<unsigned char>(c));
 
    }
};
 
/************************************************************************************************************/
/* FONCTION QUI CONVERTIT UN MOT EN MAJUSCULE */
/************************************************************************************************************/
struct my_toupper//Converti en majuscule
{
    char operator()(char c) const
    {
        return toupper(static_cast<unsigned char>(c));
    }
};
 
 
 
 
int main(int argc, char *argv[])//Lancement du programme
{
    QCoreApplication a(argc, argv);
 
 
    /************************************************************************************************************/
    /* DECLARATION DES VARIABLES */
    /************************************************************************************************************/
        int compteurRejouer(0), nbCoups(0) ;
        string leMotMelange, motIndice,  leMot,  joueur;
 
    /************************************************************************************************************/
    /*   INITIALISER  LE GENERATEUR DE NOMBRE ALEATOIRE*/
    /************************************************************************************************************/
        srand(time(NULL));
 
    /************************************************************************************************************/
    /*  COMMENCE LE PROGRAMME  */
    /************************************************************************************************************/
        cout << "Ah que c'est quoi ton prenom mec ? " << endl;
        cin >>  joueur;
        transform(joueur.begin(), joueur.end(), joueur.begin(), my_toupper());//Met le nom en majuscule
        cout  << "C'est ca ton prenom ? " << joueur <<" ! ! !  Phfffffffffooooouuuuu Wouaaaaaaa ha ha ha ha ha ha !  \nBon c'est pas grave, on va faire avec hein... Bien oblige de toute facon..." << endl;
 
        /************************************************************************************************************/
        /*  BOUCLE DE REJOUER */
        /************************************************************************************************************/
            do
                {
                    /************************************************************************************************************/
                    /* COMPTE LE NOMBRE DE FOIS QUE LE JOUEUR REJOUE*/
                    /************************************************************************************************************/
                        compteurRejouer ++;
 
                    /************************************************************************************************************/
                    /* VA CHERCHER UN MOT DANS LE FICHIER TEXTE */
                    /************************************************************************************************************/
                        leMot = ouvertureFichierTexte("dico.txt");// Va chercher un mot dans le fichier texte
                        transform(leMot.begin(), leMot.end(), leMot.begin(), my_toupper());//Met le mot en majuscule
 
                       //////////////////////////////////////////////
                       cout<< leMot <<endl;//Pour que je puisse faire des essais/
                       //////////////////////////////////////////////
 
                    /************************************************************************************************************/
                    /* MELANGER LES LETTRE  */
                    /************************************************************************************************************/
                        leMotMelange = melangeLeMot(leMot);//Mélange le mot
 
                    /************************************************************************************************************/
                    /* MET EN PLACE LES TIRETS POUR LES INDICES  */
                    /************************************************************************************************************/
                        motIndice = metLesTirets(leMot);
 
                    /************************************************************************************************************/
                    /* COMMENCE  LE JEU POUR LE JOUEUR*/
                    /************************************************************************************************************/
                        debutJeu(leMot, joueur, leMotMelange, motIndice);
 
                }while(continuer() == 1);   // Tant que l'utilisateur veut jouer
 
       /************************************************************************************************************/
        /* FIN DU JEU */
        /************************************************************************************************************/
            cout << endl << "\nAlors si tu veux plus jouer bye  "  << joueur << " !" << endl;// Fin du jeu
 
            return a.exec();
 }

Ben euh... Je n'ai plus de problèmes avec le compilateur... J'ai eu du mal mais bon en cherchant et en regardant comment font les autres on finit par s'arranger un peu au fur et à mesure...
Maintenant j'ai tout de même un petit problème avec ma routine rejouer ou non. La voici

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
int continuerOuArreter()
                {
                    int reponseUtilisateur;
 
                    do
                        {
                            cout << " 1 = Continuer  /   2 = Quitter " << endl;
                            cin >> reponseUtilisateur;
                            cout << endl << endl;
                            if(reponseUtilisateur  != 1 || reponseUtilisateur != 2)
                                {
                                    effacer_ecran();
                                    cout << "Tu as saisis une mauvaise lettre,  il ne faut que, soit 1, soit 2 " << endl;
                                    cout << " '1' pour oui je veux continuer à jouer" << endl;
                                    cout << "'2' pour non je veux arreter de jouer." << endl << endl << endl;
                                }
                        }while(reponseUtilisateur  != 1 || reponseUtilisateur != 2); // Tant que l'utilisateur met n'importe quoi comme lettre ou chiffre
 
                    return reponseUtilisateur;
                }

En fait, elle ne répond pas à priori. ni à 1 ni à 2... J'ai du zapper un truc... Merci pour votre aide. De mon côté je continue à me plonger dans des recherches intensives afin d'essayer de comprendre le truc...

19/08/2011, 07h13
Médinoc

Tout le monde fait cette erreur un jour ou l'autre:

reponseUtilisateur != 1 || reponseUtilisateur != 2 est toujours vrai: si c'est égal à l'un, c'est différent de l'autre.
19/08/2011, 11h27
spiranenc

Merci Medinoc. En remplaçant "||" par des "&&" ça fonctionne super parfaitement.
Connais-tu, car je fouille mais ne trouve pas, et après ce post je reprends mes fouilles intensives, s'il y a une commande en C++ qui rivalise et même la dépasse avec celle en VB de "space()" pour ajouter un certain nombre d'espaces.
En VB tu fais space(15) et hop 15 espaces sont ajoutés. C'est obligé qu'en C++ cette commande existe, obligé... Sinon je serais tellement déçu du C++...

Merci pour ton aide et l'aide de tout un chacun d’ailleurs, car sinon les débutants de mon genre n'iraient pas très vite sur ce chemin parsemé d'embuches. Sentier surveillé de près par un compilateur qui se plait à loisir de nous faire trébucher et nous faire tout un plat pour de si de minuscules erreurs de parcours. Phffffffffff ! C'est petit de la part du compilateur...
19/08/2011, 12h00
3DArchi

Citation:

Envoyé par spiranenc

Connais-tu, car je fouille mais ne trouve pas, et après ce post je reprends mes fouilles intensives, s'il y a une commande en C++ qui rivalise et même la dépasse avec celle en VB de "space()" pour ajouter un certain nombre d'espaces.
En VB tu fais space(15) et hop 15 espaces sont ajoutés. C'est obligé qu'en C++ cette commande existe, obligé... Sinon je serais tellement déçu du C++...

Un déception qui pourrait se transformer en émerveillement :

Code:

std::cout<<std::string(12,' ')<<"\n";

on triche en insérant une chaine de caractère (std::string) faite de n fois (ici 12) le même caractère (ici ' ', l'espace).
Changeable à loisir :

Code:

std::cout<<std::string(42,'X')<<"\n";

pour avoir 42 'X' :aie:
19/08/2011, 12h00
JolyLoic

Code:

cout << "a" << string(15, ' ') << "b";

Mais pour gérer un affichage aligné,il y a des fonctions spécialisées.
19/08/2011, 17h35
spiranenc

Merci Archi et Loic pour vos réponses.
Effectivement je ne suis pas déçu, car cette commande est plus souple que le "space()" de VB. J'en prend note, merci Archi.
En fait comme mon prog de TP fonctionne je voulais juste améliorer le visuel comme cela était encore au temps du Dos. Temps que les moins de vingt ans ne peuvent pas connaitre (dixit Charles Aznavour).

Créer une routine qui va entourer d'étoiles les demandes ou remarques très pertinentes du programme au joueur. genre :

une demande parfaitement justifiée pour lancer le programme :

***********************
* Comment tu t'appelles ? *
***********************

ou une remarque des plus pertinentes qui fait avancer les choses :

**************************
* quel drôle de prénom tu as... *
**************************

Donc sans connaitre la formule magique, je me suis débrouillé pour que ma routine fonctionne, ce qui n'était pas très compliqué en somme. (c'est que je deviens vachement bon en C++ basique du ras des paquerettes)
Évidemment l'on pourra toujours améliorer cette petite routine, mais pour l'instant cela fonctionne.

Somme toute ce petit TP m'aura moins fait transpirer qu'il ne m'aura appris plein de choses.

Merci pour votre "bénévolat" (enfin je suppose) sur ce forum, votre attention méritante auprès des "Cplusseur" comme moi, et vos réponses finalement judicieuses puisque le néophyte s'y retrouve dans l'ensemble. Du moins sur ce coup, c'est mon cas, mais je pense que pour les autres c'est itou - idem. Post résolu
19/08/2011, 17h51
3DArchi

Citation:

Envoyé par spiranenc

....

L'affamé néophyte peut toujours fouiner dans nos pages tutoriels et/ou picorer dans la F.A.Q..
19/08/2011, 19h03
spiranenc

Merci 3DArchi pour ces liens, dont sois-en sûr, je vais faire miens afin de peaufiner et affuter ma connaissance vachement heu.. Gr... quelque chose... Non pas grande, je n'ai point cette prétention, mais grotesque, oui c'est ça grotesque.
Parce que tout ce que je lis, et je te cause pas les lignes que j'ai avalé en quelques semaines, ne m'est pas utile systématiquement et immédiatement. Si je ne m'en sers pas, cela devient automatiquement du "gros texte" qui se digère mal et qui ne laisse que quelques soupçons mnémoniques de :
Tiens j'ai vu ça quelque part...
Mais où ????
Et comment le retrouver ?
Quels termes employés pour ?

C'est pourquoi, sois-en sûr aussi, ma certitude d'un retour sur ces forums à plus ou moins, non pas longs termes, mais très courts termes. Je perçois dans cet avenir proche, de bêtes questions posées par moi même.

De ces questions qui vous feront douter sérieusement, de mes aptitudes passées touchant mes cours de lecture en CP, voire peut-être même sur ma présence en ces cours.
Peut-être aussi vous direz-vous, que la dégénérescence du mon cerveau favorise ce côté aphasique, genre aussitôt lu aussitôt oublié et dont l'âge, le trou dans la couche d'ozone, et l'abrutissement publicitaire en sont les seules véritables raisons.
Mais bast ! Qu'à cela ne tienne ! Je reviendrai, la question au bout des doigts, le cerveau en compote, effleurer par écrans interposés, toutes les richesses de vos connaissances.
A bientôt... sûrement... et... Par avance un grand merci...