Dans ce cours, nous allons aborder la notion de modularisation en programmation, qui est un concept fondamental pour rendre le code plus structuré, plus facile à comprendre et à maintenir. Ensuite, nous allons découvrir les fonctions en C#, leur définition, la manière dont elles prennent des paramètres et renvoient des valeurs. Enfin, nous terminerons avec des exercices pratiques pour modulariser des programmes complexes.

I. Notions de Modularisation et Définition de Fonctions en C

1.1. Qu’est-ce que la modularisation ?

La modularisation en programmation consiste à diviser un programme en plusieurs sous-parties appelées modules. Chaque module ou fonction est conçu pour accomplir une tâche précise. Ce concept est essentiel pour améliorer la lisibilité, la maintenance, et la réutilisation du code.

Avantages de la modularisation :

• Lisibilité améliorée : En divisant un programme en modules plus petits, chaque fonction devient plus facile à lire et à comprendre. Au lieu d’avoir un long bloc de code, on a des parties spécifiques qui accomplissent des tâches claires.
• Réutilisabilité du code : Une fois qu’une fonction est créée, elle peut être réutilisée dans différentes parties du programme ou même dans d’autres programmes.
• Maintenance facilitée : Si un bug est trouvé dans une fonction, il est plus facile à corriger car la fonction est isolée. Cela réduit également les risques d’introduire de nouveaux bugs dans d’autres parties du code.
• Tests plus simples : Il est plus facile de tester une fonction spécifique de manière indépendante avant de l’intégrer à un programme plus large.

1.2. Les fonctions en C

En C#, une fonction est un bloc de code qui peut être appelé pour accomplir une tâche spécifique. Les fonctions permettent de regrouper des instructions qui peuvent être exécutées plusieurs fois sans répéter le code.

Structure d’une fonction en C# :

1. Type de retour : Ce que la fonction renvoie après avoir exécuté ses instructions. Cela peut être n’importe quel type de données (int, string, bool, etc.) ou void si la fonction ne renvoie rien.
2. Nom de la fonction : Doit être un nom explicite qui décrit l’action accomplie par la fonction.
3. Paramètres : Ce sont les valeurs que la fonction peut recevoir pour exécuter une tâche. Ils sont définis entre parenthèses après le nom de la fonction.
4. Corps de la fonction : C’est là que se trouve l’ensemble des instructions que la fonction exécute.

Exemple d’une fonction en C# :

public int Addition(int a, int b)
{
return a + b;
}

Dans cet exemple :

• Le type de retour est int, ce qui signifie que la fonction renverra un nombre entier.
• Le nom de la fonction est Addition.
• La fonction prend deux paramètres int a et int b.
• Elle renvoie la somme de ces deux paramètres.

Pour appeler cette fonction, vous pouvez faire :

int resultat = Addition(5, 3); // resultat vaudra 8

II. Passage de Paramètres et Retour de Valeurs

2.1. Le passage de paramètres

Les paramètres permettent de passer des informations aux fonctions. Lorsque vous appelez une fonction, vous pouvez lui fournir des arguments qui seront utilisés dans les instructions de la fonction.

Il existe plusieurs façons de passer des paramètres dans une fonction en C# :

• Passage par valeur : Le paramètre est copié dans la fonction. Toute modification du paramètre à l’intérieur de la fonction n’affecte pas la valeur originale.

Exemple :

public void AfficherNombre(int nombre)
{
nombre = 10;
Console.WriteLine(nombre); // Affichera 10
}

int monNombre = 5;
AfficherNombre(monNombre);
Console.WriteLine(monNombre); // Affichera toujours 5 car la fonction ne modifie pas la valeur originale

• Passage par référence : En utilisant le mot-clé ref, la fonction reçoit une référence à la variable d’origine. Toute modification du paramètre affectera la valeur originale.

Exemple :

public void ModifierNombre(ref int nombre)
{
nombre = 10;
}

int monNombre = 5;
ModifierNombre(ref monNombre);
Console.WriteLine(monNombre); // Affichera 10 car la valeur originale a été modifiée

2.2. Retour de valeurs

Une fonction peut renvoyer une valeur après son exécution. Le mot-clé return permet de spécifier quelle valeur renvoyer. Une fois que return est appelé, la fonction s’arrête et renvoie cette valeur à l’appelant.

Exemple avec retour de valeur :

public string DireBonjour(string prenom)
{
return "Bonjour, " + prenom;
}

string message = DireBonjour("Gilblas");
Console.WriteLine(message); // Affichera : Bonjour, Gilblas

III. Activités Pratiques : Création de Fonctions pour Modulariser des Programmes Complexes

1. Exercice 1 : Calculatrice Simple

Créez une fonction qui effectue des opérations de base telles que l’addition, la soustraction, la multiplication et la division.

public double Calculatrice(double a, double b, string operation)
{
switch (operation)
{
case "+":
return a + b;
case "-":
return a - b;
case "*":
return a * b;
case "/":
return a / b;
default:
throw new InvalidOperationException("Opération non valide.");
}
}

Utilisation :

double resultat = Calculatrice(10, 5, "+"); // Affichera 15
Console.WriteLine(resultat);

2. Exercice 2 : Gestion des Notes

Créez une fonction qui prend une liste de notes et retourne la note moyenne, la note la plus élevée et la note la plus basse.

public (double moyenne, double max, double min) StatistiquesNotes(double[] notes)
{
double moyenne = notes.Average();
double max = notes.Max();
double min = notes.Min();
return (moyenne, max, min);
}

Utilisation :

double[] notes = { 12.5, 15, 18, 10 };
var stats = StatistiquesNotes(notes);
Console.WriteLine($"Moyenne: {stats.moyenne}, Max: {stats.max}, Min: {stats.min}");

3. Exercice 3 : Programme de Gestion de Stock

Créez des fonctions pour gérer un inventaire simple. La première fonction doit ajouter des articles, la deuxième doit les retirer, et la troisième doit afficher l’état de l’inventaire.

Conclusion

Dans cette leçon, nous avons exploré les concepts de modularisation et les fonctions en C#. Nous avons appris à définir des fonctions, à passer des paramètres, et à retourner des valeurs. Les exercices pratiques permettent de voir comment ces notions peuvent être appliquées pour organiser et simplifier des programmes complexes.