Discussion :

[Armulis]

Salut!

Depuis quelques temps, j'ai pu écrire plusieurs programmes simples en C++, et j'essaie de mettre des nouveautés à chaque fois.

Quand mes programmes sont devenus plus conséquents (500 lignes en gros), on m'a un peu reproché de tout faire dans le Main.
J'ai demandé ce que je pouvais faire d'autre, et on m'a expliqué qu'il fallait faire des fonctions.
Mais en lisant la théorie sur les fonctions, j'ai pas trop compris comment c'était censé sortir du Main..?
Autre chose: pour que les variables soient liées entre un sous-programme et les autres, est-ce que je dois utiliser une subtilité?

Merci pour vos indications =D

[koala01]

Salut,

En fait, le principe est tout bête: pour passer de la fonction (parce qu'on parle de fonction, voir de routine et non de sous programme ) main à une autre fonction, il "suffit" d'appeler cette fonction.

une fois que la fonction appelée aura terminé son boulot, on retournera automatiquement dans la fonction appelante pour reprendre "là où on l'avait laissée".

Un exemple tout bête, pour te permettre de comprendre:

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
 
#include <iostream>
/* une fonction "toute bête" qui avise juste l'utilisateur qu'on arrive dedans */
void foo()
{
   std::cout<<"bienvenue dans foo()"<<std::endl;
}
/* et la fonction principale qui l'appelle */
int main()
{
    std::cout<<"nous sommes au debut de main()"<<std::endl;
    foo();
    std::cout<<"nous somme de retour dans main()"<<std::endl;
    return 0;
}

A l'exécution, tu verra apparaitre

Code :

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

1
2
3
nous sommes au debut de main()
bienvenue dans foo()
nous sommes de retour dans main()

Il faut cependant savoir que le compilateur travaille de la même manière que toi quand tu lis un livre:
Tout comme, la première fois que tu lis le livre, tu ne sais pas ce qui va se passer à la page 10 quand tu n'en es qu'à la page 8, le compilateur ne sait pas ce qu'il y a à la ligne 10 lorsqu'il se trouve à la ligne 9.

Et s'il ne connait pas "quelque chose", il n'est pas content et t'éjecte sans vergogne.

Ainsi, alors que les deux fonctions existent, si on en inverse simplement l'ordre sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
 
/* et la fonction principale qui l'appelle */
int main()
{
    std::cout<<"nous sommes au debut de main()"<<std::endl;
    foo();
    std::cout<<"nous somme de retour dans main()"<<std::endl;
    return 0;
}/* une fonction "toute bête" qui avise juste l'utilisateur qu'on arrive dedans */
void foo()
{
   std::cout<<"bienvenue dans foo()"<<std::endl;
}

le compilateur refusera de compiler le programme sous prétexte "qu'il ne connait pas foo" quand il est dans main

Mais il "suffit" de lui dire, avant d'entrer dans main, que la fonction foo existe, et il sera content . On parle alors d'une déclaration de fonction.

Ainsi, le 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
 
#include <iostream>
/* déclare la fonction foo() pour que le compilateur sache qu'elle existe */
void foo();
/* définition de la fonction main */
int main()
{
    std::cout<<"nous sommes au debut de main()"<<std::endl;
    foo();
    std::cout<<"nous somme de retour dans main()"<<std::endl;
    return 0;
}
/* et enfin la définition de la fonction foo */
void foo()
{
   std::cout<<"bienvenue dans foo()"<<std::endl;
}

sera parfaitement accepté par le compilateur.

Afin de savoir de quoi l'on parle, on utilise le terme "déclaration d'une fonction" (ou toute utilisation adéquate du verbe "déclarer", bien sur) lorsqu'on ne fait qu'indiquer la signature (*) de la fonction, mais on parle de définition (ou toute utilisation adéquate du verbe "définir", bien sur) ou encore d'implémentation (ou tout autre utilisation du verbe ... implémenter) lorsque l'on fournit le corps de la fonction (comprends : lorsque l'on indique ce que doit faire la dite fonction )

Toute définition (ou implémentation) de fonction vaut d'office déclaration pour "le code qui suit", mais tu auras de gros problèmes si tout ce qui existe au sujet d'une fonction, c'est sa déclaration: tout le processus de compilation se passera correctement jusqu'au moment où... il s'agira de faire coincider l'appel d'une fonction avec l'adresse mémoire à laquelle elle se trouve, et là, tu sera confronté à une erreur de "référence indéfinie"

(*) On utilise régulièrement plusieurs termes lorsque l'on parle des fonction:

• Le prototype, qui est composé du nom de la fonction et des arguments éventuels qu'elle accepte
• La signature, qui est composée du prototype de la fonction et du type de donnée qu'elle renvoie
• le corps de la fonction qui est composé de toutes les instructions qu'elle doit effectuer.

Pour déclarer une fonction, la signature de celle-ci suffit
Pour implémenter une fonction, il faut que la signature de celle-ci soit suivi de son corps placé entre accolades "{" et "}"
De manière générale, la signature sera proche de

Code :

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

<type de retour> <nom de la fonction> ( <liste des arguments qu'elle accepte, séparés par une virgule>)

Pour définition d'un argument de fonction se fait exactement comme la déclaration d'une variable, c'est à dire que nous pourrions modifier le code précédant sous la forme de

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
#include <iostream>
/* on déclare une fonction (qui ne renvoie rien) foo() qui prend un entier 
 * comme argument
 */
void foo(int valeur);
/* que l'on peut alors appeler depuis "n'importe où" */
int main()
{
 
    std::cout<<"nous sommes au debut de main()"<<std::endl;
    for(int i=1;i<=10;++i)
    {
        foo(i);
        std::cout<<"nous somme de retour dans main()"<<std::endl;
    }
    std::cout<<"merci et au revoir"<<std::endl;
}
void foo(int valeur)
{
    /* les argument passés à une fonction s'utilisent exactement comme s'il
     * s'agissait d'une variable classique au sein de la fonction
     */
    std::cout<<"bienvenue dans foo()"<<std::endl;
    std::cout<<"c'est la "<<valeur<<" ieme fois qu'on passe dedans"<<std::endl;
}

Après, il y a quelques particularités au sujet du passage de paramètres aux fonctions, mais, si tu as déjà compris ceci, tu devrais arriver à comprendre la suite dans n'importe quel tutoriel

[Médinoc]

^Attention, tu as oublié le point-virgule sur la première déclaration anticipée.
Quant à ton dernier bloc de code, il a un commentaire non-terminé.

[koala01]

^Attention, tu as oublié le point-virgule sur la première déclaration anticipée.
Quant à ton dernier bloc de code, il a un commentaire non-terminé.

Bien vu!

Corrigé, merci

[Armulis]

Youpi, c'est tout nice!
En fait, on écrit tout dans le même fichier, mais pas tout dans le main...
C'est cool.

[Armulis]

Génial!
Avec les pototypes c'est parfait! =D

Maintenant, un petit détail: est-ce qu'on peut créer une fonction dont le type soit une structure?
(Je crois savoir que les structures sont des types personnalisés, en gros, mais est-ce que ça marche?)

Ou plus simple: comment fait-on pour que toutes les fonctions puissent utiliser (et modifier) un groupe de variables déclarées (une seuls fois) dans le main?