L'apparition des fonctions

Nous allons voir dans ce chapitre la notion de fonction ainsi que comment en créer et apprendre à s'en servir, bref que du bonheur!

Commençons tout de suite par voir ce qu'est une fonction et comment en créer une


La notion de fonction

Les fonctions permettent au programmeur d'organiser son code pour lui simplifier la vie et d'éviter de répéter des tâches inutiles. Si vous devez par exemple répéter beaucoup de fois dans votre code une certaine action prenant pas mal de ligne, la création d'une fonction serait utile car elle permettrait de ne pas tout réécrire à chaque fois mais juste une seule ligne.

Prenons un exemple:


/*Nous verrons juste après comment en créer, pour l'instant comprenez que ceci est une fonction qui exécute tout ce qui se trouve entre accolades*/

int FaireSauterJoueur()
{
      //Plein d'opérations supers-complexes pour faire sauter le joueur.
}


int main() //Le programme débute.
{    
     FaireSauterJoueur(); //On a juste à appeler la fonction. Super pratique
     return 0;
}



Comme vous pouvez le voir, il suffit d'écrire juste une ligne à la place de plusieurs centaines C'est donc beaucoup plus clair


Voyons maintenant comment en créer une.


La création d'une fonction

En premier lieu, un point de vocabulaire: On ne dit pas vraiment "créer" une fonction mais plutôt "déclarer" (comme pour les variables).

Voici comment se présente la déclaration d'une fonction:


type nomDeLaFonction()
{
     //Instructions.
     return variable;
}


Voyons maintenant tout cela en détails:

-Le type est le type de retour de la fonction. Je m'explique: une fonction est souvent utilisée pour renvoyer quelque chose, par exemple la fonction pow (fonction qui calcule une puissance)
retourne un nombre (le résultat de l'opération) qui est de type double.
Et bien le type est tout simplement le type de retour de la fonction. Si vous souhaitez par exemple retourner un résultat dans un int, le type de la fonction sera de type int tout simplement et c'est exactement la même chose pour double, float, char, int, long etc..


-Le nomDeLaFonction est simplement le nom que vous souhaitez lui donner. Il est préférable de lui donner un nom plutôt explicite. Ce nom doit respecter les mêmes règles que pour les variables, à savoir je vous le rappelle: pas d'espaces, pas de caractères spéciaux, pas d'accents, etc...

-Viennent ensuite les parenthèses juste après le nom de la fonction. Il s'agit de l'endroit où l'on peut placer des éventuels paramètres (nous allons revenir dessus juste après avoir terminé l'explication sur comment créer des fonctions).


-Enfin, il y a les accolades et tout ce qui se trouve dedans. Ce sont les instructions à exécuter.

-Pour terminer, il y a le return variable qui renvoie la variable désignée du type choisi au départ


Les paramètres

Les paramètres se situent entre les parenthèses, séparés chacun par une virgule.

Les paramètres sont des variables que l'on donne à une fonction pour qu'elle puisse les utiliser. Si on ne lui donne pas et que l'on essaye de quand même les utiliser, cela va générer une erreur.

Il faut indiquer à chaque fois le type demandé ainsi que le nom que l'on va attribuer à cette variable.

Exemple:


type nomDeLaFonction(int variable1, double variable2, float variable3) //Comme ceci.
{
     //Instructions.

     /*Nous pouvons donc, dans cette fonction, utiliser les variables "variable1", "variable2" et "variable3".*/

     return variable;
}


Vous savez à présent tout des fonctions "simples"Voyons maintenant comment les utiliser:

-Tout d'abord, il faut déclarer la fonction avant le main, comme ceci:


/*On place la déclaration de la fonction juste avant le main (le main qui est d'ailleurs lui même une fonction).*/

void Fonction()
{
      //Plein d'opérations supers-complexes.
}


int main() //Le programme débute.
{    
     Fonction(); //On a juste à appeler la fonction. Super pratique
     return 0;
}


Utiliser une fonction

Pour utiliser une fonction, il suffit d'écrire son nom suivi des parenthèses avec à l'intérieur les différents paramètres de la fonction. Si celle-ci n'a pas de paramètres, on met quand même les parenthèses mais en les laissant vides


Pour nous habituer aux fonctions, nous allons créer ensemble une fonction qui fera l'addition des deux nombres passés en paramètre (c'est un exemple).

Tout d'abord, admettons que notre fonction renverra un nombre (logique) de type int et appelons notre fonction "CalulerSomme". Elle se présentera donc comme ceci:

