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