Appeler des fonctions

Version imprimable

1 pièce(s) jointe(s)

Bonjour à tous,
Je viens ici recueillir votre expérience afin que vous puissiez m'éclairer sur un petit problème.

Le voici :

• Expérimentant mes codes en C++, je teste diverses choses chaque soir en rentrant du lycée afin de mieux me préparer à ma prochaine école.
• Ce soir, je me suis penché sur le ' problème ' des fonctions.
• J'ai donc fait un test de petit programme sans avoir rien regardé à côté afin de voir si j'y arrivais seul.
• Surprenant, j'arrive à faire rediriger la fonction main qui ira dans la fonction menu . Une fois dans celle-ci , je propose deux choix vers deux autres fonctions.
• Or , dans cette fonction menu , je n'ai pas le choix et le programme me redirige directement à la dernière fonction , reconnaissable par le texte.

J'en arrive donc à vous demander comment faire pour appeler correctement des fonctions / procédures et que mettre dedans de particuliers ? ( return etc .. )

Voici mon programme de test :
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 #include <iostream> using namespace std; int test(); int test2(); int menu(); int choix; int main() { menu(); return 0; } int menu() { cout << "Aller dans quelle fonction ?"<<endl; switch (choix) { case 1 : test();break; default : test2();break; } return 0; } int test() { cout << "\nFONCTION TEST!"<<endl; } int test2() { cout << "\nFONCTION TEST2!"<<endl; }
Voici maintenant le résultat lors de l’exécution de mon problème :
http://www.developpez.net/forums/att...1&d=1365488127

J'espère avoir été le plus clair possible,
En attente de vos aides, merci d'avance . :ccool:

08/04/2013, 22h01
PilloBuenaGente

Bonsoir,

une fonction est relativement complexe !

Je pense que lire ce cour serait très instructif, il répond au questions principales.

Si certaines parties posent problème, on est là !

Hello,
Citation:
Envoyé par Rave-
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int menu() { cout << "Aller dans quelle fonction ?"<<endl; cin >> choix; // récupérer le choix de l'user switch (choix) { case 1 : test();break; default : test2();break; } return 0; }
Nul part choix est initialisé. Il prend donc une valeur aléatoire (la valeur que la mémoire contient à son emplacement). Vu qu'il prend une valeur pseudo-aléatoire, il à de grandes chances d'être différent de 1, et donc ton switch appelle test2.
std::cin, qui marche comme std::cout te permet de récupérer des données écrites au clavier.

Attention aussi à tes fonctions test et test2 qui devraient retourner un int mais qui ne le font pas. Tu peux les déclarer void (void test() { ... }) si elles n'ont rien besoin de retourner.

09/04/2013, 17h45
Rave-

Tout d'abord, merci à vous de vos réponses !

Iradrille,
Merci beaucoup, tu viens de m'expliquer pourquoi mon switch renvoyait directement à la deuxième case.
Par contre, tu dis que choix n'est nul part initialisé, or je l'ai placé avant la fonction main. J'en conclus donc que c'est un mauvais choix ?

Ensuite, je pensais à les déclarer en tant que void, mais en testant, j'obtenais le même << résultat >> .

PilloBuenaGente,
Merci également de ton aide, je pense que re-lire ce cours ne me fera pas de mal !
Si j'ai des questions, je n'hésiterai pas , merci :)

Je referais donc des tests supplémentaires et essaierai de trouver par moi même , merci en tout cas !

C'est bon, problème résolu !
Pour ceux curieux de savoir, je n'avais tout simplement pas mis un cin , demandant donc vers quelle fonction aller !
09/04/2013, 18h46
Iradrille

Citation:

Envoyé par Rave-

Par contre, tu dis que choix n'est nul part initialisé, or je l'ai placé avant la fonction main. J'en conclus donc que c'est un mauvais choix ?

Les variables globales sont généralement à éviter oui.
Ici, choix peut être déclaré dans menu.
09/04/2013, 18h57
Ehonn
Un petit peu de vocabulaire.

Code:

int v; // v est déclaré et défini
Code:

1 2 int v; // v est déclaré et défini v = 0; // v est affecté
Code:

int v = 0; // v est déclaré et défini et initialisé

Code:

int v(0); // v est déclaré et défini et initialisé (grosso modo : syntaxe pour les objets mais possible aussi pour les types de base)