int CalculerSomme()
{

}




Il ne manque plus qu'à indiquer les noms des paramètres comme ceci:


int CalculerSomme(int nombre1, int nombre2)
{

}


et à ajouter l'opération nécessaire à l'intérieur:

int CalculerSomme(int nombre1, int nombre2)
{
/*On écrit directement l'opération dans le return, bien que l'on aurait pu la stocker dans une variable et retourner cette dernière.*/
       return nombre1 + nombre2;
}


Ce qui nous donne le programme final:


#include <stdlib.h>
#include <stdio.h>

int CalculerSomme(int nombre1, int nombre2)
{
/*On écrit directement l'opération dans le return, bien que l'on aurait pu la stocker dans une variable et retourner cette dernière.*/
       return nombre1 + nombre2;
}

int main()
{
     int resultatOperation;

//Le resultat est stocké dans la variable resultatOperation.
     resultatOperation = CalculerSomme(3, 45);

     printf("L'addition de 3 + 45 est egale a %d.", resultatOperation);  //On affiche le résultat.
}



Remarquez bien que comme une fonction retourne quelque chose, le simple fait d'écrire:

CalculerSomme(3, 45);

correspond à un nombre (ici le résultat de la somme de 3 par 45). Nous pouvons donc écrire directement la fonction dans le printf comme ceci:

     printf("L'addition de 3 + 45 est egale a %d.",CalculerSomme(3, 45));

Cela est tout à fait correct et permet d'utiliser une variable en moins

Voilà, j'espère que tout cela est à présent clair pour vous


Voyons maintenant les fonctions plus spéciales (il n'y en a que deux).



Les fonctions spéciales

Voici deux types de fonctions spéciales:


-La fonction main. Vous la connaissez depuis le début, mais elle mérite que l'on s'y intéresse un peu plus en détails. C'est une fonction comme les autres qui renvoie un int.
Elle prend comme paramètres argc et argv. Le premier paramètre contient le nombre de paramètres envoyé à cette fonction et argv contient tous les paramètres.

Vous allez me dire: Oui mais on ne lui donne pas de paramètre nous!
C'est exact, mais le système d'exploitation lui oui!
Je ne vais pas m'aventurer dans des explications plus approfondies, il faut pour cela que vous maitrisiez les tableaux, notion que nous n'avons pas encore vu


-La fonction de type void. C'est un type de fonction qui permet de ne rien renvoyer!
Imaginez que vous écrivez une fonction ne servant, par exemple, qu'à écrire du texte à l'écran. Il ne sert à rien de renvoyer quelque chose. Vous pouvez donc écrire une fonction de type void.

Exemple:

#include <stdlib.h>
#include <stdio.h>

/*Notez qu'une fonction de type void peut très bien avoir des arguments comme tout autre type de fonction */

void AfficherTexte()
{
     printf("Hello world!");
}

int main()
{
     AfficherTexte(); //On appele la fonction.
     return 0;
}


Voilà pour les deux types de fonctions "spéciales".


Les prototypes

Jusqu'ici nous avons vu qu'il fallait impérativement déclarée les foncitons avant le main sans quoi cela ne marchait pas. Et bien bonne nouvelle, on peut s'en passer!

Il suffira maintenant de déclarer son prototype avant la fonction main et de mettre la fonction n'importe où (même dans un autre fichier, chose que nous verrons très bientôt).

Reprenons l'exemple précédent:

#include <stdlib.h>
#include <stdio.h>

void AfficherTexte() //La fonction est déclarée avant le main.
{
     printf("Hello world!");
}

int main()
{
     AfficherTexte(); //On appele la fonction.
     return 0;
}


Pour créer le prototype d'une fonction, c'est extrêmement simple:

1) Vous prenez la déclaration de la fonction.
2) Vous rajoutez un ";" à la fin de celle-ci.

Et c'est tout!
Essayons avec le code du dessus:


1) void AfficherTexte()
2) void AfficherTexte();

Ça va ce n'est pas trop compliqué


Il suffit donc de mettre cette ligne avant le main puis la fonction n'importe où (ici nous allons, pour l'exemple, la mettre après le main):


#include <stdlib.h>
#include <stdio.h>

void AfficherTexte();

int main()
{
     AfficherTexte(); //On appele la fonction.
     return 0;
}

void AfficherTexte()
{
     printf("Hello world!");
}


Et voilà! Vous savez maintenant absolument tout des fonctions! Le prochain chapitre traitera du préprocessing et qui sera très simple


   Les boucles                                                                                              Le préprocessing