Fiche de révision : Maîtrise des fonctions et paradigmes de programmation

📋 Plan du Cours

1. Utilisation et déclaration des fonctions
2. Définition, procédure et paramètres
3. Copie, référence et const
4. Arguments par défaut et surcharge
5. Fonctions génériques et opérateurs
6. API, fichiers d’en-tête et Makefile
7. Paradigmes impératif, procédural et modulaire
8. Concept objet et réutilisabilité

📖 1. Utilisation et déclaration des fonctions

🔑 Notions clés & Définitions

• Déclaration de fonction : La déclaration indique au compilateur le type de retour, le nom et le profil des arguments afin de permettre la compilation avant la définition.
• Définition de fonction : La définition contient le code effectif de la fonction, et doit être unique (dans un fichier du programme, ailleurs, ou via une librairie).
• Appel de fonction : L’appel exécute la fonction depuis le corps du programme en fournissant des paramètres effectifs correspondant aux arguments attendus.

📝 Points essentiels

• Une fonction doit être déclarée au moins une fois avant d’être utilisée si la définition ne précède pas l’appel.
• La déclaration fixe type de retour, nom et nombre/type des arguments, ce qui permet des vérifications de type à la compilation.
• La définition d’une fonction doit être unique et peut venir d’un autre fichier ou d’une librairie (exemples sin et cos).
• Si la définition précède l’utilisation dans un fichier, la déclaration devient inutile pour ce cas précis.

📖 2. Définition, procédure et paramètres

🔑 Notions clés & Définitions

• Fonction : Une fonction renvoie une valeur d’un type donné, ou le type void si elle ne retourne rien.
• Procédure : Une procédure est une routine sans valeur de retour, typiquement déclarée avec void.
• Paramètres formels : Les paramètres formels sont les noms utilisés dans la définition pour manipuler les valeurs reçues par la fonction.
• Paramètres effectifs : Les paramètres effectifs sont les expressions passées lors de l’appel, recopiées vers les paramètres formels (cas par copie).

📝 Points essentiels

• Une fonction se termine toujours par un return qui renvoie le résultat de la fonction.
• Une procédure se déclare avec void, puis exécute ses instructions sans renvoyer de valeur.
• Le nom des paramètres est optionnel dans la déclaration, mais nécessaire pour les manipuler dans la définition.
• À l’appel, chaque paramètre effectif est recopié dans le paramètre formel (passage par copie).

📖 3. Copie, référence et const

🔑 Notions clés & Définitions

• Passage de paramètres par copie : Le passage par copie donne à la fonction des valeurs dupliquées, de sorte qu’une modification interne n’affecte pas l’appelant.
• Passage de paramètres par référence : Le passage par référence fait travailler la fonction sur les variables originales grâce à un & sur les paramètres formels.
• const : Le modifieur const indique qu’un argument passé (ici par référence) ne doit pas être modifié à l’intérieur de la fonction.

📝 Points essentiels

• Avec la copie, modifier un paramètre dans la fonction ne modifie pas la variable du programme appelant.
• Le passage par copie peut coûter du temps car la copie des paramètres peut être coûteuse.
• Avec la référence, on supprime la copie et la fonction peut modifier les variables de l’appelant.
• const sur une référence rend l’argument en lecture seule et peut déclencher une erreur à la compilation lors d’une affectation.

📖 4. Arguments par défaut et surcharge

🔑 Notions clés & Définitions

• Arguments par défaut : Les arguments par défaut permettent de rendre certains paramètres optionnels en fournissant une valeur par défaut dans la déclaration.
• Surcharge des fonctions : La surcharge permet d’utiliser le même nom pour plusieurs fonctions distinctes selon la signature (types/nombre d’arguments).

📝 Points essentiels

• Les valeurs par défaut sont spécifiées uniquement au niveau de la déclaration.
• Les paramètres avec valeur par défaut doivent être consécutifs et placés à droite de la liste des paramètres.
• Le choix de la fonction surchargée se fait sur la signature (types et nombre d’arguments).
• Attention aux conversions implicites de types et aux paramètres optionnels qui peuvent mener à une résolution inattendue.

📖 5. Fonctions génériques et opérateurs

🔑 Notions clés & Définitions

• Fonctions génériques : Les fonctions génériques (templates) décrivent un patron de fonction réutilisable pour différents types, généré à la compilation.
• Template <typename T> : Le paramètre de type du template permet d’adapter la fonction à des types variés lors de l’instanciation.
• Surcharge d’opérateurs : La surcharge d’opérateurs permet de définir le comportement d’un opérateur (comme <) pour des types non primitifs.

📝 Points essentiels

• Les patrons de fonction génériques peuvent être surchargés, comme les fonctions classiques.
• Le compilateur crée la version de la fonction générique à la compilation à partir du modèle et des types utilisés.
• Pour surcharger un opérateur, il faut préserver la signature (uniaire, binaire, etc.).
• Avec operator < entre deux ville, la comparaison s’effectue via l’attribut population pour choisir le moins peuplé.

📖 6. API, fichiers d’en-tête et Makefile

🔑 Notions clés & Définitions

• Fichier d’en-tête : Le fichier d’en-tête regroupe les déclarations publiques nécessaires à l’usage d’un type ou d’une bibliothèque.
• API (Application Programming Interface) : Une API expose autour du type des déclarations et fonctions destinées à être utilisées par d’autres programmes.
• Makefile : Un Makefile décrit des règles de compilation et d’assemblage à partir de cibles et de dépendances.

