Les cours du BTS SIO

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Fiche savoirs sur les fonctions ======

**Définition :** 
  * Une fonction est un bloc de code isolé, qui peut être appelé et donc réutilisé plusieurs fois dans le code de son programme.
  * l'utilisation des fonctions permet d'avoir un code organisé en modules.

===== Utiliser une fonctionpour éviter les répétitions de code =====

Voici l’exemple du programme **NombreCache** avec des contrôles de la saisie de l'essai (try catch) qui sont utilisés à plusieurs endroits dans le code de l'application et qui  se ressemblent : 
  * le contrôle de la saisie avant la boucle (la première saisie) 
  * et le contrôle de la saisie dans la boucle:

<code c# fonction.cs>
static void Main(string[] args) {
  // déclaration
  int valeur = 0, essai = 0, nbre = 1;
  bool correct = false;
  // saisie du nombre à chercher
  while (!correct) {
    try { 
      Console.Write("Entrez le nombre à chercher = ");
      valeur = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
  Console.Clear();
  // saisie du premier essai
  correct = false;
  while (!correct) {
    try {
      Console.Write("Entrez un essai = ");
      essai = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
  // boucle sur les essais
  while (essai != valeur) {
    // test de l’essai par rapport à la valeur à chercher
    if (essai > valeur) {
      Console.WriteLine(" --> trop grand !");
    }
    else {
      Console.WriteLine(" --> trop petit !");
    }
    // saisie d’un nouvel essai
    correct = false;
    while (!correct) {
      try {
        Console.Write("Entrez un essai = ");
        essai = int.Parse(Console.ReadLine());
        correct = true;
      }
      catch {
        Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
      }
    }
    // compteur d’essais
    nbre++;
  }
  // valeur trouvée
  Console.WriteLine("Vous avez trouvé en "+nbre+" fois !");
  Console.ReadLine();
}
</code>
 
Le premier objectif est d’éviter la répétition à l'identique de plusieurs lignes de code en créant une **fonction appelée saisie()** en dehors du **Main()**, juste au-dessus, pour isoler le bloc de code identique :
<code c#>
static void saisie()
{
  correct = false;
  while (!correct)
  {
    try
    {
      Console.Write("Entrez un essai = ");
      essai = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch
    {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
}
</code>

<WRAP center round important>
Problème : 
  * les variables **correct** et **essai** ne sont pas déclarées dans la fonction **saisie()**.
  * il faut rajouter leur déclaration
</WRAP>
La variable **correct** n'est utilisée que dans la fonction **saisie()** : on peut la déclarer directement dans la fonction **saisie()** :
<code c#>
static void saisie()
{
  bool correct = false;
  while (!correct)
  {
     try
    {
      Console.Write("Entrez un essai = ");
      essai = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch
    {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
}
</code>

Par contre la variable **essai** doit pouvoir être réutilisée dans le **Main()**. Il est nécessaire que **essai** soit déclarée pour être visible et utilisable à la fois dans le **Main()** et dans la fonction **saisie()**. Il est préférable que **essai** soit déclarée comme une **variable globale** à l'ensemble du programme.


==== Déclaration de la variable globale essai : ====

<code c#>
class Program
{
  static int essai;
  ...
</code> 


==== Essai n'est plus déclarée dans le Main() : ====

<code c#>
// déclaration
int valeur = 0, nbre = 1;
essai = 0;
</code> 
==== Programme du nombre caché avec la procédure saisie ====
<code c#>

static int essai;

static void Main(string[] args) {
  // déclaration
  int valeur = 0, nbre = 1;
  bool correct = false;
  // saisie du nombre à chercher
  while (!correct) {
    try { 
      Console.Write("Entrez le nombre à chercher = ");
      valeur = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
  Console.Clear();
  // saisie du premier essai
  saisie();
  // boucle sur les essais
  while (essai != valeur) {
    // test de l’essai par rapport à la valeur à chercher
    if (essai > valeur) {
      Console.WriteLine(" --> trop grand !");
    }
    else {
      Console.WriteLine(" --> trop petit !");
    }
    // saisie d’un nouvel essai
    saisie();
    // compteur d’essais
    nbre++;
  }
  // valeur trouvée
  Console.WriteLine("Vous avez trouvé en "+nbre+" fois !");
  Console.ReadLine();
}
</code>

<WRAP center round todo>
**Exercice 1 :**
  * Créez un nouveau projet à partir de ce dépôt Git : https://github.com/ctecher/ModuleExercice_1.git
  * Modifiez Le programme doit permettre de saisir plusieurs prix et au final d’afficher le total des prix.
  * Avant chaque saisie, il faut poser la question "Avez-vous un prix à saisir ? (O/N) " et saisir la réponse de préférence d’un seul caractère sans valider, en contrôlant que l’utilisateur a bien saisi O ou N et pas autre chose (sinon la question est reposée). 
  * Si l’utilisateur répond N, le total des prix est affiché et le programme s’arrête.
  * Sachant qu’une saisie doit être prévue avant la boucle générale, et une à la fin de la boucle, le but est d’isoler ce bloc de code dans une fonction.

{{ :bloc1:fonction_01.png?400 |}}
{{ :bloc1:fonction_02.png?400 |}}
</WRAP>

===== Utiliser une fonction qui renvoie un résultat (une valeur)=====
Il est possible de ne pas utiliser la variable globale en transformant la fonction pour qu’elle **renvoie** (**retourne**) au programme appelant, la valeur saisie. 

Il faut supprimer la déclaration de la variable globale **essai** et remettre sa déclaration dans le **Main()**, comme c’était avant :
<code c#>
//static int essai; à supprimer
...
static void Main(string[] args)
{
// déclaration
int valeur = 0, essai = 0, nbre = 1;
</code>

Il est nécessaire de déclarer la variable **essai** dans la fonction **saisie()**. 

Cette déclaration va se faire :
  * en changeant le nom de la variable pour l'appeler **nombre** et en l'initialisant en début de fonction ;
  * en modifiant la déclaration de la fonction : **void** est devenu **int** car la fonction va **retourner** une information de type **int** ;
  * en rajoutant à la fin de la fonction la ligne **return nombre;** qui permet de **retourner** le contenu de la variable **nombre** :
<code c#>
static int saisie()
{
  int nombre = 0;
  bool correct = false;
  while (!correct)
  {
    try
    {
      Console.Write("Entrez un essai = ");
      nombre = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch
    {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
  return nombre;
}
</code>

Pour récupérer le retour de la fonction **saisie()** dan* le **Main()** il suffit d’affecter l’appel de la fonction, dans une variable. 

Dans le **Main()**, l’appel de la fonction **saisie()** doit donc être affecté à la variable **essai** pour récupérer dans **essai** l’information saisie. Voici au final le **Main()** :
<code c#>
static void Main(string[] args) {
  // déclaration
  int valeur = 0, essai = 0, nbre = 1;
  bool correct = false;
  // saisie du nombre à chercher
  while (!correct) {
    try { 
      Console.Write("Entrez le nombre à chercher = ");
      valeur = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
  Console.Clear();
  // saisie du premier essai
  essai = saisie();
  // boucle sur les essais
  while (essai != valeur) {
    // test de l’essai par rapport à la valeur à chercher
    if (essai > valeur) {
      Console.WriteLine(" --> trop grand !");
    }
    else {
      Console.WriteLine(" --> trop petit !");
    }
    // saisie d’un nouvel essai
    essai = saisie();
    // compteur d’essais
    nbre++;
  }
  // valeur trouvée
  Console.WriteLine("Vous avez trouvé en "+nbre+" fois !");
  Console.ReadLine();
}
</code>
<WRAP center round todo>
**Exercice 2 :** 

Reprenez le programme de l'exercice 1 et modifiez-le de cette manière afin de renvoyer un résultat.
</WRAP>
===== Rendre la fonction paramétrable =====
Il reste maintenant au début du programme un bloc de code, très similaire à celui copié dans le module **saisie()** :
  * c’est celui qui concerne la saisie de la valeur à chercher ;
  * et la différence est au niveau du **message** qui doit s’afficher.

Voici le bloc de code concerné  :

<code c#>
static void Main(string[] args) 
{
  ...
  bool correct = false;
  // saisie du nombre à chercher
  while (!correct) {
    try { 
      Console.Write("Entrez le nombre à chercher = "); // message qui est différent
      valeur = int.Parse(Console.ReadLine());
      correct = true;
    }
    ...}
</code>

Il est possible :
  * d’ajouter des **paramètres** à une fonction pour lui envoyer une information ;
  * en **ajoutant le paramètre** dans l’entête du module ;
  * et ce paramètre est utilisable dans le module comme une **variable locale** :

<code c#>
static int saisie(string message) // -> paramètre avec son type qui peut recevoir une valeur 
{
  int nombre = 0;
  bool correct = false;
  while (!correct)
  {
    try
    {
      Console.Write(message + " = "); // -> utilisation du paramètre comme une variable locale
      nombre = int.Parse(Console.ReadLine());
      correct = true;
    }
    catch
    {
      Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
    }
  }
  return nombre;
}
</code>
Maintenant, nous pouvons dans le **Main()**, modifier les 3 appels à la fonction **saisie()** pour envoyer une valeur au paramètre.
==== Ajout du paramètre lors de l’appel de la fonction saisie ====
<code c#>
static void Main(string[] args) 
{
  // déclaration
  int valeur = 0, essai = 0, nbre = 1;
  // plus de déclaration de la variable correct à faire //bool correct = false;
  // saisie du nombre à chercher
  valeur = saisie("Entrez le nombre à chercher"); // -> 1er appel de la fonction saisie() avec un message en paramètre
  Console.Clear();
  // saisie du premier essai
  essai = saisie("Entrez un essai"); // -> 2ème appel de la fonction saisie() avec un message en paramètre
  // boucle sur les essais
  while (essai != valeur) 
  {
    // test de l’essai par rapport à la valeur à chercher
    if (essai > valeur) {
      Console.WriteLine(" --> trop grand !");
    }
    else {
      Console.WriteLine(" --> trop petit !");
    }
    // saisie d’un nouvel essai
    essai = saisie("Entrez un essai"); // -> 3ème appel de la fonction saisie() avec un message en paramètre
    // compteur d’essais
    nbre++;
  }
  // valeur trouvée
  Console.WriteLine("Vous avez trouvé en "+nbre+" fois !");
  Console.ReadLine();
}
</code>

  * Les messages d’information **Entrez le nombre à chercher** et **Entrez un essai** sont maintenant transférés dans le paramètre **message** selon les besoins. 

La fonction est paramétrée et le code de la fonction **Main()** est nettement plus court.
<WRAP center round info>
Dépôt GitHub : https://github.com/ctecher/FonctionC_cor.git
</WRAP>

==== Correction ====
[[correction|Correction]]
<code c#>
using System;
class Program
{
    static int saisie(string message)
    {
        bool correct = false;
        int chiffre = 0;
        while (!correct)
        {
            try
            {
                Console.Write(message);
                chiffre = int.Parse(Console.ReadLine());
                correct = true;
            }
            catch
            {
                Console.WriteLine("Erreur de saisie : saisissez un nombre entier");
            }
        }
        return chiffre;
    }

    public static void Main(string[] args)
    {
        // déclaration
        int valeur = 0, essai = 0, nbre = 1;

        // saisie du nombre à chercher
        valeur = saisie("Entrez le nombre à chercher = ");

        Console.Clear();
        // saisie du premier essai
        essai = saisie("Entrez un essai = ");

        // boucle sur les essais
        while (essai != valeur)
        {
            // test de l’essai par rapport à la valeur à chercher
            if (essai > valeur)
            {
                Console.WriteLine(" --> trop grand !");
            }
            else
            {
                Console.WriteLine(" --> trop petit !");
            }
            // saisie d’un nouvel essai
            essai = saisie("Entrez un essai = ");
            // compteur d’essais
            nbre++;
        }
        // valeur trouvée
        Console.WriteLine("Vous avez trouvé en " + nbre + " fois !");
        Console.ReadLine();
    }
}
</code>

==== Aller plus loin avec plusieurs paramètres ====
<WRAP center round info>
Il est possible de mettre plusieurs paramètres à une fonction.

**Exemple :** 
<code c#>
static int saisie(string message, int borneMin, int borneMax)
</code>
</WRAP>
Les cours du BTS SIO

Outils pour utilisateurs

Outils du site

Outils de la page