Une règle simplifiée : toute variable déclarée et défini doit être initialisée (ou affectée juste après la définition (lorsqu'on utilise std::cin par exemple)).
Autre règle simplifiée (comme le dit Iradrille) : la portée (la durée de vie) des variables doit être limité aux blocs (ce qu'il y a entre deux { }) qui en ont besoin. C'est-à-dire que l'on ne déclare des variables que lorsqu'on en a besoin.
10/04/2013, 10h21
ternel
Ce n'est pas le bon vocabulaire.
- extern int v; déclaration d'une variable (définie ailleurs).
- int v; définition arbitaire
- int v = 2; définition
- v = 2; affectation
- int f(); déclaration d'une fonction (définie ailleurs).
- int f(){return 0;} définition d'une fonction
- class s; déclaration d'une classe (marche aussi pour les structures)
- class s{/**/}; définition d'une classe
Sachant cela, la règle absolue est:
Chaque chose doit être définie une et une seule fois.
10/04/2013, 10h41
gbdivers
Citation:
Envoyé par leternel

Ce n'est pas le bon vocabulaire.

extern int v; déclaration d'une variable (définie ailleurs).
int v; ~~définition arbitaire~~ déclaration + définition
int v = 2; ~~définition~~ déclaration + définition + intialisation
v = 2; affectation
int f(); déclaration d'une fonction (définie ailleurs).
int f(){return 0;} définition d'une fonction
class s; déclaration d'une classe (marche aussi pour les structures)
class s{/**/}; définition d'une classe

Sachant cela, la règle absolue est:
Chaque chose doit être définie une et une seule fois par unité de compilation (non ? ou par lib ? je sais plus trop...).
J'avais retenu (sauf erreur ou simplification) :
* déclaration : on dit au compilateur qu'il existe un "identifiant" (nom d'une variable, d'une fonction, d'une classe)
* définition : on dit au compilateur à quoi correspond cet identifiant (type d'une variable, corps d'une fonction, interface d'une classe)
* initialisation : donner une valeur lors de la définition d'une variable
* affectation : donner une valeur à une variable hors définition
10/04/2013, 10h56
Ehonn

Autant pour moi, il faut remplacé tous mes «déclaré» par «déclaré et défini».
(Pour le contexte : on est dans un bloc)

Citation:

Chaque chose doit être définie une et une seule fois par unité de compilation (non ? ou par lib ? je sais plus trop...)

Par programme, sinon l'éditeur de lien se plaint avec un «multiple definition of ...»
10/04/2013, 11h05
ternel

Citation:

Envoyé par gbdivers

J'avais retenu (sauf erreur ou simplification) :
* déclaration : on dit au compilateur qu'il existe un "identifiant" (nom d'une variable, d'une fonction, d'une classe)
* définition : on dit au compilateur à quoi correspond cette identifiant (type d'une variable, corps d'une fonction, interface d'une classe)
* initialisation : donner une valeur lors de la définition d'une variable
* affectation : donner une valeur à une variable hors définition

C'est assez vrai. J'ai juste fait un raccourci. Toute définition implique la déclaration du symbole défini.
Ce que tu appelle initialisation est en fait une initialisation explicite.
Toute définition contient une initialisation, explicite ou par défaut.
Pour les types de base, cette initialisation par défaut est arbitraire, mais présente. Pour les classes et structures, c'est le constructeur par défaut, c'est-à-dire celui appelé sans argument.

Du coup, int v; est une définition implicite, et int v=2; une définition explicite.

Les affectations sont les appels à operator=(). (ou à ce qui en tient lieu pour les types de bases)

La règle de la définition unique s'applique en toute occasion: par unité de compilation, par lib et par binaire lié. En fait, elle est vérifiée par le compilateur et l'éditeur de liens.

Salut,

Citation:

Envoyé par leternel

La règle de la définition unique s'applique en toute occasion: par unité de compilation, par lib et par binaire lié. En fait, elle est vérifiée par le compilateur et l'éditeur de liens.

En fait, c'est même carrément:

par portée (blocs d'instructions entre { et } ) sachant que le compilateur peut le vérifier
par unité de compilation (pour les variables statiques)
par bibliothèque
par binaire lié
Code:

1 2 3 4 5 6 7 8 9 void foo(){ int i; for(/*... */){ int i; // correct et légal, mais i n'est pas le i de deux lignes plus haut // on aura cependant un avertissement du compilateur indiquant // que la variable en cache une autre (si on le règle correctement) ;) } }

Citation:

Envoyé par leternel

Toute définition contient une initialisation, explicite ou par défaut.

Code:

1
2
3
4
5
6
7
8
9
#include <iostream> 
 
int main()
{
	int i;
	std::cout << i << std::endl;
 
	return 0;
}

Code:

1
2
3
$ g++ -Wall main.cpp
main.cpp: In function ‘int main()’:
main.cpp:6:15: warning: ‘i’ is used uninitialized in this function [-Wuninitialized]

10/04/2013, 12h40
ternel

Il y a bien une initialisation, mais ton warning t'indique qu'il n'y a pas eu d'initialisation explicite, donc que la valeur est pourrie.

Ton programme est tout de même compilable, et exécutable, (sauf si -Werror).
10/04/2013, 14h22
gbdivers
@leternel
Je comprend l'idée dans ce que tu veux dire. La création d'un objet nécessite :
1. l'allocation de la mémoire
2. attribuer une "valeur" à la mémoire allouée
Personnellement, quand je parle d'initialisation, je parle de la seconde partie, c'est à dire attribuer une valeur lors de la création de l'objet

Dans la norme, on parle de "non trivial initialization" dans ce cas. Dans le cas d'un objet n'ayant pas de "trivial initialization" (donc les build in type et les agrégats de build in type), il n'y a pas d'initialisation.

Parler d'initialisation implicite et explicite peut être trompeur pour un débutant, puisque dans langage courant, initialisation = affecter une valeur par défaut. Ce qui peut poser des problèmes. Un classique, ce code qui ne fait pas ce qu'attend un débutant
Code:

1 2 int* p; if (p) { ... } // dans une fonction par exemple
Donc je pense que "ma" définition de "initialisation" est moins sujet à erreur que la tienne.

(HS : d'ailleurs, dans le livre "Safe C++", il propose par exemple de remplacer toute utilisation d'un build-in type par une classe garantissant l'initialisation)

Pour "déclaration", la norme donne comme définition :

Citation:

Envoyé par N3376 3.1

A declaration (Clause 7) may introduce one or more names into a translation unit

Pour "définition", c'est amusant, la norme le définie à partir de "déclaration" ("tout est définition, sauf...") :

Citation:

Envoyé par N3376 3.1

A declaration is a definition unless it declares
10/04/2013, 15h19
ternel

Je note, "ta" définition est encore plus précise.
Je m'en inspirerai par la suite.

Nous sommes de toute facon bien d'accord pour dire que int v; définit le symbole, qui ne peut être défini qu'une fois, à l'opposé de extern int v;.
Tout va bien, tant mieux:mrgreen: