Fiche de révision : Introduction aux fonctions en programmation C

📋 Plan du Cours

1. Fonctions et programmation modulaire
2. Syntaxe des fonctions et procédures
3. Passage par valeur et par adresse
4. Fonctions itératives
5. Fonctions récursives
6. Pointeurs et fonctions
7. Choisir entre itératif et récursif

📖 1. Fonctions et programmation modulaire

🔑 Notions clés & Définitions

• Programmation modulaire : La programmation modulaire consiste à découper un problème complexe en modules simples traités séparément.
• Fonction : Une fonction est un sous-programme regroupant un traitement réutilisable sous un nom pour éviter de répéter des instructions.
• Procédure : Une procédure est un sous-programme qui exécute une action sans renvoyer de valeur.

📝 Points essentiels

• En C, les modules prennent souvent la forme de fonctions ou de procédures.
• Une fonction permet de réutiliser un traitement plusieurs fois et de mieux structurer un problème en sous-problèmes.
• Une fonction retourne une valeur et peut être utilisée dans une expression, alors qu’une procédure ne renvoie rien et a un type void.

💡 Astuce mémo

Découpe = modules, action = procédure, valeur = fonction.

📖 2. Syntaxe des fonctions et procédures

🔑 Notions clés & Définitions

• Prototype de fonction : Un prototype annonce l’interface d’une fonction avant son utilisation pour que le compilateur connaisse ses types.
• Forme générale fonction : La forme générale d’une fonction décrit le type de retour, le nom, la liste des paramètres et un corps avec return.
• Forme générale procédure : La forme générale d’une procédure utilise void, un nom de procédure, une liste de paramètres et un corps sans return de valeur.

📝 Points essentiels

• Une fonction non void doit renvoyer une valeur via return.
• Un prototype ressemble à une déclaration de type et paramètres, par exemple int min(int a, int b);
• Une procédure a un retour void et sert à exécuter des traitements sans valeur renvoyée.

💡 Astuce mémo

Prototype avant usage, fonction avec return, procédure sans valeur.

📖 3. Passage par valeur et par adresse

🔑 Notions clés & Définitions

• Passage par valeur : Le passage par valeur consiste à envoyer des copies des arguments afin que les modifications dans la fonction n’affectent pas les variables originales.
• Passage par adresse : Le passage par adresse transmet l’adresse d’une variable pour permettre à la fonction de modifier directement la variable originale.
• Opérateur adresse : L’opérateur & produit l’adresse d’une variable, utilisée pour passer par adresse.

📝 Points essentiels

• En C, les arguments sont passés par valeur par défaut.
• Pour lire une valeur pointée, on utilise *a, et pour transmettre l’adresse d’un entier x on utilise &x.
• Une permutation via paramètres par valeur ne modifie pas les originaux, tandis qu’une permutation via pointeurs modifie les originaux.

💡 Astuce mémo

Valeur = copie, Adresse = cible : modifie ce que tu pointes.

📖 4. Fonctions itératives

🔑 Notions clés & Définitions

• Fonction itérative : Une fonction itérative applique un traitement répété en utilisant une boucle.
• Boucle for : Une boucle for exécute un corps en contrôlant une variable d’itération et une condition d’arrêt.
• Boucle while : Une boucle while répète le corps tant qu’une condition reste vraie.
• Boucle do while : Une boucle do while exécute d’abord le corps puis teste la condition pour continuer.

📝 Points essentiels

• Une fonction itérative répète un traitement grâce à une boucle, typiquement for, while ou do while.
• La factorielle itérative initialise f à 1 puis multiplie successivement par i de 1 à n et renvoie f.
• Pour calculer n! avec la version récursive, on utilise un appel sur n-1, alors que la version itérative parcourt i de 1 à n sans appel récursif.

💡 Astuce mémo

Itératif = boucle qui avance : i=1 à n.

📖 5. Fonctions récursives

🔑 Notions clés & Définitions

• Récursivité : La récursivité est le mécanisme où une fonction s’appelle elle-même pendant son exécution.
• Cas de base : Le cas de base est la condition d’arrêt qui évite une récursion infinie.
• Relation de récurrence : La relation de récurrence décrit comment calculer le résultat courant à partir d’un appel sur un problème plus petit.
• Factorielle récursive : La factorielle récursive calcule n! en utilisant le produit de n avec la factorielle de n-1 et un cas d’arrêt pour n=0.

📝 Points essentiels