📝 Points essentiels

• L’organisation type Ville utilise un en-tête pour déclarations et un fichier source pour définitions, puis main inclut l’en-tête.
• Les déclarations publiques (type, constantes, fonctions) servent d’interface, tandis que l’implémentation peut rester cachée.
• Dans le Makefile, une cible est suivie de ses dépendances sans espace à gauche et les commandes commencent par une tabulation.
• Les variables comme CXX contiennent le compilateur, et les macros $@ (cible) et$^ (dépendances) sont utilisées dans les règles.

📖 7. Paradigmes impératif, procédural et modulaire

🔑 Notions clés & Définitions

• Programmation impérative : Le problème est décomposé en une suite d’instructions, comme dans une exécution pas à pas.
• Programmation procédurale : Le problème est décomposé en fonctionnalités, en structurant l’application par fonctions selon un ordre descendant.
• Programmation modulaire : Le problème est éclaté en sous-problèmes indépendants sous forme de modules, sans hiérarchie hiérarchique stricte.

📝 Points essentiels

• En impératif, la solution suit une suite d’instructions, et l’approche ne met pas l’accent sur la réutilisabilité via contrôle de qualité des données.
• En procédural, la décomposition par fonctionnalités peut souffrir de dépendances entre fonctions et exige souvent la déclaration avant appel.
• En modulaire, les modules représentent des entités du monde réel offrant des services via une interface et un code via une implémentation.
• Les architectures modulaires visent unité modulaire, interface minimale explicite, couplage faible, masquage de l’information, et indépendance de l’ordre d’appel.

📖 8. Concept objet et réutilisabilité

🔑 Notions clés & Définitions

• Programmation objet : La programmation objet fait évoluer le concept modulaire en introduisant un objet qui est à la fois une entité du monde réel et un type réutilisable.
• Réutilisabilité : La réutilisabilité est la capacité d’un logiciel à être exploité facilement par de nouvelles applications.
• Extensibilité : L’extensibilité est la possibilité d’ajouter facilement de nouvelles spécifications au logiciel.
• Validité : La validité impose que le logiciel réalise exactement les tâches pour lesquelles il a été conçu.

📝 Points essentiels

• Le concept objet corrige les limitations des modules en apportant un type, pas seulement une entité syntaxique.
• L’évolution mentionnée relie l’objet à la réutilisabilité et à l’extensibilité, tout en visant la validité du comportement du logiciel.
• Un module n’est pas un type de données mais une entité syntaxique conceptuelle, ce qui limite la généricité et l’évolution de la précision.
• Le cours annonce que l’héritage appartient au mécanisme objet, en distinguant héritage et assemblage modulaire sans généricité.

📊 Tableaux de synthèse

Copie vs référence

⚠️ Pièges & confusions fréquents

1. Confondre déclaration et définition : déclarer fixe le profil pour compiler, mais le code n’est défini qu’une seule fois dans la définition.
2. Croire que passer par copie permet de modifier l’appelant : en réalité les paramètres sont recopiés et le main garde ses valeurs.
3. Oublier que const sur une référence empêche toute affectation : cela mène à une erreur de compilation si on tente de modifier l’argument.
4. Penser que tous les paramètres par défaut peuvent être dispersés : ils doivent être consécutifs et situés les plus à droite.
5. Résoudre une surcharge en ignorant la signature : le compilateur choisit selon types et nombre d’arguments, et les conversions implicites peuvent tromper.
6. Surcharger un opérateur sans respecter sa signature (uniaire/binaire) : la surcharge doit garder la forme de l’opérateur attendue.

✅ Checklist Examen

1. Savoir distinguer déclaration, définition et appel, et reconnaître quand la déclaration est obligatoire avant utilisation.
2. Savoir ce qu’impose la déclaration : type de retour, nom, nombre et types des arguments, ainsi que les vérifications/conversions à la compilation.
3. Savoir ce qu’impose la définition : unicité, possibilité via un autre fichier ou une librairie, et terminaison par return pour une fonction.
4. Savoir distinguer fonction et procédure, et identifier un exemple de procédure avec void.
5. Savoir distinguer paramètres formels et effectifs, et l’option sur le nom des paramètres en déclaration.
6. Savoir expliquer la différence entre passage par copie et passage par référence, y compris l’impact sur la modification des variables appelantes.
7. Savoir utiliser const avec une référence pour obtenir une lecture seule, et comprendre l’erreur de compilation en cas d’affectation.
8. Savoir définir et appliquer des arguments par défaut : déclaration uniquement, consécutifs, à droite, et rendre optionnels les appels manquants.
9. Savoir raisonner la surcharge : même nom, signature différente, sélection par types/nombre d’arguments, et vigilance conversions implicites.
10. Savoir décrire les fonctions génériques : template, instanciation à la compilation et possibilité de surcharger des templates.
11. Savoir décrire la surcharge d’opérateur : mot-clé operator, contrainte de signature et définition du comportement pour un type utilisateur.
12. Savoir expliquer l’intérêt de séparer type et programme via en-tête (API déclarations) et fichier source (implémentations cachées).
13. Savoir interpréter les règles clés d’un Makefile : cible/dépendances, tabulation avant commandes, et usage de CXX, $@,$^.
14. Savoir comparer impératif, procédural et modulaire par leur logique de décomposition et les caractéristiques (qualité/dépendances/réutilisabilité).