petit souci expected

**spiranenc** · 16/08/2011, 16h02

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.

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

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

Code :

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

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 :

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

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 :

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

**Médinoc** · 16/08/2011, 16h19

Un tel message me fait penser à un nombre d'accolades ouvrantes/fermantes incorrect.

**3DArchi** · 16/08/2011, 16h55

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)

**3DArchi** · 16/08/2011, 17h06

J'arrive à reproduire ton erreur ... en enlevant le main

int main(int argc, char *argv[]), c'est pas facultatif pour mettre ton programme dedans

Allez j'ose : c'est ou ça ou ça.

**spiranenc** · 16/08/2011, 18h54

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

**3DArchi** · 16/08/2011, 19h51

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 :

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

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

puis tout ton 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
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 :

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

et ça devrait compiler.

petit souci expected

C++

Vue hybride

Discussions similaires

Partager

Partager