Discussion :

[Rave-]

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 :

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

[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à !

[Iradrille]

Hello,

Code :

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

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.

[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 !

[Iradrille]

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.

[Ehonn]

Un petit peu de vocabulaire.

Code :

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

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

Code :

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

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

Code :

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

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

Code :

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

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.

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

[gbdivers]

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

[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)

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

[ternel]

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.

[koala01]

Salut,

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 :

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

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) ;)
    }
}

[Ehonn]

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

?

Code :

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

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

Code :

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

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]

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

[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 :

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

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 :

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...") :

A declaration is a definition unless it declares

[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