Dans la première partie de cette formation, l'ensemble de notre code résidait dans une fonction unique : main(). Si cette approche convient pour des scripts de quelques dizaines de lignes, elle devient ingérable pour des projets d'envergure. Un fichier source monolithique de plusieurs milliers de lignes est illisible, impossible à tester unitairement et conduit inévitablement à la duplication de code.

La solution universelle du génie logiciel s'appelle la modularité : découper un problème complexe en sous-problèmes plus simples, résolus chacun par une fonction dédiée.

---

1. Pourquoi concevoir des fonctions ?

En programmation, le principe fondamental est le DRY (Don't Repeat Yourself - Ne vous répétez pas) :

• Éviter la redondance : Un algorithme complexe (par exemple le calcul d'une moyenne ou le tri d'une liste) n'est écrit qu'une seule fois. Si une correction ou une optimisation est nécessaire, elle s'applique immédiatement à tous les endroits du programme qui appellent cette fonction.
• Lisibilité et clarté : Un programme dont la fonction main() se lit comme une liste d'étapes à haut niveau (InitialiserBase(); SaisirNotes(); CalculerMoyennes(); AfficherResultats();) est infiniment plus compréhensible.
• Réutilisabilité : Une fonction bien conçue peut être copiée et réutilisée dans de futurs projets logiciels ou partagée sous forme de bibliothèque.
• Testabilité unitaire : Il est aisé de vérifier la validité d'une petite fonction indépendamment du reste du système.

---

2. Typologie : Les 4 formes de fonctions

Une fonction se caractérise par ses paramètres d'entrée et sa valeur de retour (sortie). Selon les besoins, elle adopte l'un des quatre archétypes :

flowchart TD
    subgraph F1 [1. Sans entrée & Sans sortie]
        P1["void AfficherMenu(void)"]
    end
    subgraph F2 [2. Sans entrée & Avec sortie]
        P2["int TirerDe(void)"]
    end
    subgraph F3 [3. Avec entrées & Sans sortie]
        P3["void ImprimerLigne(int n, char motif)"]
    end
    subgraph F4 [4. Avec entrées & Avec sortie]
        P4["float CalculerMoyenne(float n1, float n2)"]
    end

1. Sans entrée et sans sortie (void ... void)

Utilisée généralement pour des affichages statiques ou des réinitialisations :

void AfficherBanniere(void)
{
    printf("=========================================\n");
    printf("   PORTAIL ETUDIANT - UNIVERSITE C       \n");
    printf("=========================================\n");
}

2. Sans entrée et avec sortie (type ... void)

Génère ou récupère une information autonome (par exemple tirer un nombre aléatoire ou lire l'horloge système) :

int LancerDe(void)
{
    // Renvoie un entier aléatoire entre 1 et 6
    return (rand() % 6) + 1;
}

3. Avec entrées et sans sortie (void ... parametres)

Appelée traditionnellement une procédure : elle reçoit des données pour agir sur l'environnement extérieur sans renvoyer de calcul numérique :

void AfficherBulletin(char initiale, float moyenne)
{
    printf("Etudiant [%c] -> Moyenne finale : %.2f/20\n", initiale, moyenne);
}

4. Avec entrées et avec sortie (type ... parametres)

Le modèle canonique de la fonction mathématique pure : reçoit des arguments, effectue un calcul et retourne le résultat :

float ConvertirCelsiusEnFahrenheit(float celsius)
{
    return (celsius * 9.0f / 5.0f) + 32.0f;
}

---

Sommaire de la Partie 2

1. Les fonctions : Déclaration, Prototypes et Portée
2. Les fonctions récursives (Arbre d'appels & Cas de base)
3. Les modules et fichiers d'en-tête (.h et .c)
4. Applications pratiques et exercices corrigés

---

Prêt à structurer vos programmes ? Rendez-vous dans le chapitre suivant pour maîtriser la déclaration des prototypes et le passage de paramètres.

Partagez sur les réseaux sociaux

Commentaires