• Une fonction récursive s’appelle elle-même et doit inclure un cas de base plus une règle de réduction.
• La factorielle récursive renvoie 1 quand n vaut 0, sinon elle renvoie n fois factorielle_rec(n-1).
• La fonction fib donnée retourne 1 quand n vaut 0 ou 1, sinon elle renvoie fib(n-1)+fib(n-2).
• Le PGCD récursif utilise l’appel pgcd(b, a % b) et s’arrête quand b vaut 0.

💡 Astuce mémo

Récursif = base pour s’arrêter, sinon réduire : n → n-1 ou (a,b) → (b,a%b).

📖 6. Pointeurs et fonctions

🔑 Notions clés & Définitions

• Pointeur vers un entier : Un pointeur vers un entier est une variable qui contient l’adresse d’un entier.
• Déréférencement : Le déréférencement via * donne la valeur située à l’adresse stockée dans un pointeur.
• Adresse d’une variable : L’adresse d’une variable désigne son emplacement mémoire, obtenue avec &.
• Pointeur sur fonction : Un pointeur sur fonction est une variable qui référence une fonction afin de l’appeler indirectement.

📝 Points essentiels

• En C, int *a signifie que a pointe vers un entier, *a désigne la valeur pointée, et &x désigne l’adresse de x.
• Une procédure permuter(int *a, int *b) échange correctement en utilisant temp = *a puis *a = *b puis *b = temp.
• La signature d’un pointeur sur fonction suit la forme type_retour (*nom_pointeur)(types des paramètres).
• L’appel via pointeur s’écrit pf(4, 6) après affectation pf = addition.

💡 Astuce mémo

*lit la cible, &pointe la cible, pf( ) appelle via le lien.

📖 7. Choisir entre itératif et récursif

🔑 Notions clés & Définitions

• Traitement itératif : Un traitement itératif convient quand les étapes sont répétitives et progressent sur une suite simple.
• Traitement récursif : Un traitement récursif convient quand le problème se reformule naturellement en une version plus petite du même problème.
• Structure arborescente : Une structure arborescente se prête à la récursivité car chaque nœud peut être vu comme racine d’un sous-arbre.

📝 Points essentiels

• On privilégie l’itératif pour un parcours séquentiel de tableau, un cumul, une recherche de maximum ou de minimum, un comptage, ou une simulation répétée.
• On privilégie le récursif pour factorielle, Fibonacci, PGCD, parcours d’arbres, et problèmes de division en sous-problèmes.
• Dans le choix pratique, l’itératif est mis en avant pour limiter la mémoire, et le récursif pour la définition mathématique et les structures imbriquées.

💡 Astuce mémo

Itératif = suite d’étapes simples, récursif = problème qui se réduit (ou arbre).

📊 Tableaux de synthèse

Valeur vs adresse

⚠️ Pièges & confusions fréquents

1. Confondre fonction et procédure conduit à utiliser return avec une procédure ou à oublier return dans une fonction non void.
2. Croire que la modification de paramètres par valeur change les variables du main, alors que ce sont des copies.
3. Lire la syntaxe *a et penser que * signifie adresse au lieu de valeur pointée.
4. Oublier un cas de base en récursivité, ce qui rend la récursion non terminante.
5. Mélanger itératif et récursif pour un même exercice, par exemple écrire Fibonacci en boucle sans respecter la logique n-1 et n-2.
6. Se tromper dans l’appel via pointeur sur fonction en écrivant une invocation directe au lieu de pf( ).

✅ Checklist Examen

1. Définir programmation modulaire et expliquer en quoi les fonctions/procédures servent de modules.
2. Distinguer fonction et procédure et donner la règle sur la présence de return et le type void.
3. Écrire la forme générale d’une fonction et celle d’une procédure sans réutiliser un fragment de code du cours.
4. Expliquer ce qu’est un prototype et à quoi il sert avant l’utilisation.
5. Dire pourquoi une fonction non void doit renvoyer une valeur via return.
6. Expliquer le passage par valeur et conclure sur l’effet des modifications des paramètres dans la fonction.
7. Expliquer le passage par adresse et l’usage de &x et *a.
8. Écrire une permutation correcte avec pointeurs et décrire le rôle de temp.
9. Identifier les éléments d’un pointeur vers un entier : int *a, *a comme valeur pointée, &x comme adresse.
10. Écrire la forme d’un pointeur sur fonction et donner la manière d’appeler une fonction via ce pointeur.
11. Choisir des cas d’usage itératifs et récursifs en s’appuyant sur les critères du cours.
12. Construire et expliquer un exemple itératif de somme/tableau et un exemple récursif de factorielle/PGCD.