Discussion :

[Armulis]

Bonjour tout le monde!

J'ai un... problème =D

J'ai décidé de réécrire un petit programme qui fonctionnait parfaitement (jusqu'à ce que je le modifie à-moitié sans créer de sauvegarde, tout ça ^^).

Bon, en gros mon programme contient a une structure comme suit (pas d'inquiétude, je vous donne aussi le code plus bas):

Main:
- Affiche un "Chargement en cours" bidon.
- Appelle la fonction "MenuAccueil".
À terme, le "Chargement en cours" sera remplacé par le logo de ma boîte (parce que oui, j'aurai ma boîte... un jour ^^).

MenuAccueil:
- Affiche le titre du jeu, et propose les quatre possibilités suivantes: A Jeu, B Meilleur score, C Crédits, D Quitter.
- L'utilisateur doit entrer la lettre qu'il veut (majuscules et minuscules sont prises en compte) pour accéder aux différentes possibilités. Quand le choix a été fait, "MenuAccueil" appelle d'autres fonctions.
- Pour l'instant, les fonctions que "MenuAccueil" doit appeler sont vides, et elles devraient seulement ne rien faire, logiquement.

Mon problème, c'est que j'ai demandé à ce que ma fonction "MeilleurScore" (qu'on appelle via le menu d'accueil) affiche "Bonjour!" pour voir si ça marchait.
Que dalle, ça affiche le menu d'accueil en boucle sans dire bonjour!

Je me suis demandé si je ne devais pas faire quelque chose pour que mon programme reconnaisse les lettres que je lui donne, parce que je sais qu'il reçoit un code pour chaque caractèrs (ASCII par exemple). J'ai un clavier QWERTZ, peut-il y avoir un décalage pour cette raison?
...mais quand j'y pense (regardez mon code en-dessous), le programme devrait donc me dire que j'ai écrit une réponse erronée...

Voici mon code, quand même ;D

"Main"

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
#include <iostream>
 
using namespace std;
 
int main()
// Programme principal
// Exécution automatique avant toute chose
// Dirige vers le menu d'accueil
{
// Déclaration des variables
 
// Déclaration des fonctions
void MenuAccueil();
 
// Distraction du joueur à l'exécution du programme
cout << "Chargement en cours..." << endl;
 
// Ouverture du menu d'accueil
MenuAccueil();// Appel de MenuAccueil
}

"MenuAccueil"

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
#include <iostream>
#include <string.h>
#include <conio.h>
 
using namespace std;
 
void MenuAccueil()
// Accueillir l'utilisateur
// Diriger l'utilisateur vers les différentes fonctions du programme
{   // Déclarer les variables
    string texte;
    int step(1);
 
    // Déclarer les fonctions
    void MeilleurScore();
 
    while(step!=10)
    {   switch(step)
        {   case 1: // Afficher le Menu d'accueil
                cout << "Menu d'accueil" << endl;
                cout << "A Jouer" << endl;
                cout << "B MeilleurScore" << endl;
                cout << "C Credits" << endl;
                cout << "D Quitter" << endl;
                step=2;
            break;
 
            case 2: // Lire la réponse du joueur
                cin >> texte;
                step=3;
            break;
 
            case 3: // Lire la réponse du joueur
                if(texte=="A"||"a")
                    {   // Exécuter la fonction Jeu
                        step=1; // Aller au menu d'accueil
                    }
                else if(texte=="B"||"b")
                    {   MeilleurScore(); // Exécuter la fonction MeilleurScore
                        step=1; // Aller au menu d'accueil
                    }
                else if(texte=="C"||"c")
                    {   // Exécuter la fonction Credits
                        step=1; // Aller au menu d'accueil
                    }
                else if(texte=="D"||"d") // Interrompre le programme
                    {   step=10; // Aller à la dernière étape
                    }
                else // Réponse erronée
                    {   cout << "Reponse erronee, recommencez" << endl;
                        step=2; // Retourner à la lecture de la réponse du joueur
                    }
            break;
        }
    }
}

"MeilleurScore"

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
#include <string.h>
#include <fstream>
 
using namespace std;
 
void MeilleurScore()
// Afficher le meilleur Score enregistré
{   // Déclarer les variables
 
    // Déclarer les fonctions
 
    cout << "Bonjour les amis!" << endl; // TEST

Voilà. Essayez de compiler ça si vous voulez. À moi, sur avec CodeBlocks, ça rend 0 Error et 0 Warning =D

[koala01]

Salut,

Le sujet a été traité récemment, même si c'était au sujet des fonctions inline...

Je t'inciterais tout particulièrement à lire mes interventions qui suivent le cinquième message .

[Armulis]

Salut, merci à toi koala... sauf que j'ai toujours mon problème moi!

Je devrais utiliser des fonctions inline?

Mon problème c'est que mon code ne renvoie aucune erreur (ni même un avertissement) à la compilation, mais que l'appel de fonctions ne donne rien.

Mes prototypes et mes appels sont faits correctement, il me semble, alors j'imagine que le problème ne vient pas de là... =)

[ternel]

Puisque tu déclare une certaine void MenuAccueil(); dans ton main, tu es certain d'avoir une erreur d'acces.

Mets cette déclaration dans un entête que tu importeras (via un #include), et ca ira mieux.

[Armulis]

Oh, j'avais oublié cette ligne dans la définition de mes fonctions!

Code :

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

#include "MeilleurScore"

Et pourtant le problème persiste!
Mon "Main" appelle très bien la fonction suivante, mais celles-ci n'arrivent pas à s'appeler entre elles... ='(

[koala01]

Relis correctement mes messages dans la discussion que j'ai citée plus haut...

Tu remarqueras que tu as le même problème que celui qu'avait josiane avec sa fonction carré:

En effet, une fois qu'on a supprimé les commentaires de ta fonction main (qui sont de toutes manières inutiles!!!), on a:

Code :

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

1
2
3
4
5
6
7
int main()
{
// Déclaration des fonctions
void MenuAccueil(); //TON ERREUR EST ICI!!!!!
// Ouverture du menu d'accueil
MenuAccueil();// Appel de MenuAccueil
}

La ligne 4 vue sous cet angle déclare une fonction "MenuAccueil" qui n'a strictement rien à voir avec la fonction MenuAccueil qui est définie dans le .cpp correspondant!

Si tu ne veux pas créer un fichier d'en-tête pour ce seul prototype de fonction, il faut qu'il se trouve en dehors de toute fonction ou portée.

C'est ce que j'explique dans le message #10 de la discussion dont j'ai mis le lien la tantot

[Armulis]

OK... si je comprends bien, la déclaration de mes fonctions n'est pas faite au bon endroit..?
Mais alors où dois-je déclarer mes fonctions?
Je te signale que mon "Main" contient seulement une paire d'accolades, et on ne peut pas faire autrement!

Par contre, je ne comprends pas pour quelle raison la déclaration de MenuAccueil n'aurait rien à voir avec son implémentation...

[koala01]

Tes déclarations de fonctions doivent être faites dans la portée dans laquelle tu veux les définir :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// hors de toute portée
void foo();
// dans un espace de noms
namespace ns{
void bar();
}
/* dans une classe ou une structure (fonction membre) */
class MaClasse{
 
    public:
        /* ...*/
        void memberFunction();
};

Elles seront définies dans la portée qui leur est impartie:

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
 
// hors de toute portée
void foo(){
    std::cout<<"vous etes dans foo"<<std::endl;
}
// dans un espace de noms
namespace ns{
void bar(){
    std::cout<<"vous etes dans ns::bar"<<std::endl;
}
}
// pour les fonctions membres, on indique le nom "pleinement qualifié"
void MaClass::memberFunction(){
    std::cout<<"voici la fonction membre de MaClasse"<<std::end;
}

Lorsqu'il faudra les appeler, nous utiliserons le noms pleinement qualifié :

Code :

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

1
2
3
4
5
6
7
int main(){
    foo(); // affiche "vous etes dans foo"
    ns::bar(); // affiche "vous etes dans ns::bar"
    /* les fonctions membres sont appelées depuis un objet du type en question */
   MaClass obj;
   obj.memberFunction(); // affiche "voici la fonction membre de MaClasse"
}

Code :

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

Je te signale que mon "Main" contient seulement une paire d'accolades, et on ne peut pas faire autrement!

Ce qui n'empêche que, si tu as ce qui ressemble à une déclaration de fonction, le compilateur considérera que cette fonction doit exister, et que c'et par défaut cette fonction qu'il tentera d'appeler.

Si la fonction main est réellement vide et qu'elle ressemble à

Code :

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

1
2
int main(){
}

il n'est pas du tout surprenant que ton programme ne fasse rien : main est la seule fonction qui soit connue depuis "l'extérieur" de ton programme et qui est appelée automatiquement lorsque tu le lance.

Pour que les autres fonctions puissent être appelée, il faut... qu'au moins l'une d'elles soit appelée depuis main (quitte à ce que la fonction appelée depuis main en appelle elle-meme d'autre).

Si tu n'appelles jamais une fonction, comment veux tu que le compilateur sache quand elle doit être exécutée

[Armulis]

Attends, on s'est pas bien compris: AVANT je faisais tout dans le "Main".
MAINTENANT (après m'être fait casser la gueule virtuellement par tout un forum de programmeurs ^^), je fais un "Main" minimaliste, qui appelle une fonction dans laquelle le programme se trouve.
Et j'ai des fichiers .cpp (ou un truc du genre), et autant moins un de fichiers .h (parce que le "Main" n'en a pas besoin).
Du coup, j'ai un répertoire de fonctions, et elles doivent s'appeler entre elles (et il n'y a pas d'appel dans les deux sens; je sais pas si ça peut poser problème, mais je préfère ne pas commencer d'emmêler à ce point les choses).

En gros, "Main" appelle "MenuAccueil", et "MenuAccueil devrait appeler une poignée d'autres fonctions. Mais il ne le fait pas.
Par contre, j'ai une fonction pour afficher du texte, et celle-là, miraculeusement, elle peut être appelée aussi bien par "Main" que par "MenuAccueil. Le pire, c'est que c'est la première que j'ai faite, et que les autres en sont des copies conformes au niveau de la structure (copies réalisées correctement, je pense, puisque mon compilateur ne m'insulte pas).

Dans le code que je vous ai passé, y a-t-il une erreur ou pas?
S'il n'y en a pas, c'est peut-être mon compilateur qui déconne, ou quelque chose dans le genre..?

[koala01]

Attends, on s'est pas bien compris: AVANT je faisais tout dans le "Main".

Same on you!!! C'est une très mauvaise idée de le faire ainis

MAINTENANT (après m'être fait casser la gueule virtuellement par tout un forum de programmeurs ^^),

Ils ont eu raison...

L'un des gros principes de base de la programmation est de respecter la responsabilité unique: toute classe, toute fonction, ne devrait jamais s'occuper que d'une chose, mais devrait le faire correctement!!!

Imagine que tu aies besoin d'une fonction qui fasse le café, la lessive,la vaiselle et qui sorte le chien, 'xactement dans cet ordre.


Tu peux très bien envisager de créer une seule fonction qui fait tout cela dans cet ordre particulier.

Mais quand (parce que la question n'est pas de savoir si ca arrivera, mais quand cela arrivera) tu auras envie de faire le café, sans faire la vaisselle ni la lessive ni sortir le chien, ou si tu décides un jour qu'il faut sortir le chien avant de faire la vaisselle, tu seras obligé de recopier exactement le meme code, si ce n'est que certaines instructions seront inversées.

Par contre, si dés le départ, tu fais quatre fonctions séparées:

• une pour faire le café,
• une pour faire la vaisselle,
• une pour faire la lessive et
• une pour sortir le chine

Ta fonction qui fait les quatre choses dans un ordre donné n'a... qu'à appeler les fonctions adéquates dans l'ordre souhaité.

Et si, plus tard, tu as besoin d'une fonction qui ne fait que deux ou trois de ces quatre choses, ou qui les fait dans un ordre différent, tu n'as qu'à combiner les appels aux différentes fonctions dans l'ordre qui te convient

je fais un "Main" minimaliste, qui appelle une fonction dans laquelle le programme se trouve.

Une, ou plusieurs fonctions, oui...

On pourrait souvent arriver à quelque chose comme

Code :

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

1
2
3
4
5
6
int main(){
    initialisation(); // on lit et on initialise les données de départ
    execution(); // on fait "tout ce qu'il faut faire " ;)
    sauvegarde(); // on sauvegarde les résultats
    nettoyage(); // on fait le "grand nettoyage" des données
}

Mais regardons bien le code que tu as fourni, et que je remet ici, en rajoutant juste une indentation:

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
int main()
// Programme principal
// Exécution automatique avant toute chose
// Dirige vers le menu d'accueil
{
    // Déclaration des variables
 
    // Déclaration des fonctions 
    void MenuAccueil();
 
    // Distraction du joueur à l'exécution du programme
    cout << "Chargement en cours..." << endl;
 
    // Ouverture du menu d'accueil
    MenuAccueil();// Appel de MenuAccueil
}

Et supprimons les commentaires inutiles:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int main()
{
    // Déclaration des variables
 
    // Déclaration des fonctions
    void MenuAccueil();
 
    // Distraction du joueur à l'exécution du programme
    cout << "Chargement en cours..." << endl;
 
    // Ouverture du menu d'accueil
    MenuAccueil();// Appel de MenuAccueil
}

Tu remarques (c'est d'ailleurs écrit en toutes lettres dans tes commentaire ) que la ligne 6 déclare la fonction void MenuAcceuil().

Et c'est de là que vient le problème!!!

En effet, la définition de la fonction MenuAcceuil se trouve "au niveau 0" (elle n'est entourée d'aucune paire d'accolades : tu n'as que la pair d'accolade qui représente la définition de la fonction), alors que la délcaration de la ligne 6 se trouve "au niveau 1" (dans la pair d'accolade correspondant à la définition de la fonction main() ).

Du coup, lorsque, dans la fonction main(), le compilateur rencontre l'appel
de la fonction MenuAccueil, il va commencer par chercher MenuAccueil au niveau correspondant (au niveau 1)... Et il va trouver une déclaration qui fonctionne...

Seulement, cette fonction MenuAcceuil de niveau 1 n'existe pas!!! la fonction MenuAcceuil qui est définie est de niveau 0!

Le "mangling" des symboles fait qu'il s'agit, purement et simplement de deux fonctions différentes!

C'est exactement le même principe que pour les variables:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void foo(){
    int a;
    if(test){ 
        int a;
        /* ... */
        for(/*...*/){
            int a;
            /* ... */
       }
    }
}

la variable a qui se trouve en ligne 2 est totalement différente de celle qui se trouve en ligne 4 ET de celle qui se trouve en ligne 7...

Bien qu'elles portent chaque fois le même nom, elles se trouvent dans des portées différentes, et ce sont donc à chaque fois des variables différentes (qui, en plus, "cachent" la variable de la portée précédente).

Et c'est exactement le même problème que tu rencontre avec tes fonctions!

Et j'ai des fichiers .cpp (ou un truc du genre), et autant moins un de fichiers .h (parce que le "Main" n'en a pas besoin).

Pour que cela fonctionne, il faut que la déclaration de la fonction (qui peut se trouver dans un fichier d'en-tête (*.h) se trouve au même niveau que la définition de la fonction, c'est à dire avant la fonction main, et non dans celle-i

[Armulis]

Pour le moment, c'est la fonction "MenuAccueil" (qui est appelée tout-à-fait correctement par "Main") qui n'arrive pas à appeler "MeilleurScore".
J'aimerais savoir pourquoi, c'est tout.
On s'occupera de "Main" plus tard (pour autant qu'il y ait un problème, mais je te signale que pour l'instant, il fonctionne parfaitement).

[Bousk]

Pour le moment, c'est la fonction "MenuAccueil" (qui est appelée tout-à-fait correctement par "Main") qui n'arrive pas à appeler "MeilleurScore".
J'aimerais savoir pourquoi, c'est tout.
On s'occupera de "Main" plus tard (pour autant qu'il y ait un problème, mais je te signale que pour l'instant, il fonctionne parfaitement).

Le problème de MenuAccueil est exactement le même que le main qui est tout autant foireux.
Le problème c'est qu'il faut lire un cours parce que la déclaration des méthodes dans le corps d'une fonction, je me demande où tu as lu ça mais tu peux jeter cette source d'information.

[Armulis]

...booooon...

J'ai résolu le problème...
...en enlevant les || dans le if, dans la méthode MenuAccueil...

[Bousk]

Le fait est que tes erreurs flagrantes sur les simples déclarations ont totalement outrepassé les erreurs if(texte=="A"||"a") qui n'est pas une syntaxe valide pour un test. (enfin si elle est valide, mais elle est à 1000 lieux de faire ce que tu crois)

[Armulis]

J'ai compris ça en cherchant comment mettre des fonctions logiques.
En fait, il fallait écrire if((texte=="blabla")||(texte=="blablabla")), et j'avais pas remarqué avant de tomber sur un exemple précis.

Si je relis mon écriture d'origine, ma fonction évalue ça: si texte="A" ou si "a" (sous-entendu: si "a"!=[chaîne de caractères vide], ce qui est impossible)

Mais mes erreurs flagrantes de déclaration relèvent-elles du manque de rigueur dans l'écriture, ou vous attendez-vous réellement à ce que mon programme ne fonctionne pas du tout?
Au cas-où, je vous assure que mon programme fonctionne parfaitement! (et je ne soudoie pas mon compilateur ^^)

Pour être honnête, le problème de déclaration que vous évoquez me dépasse complètement. Je ne sais pas quel est votre niveau, mais je sais que je suis un débutant: je ne suis peut-être (pour l'instant) pas apte à comprendre de quoi vous parlez; ça devrait venir, en somme).
Disons que grâce à vous, en cas de problème (quand, plus tard, je me mettrai à pousser le langage dans ses retranchements) j'aurai plus facilement une idée du problème =D

[Bousk]

(sous-entendu: si "a"!=[chaîne de caractères vide], ce qui est impossible)

Non.
if ("a") est un test sur const char* qui est un pointeur et donc l'équivalent de if ("a" != NULL) qui est toujours vrai.

Btw, débutant ou pas, il s'agit d'apprendre et pas de tenter au petit bonheur la chance des syntaxes. Pour cela il y a des langages de script qui conviennent bien plus souvent à la bidouille. (plus simple, plus rapide, pas de compilation, erreurs plus claires, ...)
Et qu'il ne s'agit pas du tout de rigueur d'écriture mais d'une simple lecture d'un vrai cours sur la grammaire de base du langage.
La déclaration c'est juste le point de départ de tout programme, ça n'a rien d'anecdotique ou superficiel dans l'apprentissage.
L'explication de Koala est tout à fait claire à ce sujet et mérite plus que ton attention.

[Flob90]

La ligne 4 vue sous cet angle déclare une fonction "MenuAccueil" qui n'a strictement rien à voir avec la fonction MenuAccueil qui est définie dans le .cpp correspondant!

En faite c'est un peu plus compliqué que ça.

Norme:

The name of a function declared in block scope [...] have linkage. When a block scope declaration of an entity with linkage is not found to refer to some other declaration, then that entity is a member of the innermost enclosing namespace.

Le nom d'une fonction déclarée dans un scope de type bloc [...] a un linkage. Quand une déclaration dans un scope de type bloc d'une entité avec un linkage ne peut être associé à une autre déclaration, alors cette entité est un membre du namespace le plus proche.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include<iostream>
 
int main()
{
    void foo();
    foo();
}
 
void foo()
{ std::cout << 0; }

Totalement valide et a le comportement voulu. (Ça marche aussi en séparant en deux unité de compilation).

Ce qui explique que le code de l'OP fonctionne parfaitement et que son problème n'est au final qu'une écriture des tests conditionnel (problème qu'il aurait vu directement en effectuant une exécution pas à pas). Cependant, bien que ce soit valide, je ne cautionne pas pour autant ce genre d'écriture, elle complexifie plus qu'autre chose la compréhension.