Cours de C/C++

Publié par

Cours de C/C++
Christian Casteyde Cours de C/C++
par Christian Casteyde
Copyright (c) 2000 Christian Casteyde
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front Cover Texts, and with no
Back Cover Texts.
A copy of the license is included in the section entitled "GNU Free Documentation License".
Copyright (c) 2000 Christian Casteyde
Permission vous est donnée de copier, distribuer et modifier ce document selon les termes de la licence GNU pour les documentations libres,
version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation.
Une copie de cette licence est incluse dans l’annexe intitulée "GNU Free Documentation License". Vous trouverez également une traduction
non officielle de cette licence dans l’annexe intitulée "Licence de documentation libre GNU".
Historique des versions
Version 1.40.1 09/09/2001 Revu par : CC
Corrections orthographiques. Précisions sur les optimisations des opérateurs d’incrémentation et de décrémentation postfixes et préfixes. Précision sur l’optimisation des copies de variables temporaires. Changement de l’exemple du mot clé explicit. Clarification des notions de surcharge et de redéfinition des fonctions.
Version 1.40.0 30/07/2001 Revu par : CC
Version finale. Réorganisation partielle de la première partie. Scission du chapitre ...
Publié le : vendredi 6 mai 2011
Lecture(s) : 254
Nombre de pages : 501
Voir plus Voir moins
Cours de C/C++ Christian Casteyde Cours de C/C++ par Christian Casteyde Copyright (c) 2000 Christian Casteyde Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front Cover Texts, and with no Back Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". Copyright (c) 2000 Christian Casteyde Permission vous est donnée de copier, distribuer et modifier ce document selon les termes de la licence GNU pour les documentations libres, version 1.1 ou toute autre version ultérieure publiée par la Free Software Foundation. Une copie de cette licence est incluse dans l’annexe intitulée "GNU Free Documentation License". Vous trouverez également une traduction non officielle de cette licence dans l’annexe intitulée "Licence de documentation libre GNU". Historique des versions Version 1.40.1 09/09/2001 Revu par : CC Corrections orthographiques. Précisions sur les optimisations des opérateurs d’incrémentation et de décrémentation postfixes et préfixes. Précision sur l’optimisation des copies de variables temporaires. Changement de l’exemple du mot clé explicit. Clarification des notions de surcharge et de redéfinition des fonctions. Version 1.40.0 30/07/2001 Revu par : CC Version finale. Réorganisation partielle de la première partie. Scission du chapitre contenant les structures de contrôle et les définitions de types complexes en deux chapitres. Clarification du chapitre traitant des structures de contrôle. Déplacement du chapitre sur la lisibilité et précisions diverses. Clarification de la notion d’instruction. Corrections diverses dans le chapitre traitant de la couche objet. Précisions sur la locale codecvt dans la partie de la librairie standard. Corrections orthographiques de la partie traitant de la librairie standard. Version 1.39.99 24/06/2001 Revu par : CC Description des locales standards. Précision sur l’initialisation des variables lors de leurs déclarations. Précision sur les droits d’accès aux membres des classes hôtes dans le cas des classes chaînées. Corrections orthographiques. Version 1.39.4 27/05/2001 Revu par : CC Description des flux d’entrée / sortie de la librairie standard. Modification de la présentation sommaire des flux dans le chapitre sur les fonctionnalités objet du C++. Présentation sommaire des locales. Version 1.39.3 03/05/2001 Revu par : CC Description des algorithmes de la librairie standard. Version 1.39.2 22/04/2001 Revu par : CC Description des conteneurs de la librairie standard. Ajout d’une traduction de la licence FDL. Suppression des symboles :, …, — et – qui ne passaient ni en HTML, ni en RTF (les symboles ’:’ et ’–’ ne sont plus formatés correctement dans le format Adobe Acrobat, mais les autres formats sont à présent corrects). Version 1.39.1 05/03/2001 Revu par : CC Description des types de données complémentaires de la librairie standard C++. Correction du comportement du bloc catch des constructeurs try. Réorganisation du document en deux parties, l’une pour le langage, l’autre pour la librairie standard. Ajout des sources des programmes d’exemple dans la distribution. Correction de quelques erreurs sur les opérateurs new et delete avec placement et clarification des explications. Correction d’une erreur dans l’exemple de la classe Bag. Version 1.39.0 04/02/2001 Revu par : CC Mise en conformité des en têtes C++ des exemples avec la norme. Correction des exemples utilisant des noms réservés par la librairie standard. Complément sur les exceptions. Corrections sur l’instanciation des template et précisions sur leur édition de liens. Première ébauche de description de la librairie standard C++. Version 1.38.1 14/10/2000 Revu par : CC Précisions sur les classes de base virtuelles. Corrections orthographiques. Version 1.38.0 01/10/2000 Revu par : CC Corrections typographiques. Précisions sur les opérateurs & et *. Version 1.37 23/08/2000 Revu par : CC Passage au format de fichier SGML. Ajout des liens hypertextes. Corrections mineures. Version 1.36 27/07/2000 Revu par : CC Complément sur les parenthèses dans les définitions de macros. Corrections sur la numérotation des paragraphes. Version 1.35 10/07/2000 Revu par : CC Corrections sur les déclarations using. Version 1.34 09/07/2000 Revu par : CC Passage en licence FDL. Ajout de la table des matières. Version 1.33 22/60/2000 Revu par : CC Correction d’une erreur dans le paragraphe sur les paramètres template template. Corrections orthographiques diverses. Version 1.32 17/06/2000/ Revu par : CC Correction d’une erreur dans le programme d’exemple du premier chapitre. Correction d’une erreur dans un exemple sur la dérivation. Précisions sur le comportement du mot clef const. Corrections orthographiques diverses. Version 1.31 12/02/2000 Revu par : CC Corrections mineurs. Ajout du paragraphe sur la spécialisation d’une fonction membre d’une classe template. Version 1.30 05/12/1999 Revu par : CC Ajout de la licence. Modifications mineures du formatage. Version<1.30 <1998 Revu par : CC Version initiale. Table des matières Avant propos..................................................................................................................................... 18 I. Le langage C++.............................................................................................................................. 20 1. Première approche du C/C++................................................................................................ 22 1.1. Les commentaires en C++........................................................................................ 23 1.2. Les types prédéfinis du C/C++ ................................................................................. 23 1.3. Notation des valeurs ................................................................................................. 26 1.4. La définition des variables........................................................................................ 28 1.5. Instructions et opérations.......................................................................................... 30 1.6. Les fonctions ............................................................................................................ 33 1.6.1. Définition des fonctions ............................................................................... 33 1.6.2. Appel des fonctions...................................................................................... 34 1.6.3. Déclaration des fonctions............................................................................. 35 1.6.4. Surcharge des ............................................................................... 36 1.6.5. Fonctions inline............................................................................................ 37 1.6.6. F statiques....................................................................................... 38 1.6.7. Fonctions prenant un nombre variable de paramètres ................................. 38 1.7. La fonction main....................................................................................................... 41 1.8. Les fonctions d’entrée / sortie de base ..................................................................... 41 1.8.1. Généralités sur les flux d’entrée / sortie en C .............................................. 42 1.8.2. La fonction printf ......................................................................................... 43 1.8.3. La fonction scanf.......................................................................................... 45 1.9. Exemple de programme complet.............................................................................. 46 2. Les structures de contrôle ..................................................................................................... 47 2.1. La structure conditionnelle if.................................................................................... 47 2.2. La boucle for............................................................................................................. 48 2.3. Le while.................................................................................................................... 49 2.4. Le do......................................................................................................................... 49 2.5. Le branchement conditionnel ................................................................................... 50 2.6. Le saut ...................................................................................................................... 51 2.7. Les commandes de rupture de séquence .................................................................. 52 3. Types avancés et classes de stockage.................................................................................... 54 3.1. Structures de données et types complexes................................................................ 54 3.1.1. Les structures ............................................................................................... 54 3.1.2. Les unions .................................................................................................... 56 3.1.3. Les énumérations ......................................................................................... 57 3.1.4. Les champs de bits....................................................................................... 58 3.1.5. Initialisation des structures et des tableaux.................................................. 59 3.1.6. Les alias de types ......................................................................................... 60 3.1.7. Transtypages ................................................................................................ 61 3.2. Les classes de stockage ............................................................................................ 61 4. Les pointeurs et références.................................................................................................... 66 4.1. Notion d’adresse....................................................................................................... 66 4 4.2. Notion de pointeur.................................................................................................... 66 4.3. Déréférencement, indirection ................................................................................... 67 4.4. Notion de référence .................................................................................................. 68 4.5. Lien entre les pointeurs et les références.................................................................. 69 4.6. Passage de paramètres par variable ou par valeur .................................................... 70 4.6.1. Passage par valeur........................................................................................ 70 4.6.2. P par variable ..................................................................................... 71 4.6.3. Avantages et inconvénients des deux méthodes........................................... 71 4.6.4. Comment passer les paramètres par variable en C ?.................................... 72 4.6.5. Passage de paramètres par référence............................................................ 72 4.7. Références et pointeurs constants et volatiles .......................................................... 74 4.8. Arithmétique des pointeurs....................................................................................... 77 4.9. Utilisation des avec les tableaux............................................................... 78 4.9.1. Conversions des tableaux en pointeurs ........................................................ 79 4.9.2. Paramètres de fonction de type tableau ....................................................... 80 4.10. Les chaînes de caractères : pointeurs et tableaux à la fois ! ................................... 81 4.11. Allocation dynamique de mémoire ........................................................................ 82 4.11.1. Allocation dynamique de mémoire en C ................................................... 82 4.11.2. en C++................................................................... 83 4.12. Pointeurs et références de fonctions ....................................................................... 86 4.12.1. Pointeurs de fonctions................................................................................ 86 4.12.2. Références de ............................................................................. 88 4.13. Paramètres de la fonction main ligne de commande............................................ 89 4.14. DANGER................................................................................................................ 90 5. Le préprocesseur C................................................................................................................ 92 5.1. Définition.................................................................................................................. 92 5.2. Les commandes du préprocesseur ............................................................................ 92 5.2.1. Inclusion de fichier....................................................................................... 92 5.2.2. Constantes de compilation et remplacement de texte .................................. 93 5.2.3. Compilation conditionnelle.......................................................................... 94 5.2.4. Autres commandes....................................................................................... 95 5.3. Les macros................................................................................................................ 96 5.4. Manipulation de chaînes de caractères dans les macros........................................... 98 5.5. Les trigraphes ........................................................................................................... 99 6. Modularité des programmes et génération des binaires...................................................... 100 6.1. Pourquoi faire une programmation modulaire ?..................................................... 100 6.2. Étapes impliquées dans la génération d’un exécutable .......................................... 101 6.3. Compilation séparée en C/C++ .............................................................................. 101 6.4. Syntaxe des outils de compilation .......................................................................... 102 6.4.1. Syntaxe des compilateurs........................................................................... 102 6.4.2.e de make ........................................................................................ 103 6.5. Problèmes syntaxiques relatifs à la compilation séparée ....................................... 104 6.5.1. Déclaration des types ................................................................................. 105 6.5.2. des variables ........................................................................... 105 5 6.5.3. Déclaration des fonctions........................................................................... 105 6.5.4. Directive d’édition de liens ........................................................................ 106 7. Comment faire du code illisible ? ....................................................................................... 108 8. C++ : la couche objet .......................................................................................................... 110 8.1. Généralités.............................................................................................................. 110 8.2. Extension de la notion de type du C....................................................................... 111 8.3. Déclaration de classes en C++................................................................................ 111 8.4. Encapsulation des données..................................................................................... 116 8.5. Héritage .................................................................................................................. 118 8.6. Classes virtuelles .................................................................................................... 121 8.7. Fonctions et classes amies ...................................................................................... 122 8.7.1. Fonctions amies ......................................................................................... 123 8.7.2. Classes amies ............................................................................................. 123 8.8. Constructeurs et destructeurs.................................................................................. 124 8.8.1. Définition des constructeurs et des destructeurs ........................................ 125 8.8.2. Constructeurs de copie............................................................................... 130 8.8.3. Utilisation des dans les transtypages ................................... 131 8.9. Pointeur this............................................................................................................ 132 8.10. Données et fonctions membres statiques.............................................................. 134 8.10.1. Données membres statiques..................................................................... 134 8.10.2. Fonctions ................................................................... 135 8.11. Surcharge des opérateurs...................................................................................... 136 8.11.1. Surcharge des opérateurs internes............................................................ 137 8.11.2. Surcharge des opérateurs externes ........................................................... 140 8.11.3. Opérateurs d’affectation........................................................................... 143 8.11.4. de transtypage........................................................................ 144 8.11.5. Opérateurs de comparaison...................................................................... 145 8.11.6. d’incrémentation et de décrémentation ................................. 145 8.11.7. Opérateur fonctionnel .............................................................................. 146 8.11.8. Opérateurs d’indirection et de déréférencement...................................... 149 8.11.9. d’allocation dynamique de mémoire ..................................... 150 8.12. Des entrées sorties simplifiées........................................................................... 158 8.13. Méthodes virtuelles .............................................................................................. 160 8.14. Dérivation ............................................................................................................. 162 8.15. Méthodes virtuelles pures Classes abstraites..................................................... 165 8.16. Pointeurs sur les membres d’une classe ............................................................... 170 9. Les exceptions en C++........................................................................................................ 174 9.1. Lancement et récupération d’une exception........................................................... 175 9.2. Remontée des exceptions........................................................................................ 178 9.3. Liste des exceptions autorisées pour une fonction ................................................. 179 9.4. Hiérarchie des exceptions....................................................................................... 181 9.5. Exceptions dans les constructeurs .......................................................................... 184 10. Identification dynamique des types................................................................................... 187 10.1. Identification dynamique des types ...................................................................... 187 6 10.1.1. L’opérateur typeid.................................................................................... 187 10.1.2. La classe type_info .................................................................................. 189 10.2. Transtypages C++................................................................................................. 190 10.2.1. Transtypage dynamique ........................................................................... 190 10.2.2. T statique ................................................................................ 193 10.2.3. Transtypage de constance et de volatilité................................................. 193 10.2.4. Réinterprétation des données ................................................................... 194 11. Les espaces de nommage .................................................................................................. 195 11.1. Définition des espaces de nommage..................................................................... 195 11.1.1. Espaces de nommage nommées............................................................... 195 11.1.2. Espaces de nommage anonymes.............................................................. 197 11.1.3. Alias d’espaces de nommage................................................................... 198 11.2. Déclaration using.................................................................................................. 198 11.2.1. Syntaxe des déclarations using ................................................................ 199 11.2.2. Utilisation des using dans les classes .................................. 201 11.3. Directive using...................................................................................................... 202 12. Les template ...................................................................................................................... 205 12.1. Généralités............................................................................................................ 205 12.2. Déclaration des paramètres template.................................................................... 205 12.2.1. Déclaration des types ................................................................ 205 12.2.2. des constantes template ........................................................ 207 12.3. Fonctions et classes template................................................................................ 208 12.3.1. Fonctions ................................................................................... 208 12.3.2. Les classes template................................................................................. 209 12.3.3. Fonctions membres template ................................................................... 212 12.4. Instanciation des template .................................................................................... 215 12.4.1. Instanciation implicite.............................................................................. 215 12.4.2. explicite .............................................................................. 217 12.4.3. Problèmes soulevés par l’instanciation des template............................... 218 12.5. Spécialisation des template................................................................................... 219 12.5.1. Spécialisation totale ................................................................................. 219 12.5.2. partielle............................................................................. 220 12.5.3. d’une méthode d’une classe template............................... 222 12.6. Mot clé typename................................................................................................. 223 12.7. Fonctions exportées .............................................................................................. 224 II. La librairie standard C++......................................................................................................... 226 13. Services et notions de base de la librairie standard........................................................... 228 13.1. Encapsulation de la librairie C............................................................... 228 13.2. Définition des exceptions standards ..................................................................... 231 13.3. Abstraction des types de données : les traits ........................................................ 234 13.4. des pointeurs : les itérateurs.............................................................. 236 13.4.1. Notions de base et définition.................................................................... 236 13.4.2. Classification des itérateurs...................................................................... 237 13.4.3. Itérateurs adaptateurs ............................................................................... 240 7 13.4.3.1. Adaptateurs pour les flux d’entrée / sortie standards .................. 240 13.4.3.2. pour l’insertion d’éléments dans les conteneurs ..... 243 13.4.3.3. Itérateur inverse pour les itérateurs bidirectionnels..................... 246 13.5. Abstraction des fonctions : les foncteurs.............................................................. 248 13.5.1. Foncteurs prédéfinis ................................................................................. 249 13.5.2. Prédicats et foncteurs d’opérateurs logiques............................................ 254 13.5.3. Foncteurs réducteurs ................................................................................ 256 13.6. Gestion personnalisée de la mémoire : les allocateurs ......................................... 258 13.7. Notion de complexité algorithmique .................................................................... 262 13.7.1. Généralités ............................................................................................... 262 13.7.2. Notions mathématiques de base et définition........................................... 263 13.7.3. Interprétation pratique de la complexité .................................................. 265 14. Les types complémentaires ............................................................................................... 267 14.1. Les chaînes de caractères...................................................................................... 267 14.1.1. Construction et initialisation d’une chaîne .............................................. 272 14.1.2. Accès aux propriétés d’une chaîne .......................................................... 273 14.1.3. Modification de la taille des chaînes........................................................ 274 14.1.4. Accès aux données de la chaîne de caractères......................................... 275 14.1.5. Opérations sur les chaînes........................................................................ 278 14.1.5.1. Affectation et concaténation de chaînes de caractères ................ 278 14.1.5.2. Extraction de données d’une chaîne de ...................... 280 14.1.5.3. Insertion et suppression de caractères dans une chaîne............... 281 14.1.5.4. Remplacements de caractères d’une chaîne ................................ 283 14.1.6. Comparaison de chaînes de caractères..................................................... 284 14.1.7. Recherche dans les chaînes...................................................................... 285 14.1.8. Fonctions d’entrée / sortie des chaînes de caractères............................... 288 14.2. Les types utilitaires............................................................................................... 289 14.2.1. Les pointeurs auto.................................................................................... 289 14.2.2. Les paires ................................................................................................. 293 14.3. Les types numériques ........................................................................................... 294 14.3.1. Les complexes.......................................................................................... 294 14.3.1.1. Définition et principales propriétés des nombres complexes ...... 295 14.3.1.2. La classe complex ....................................................................... 297 14.3.2. Les tableaux de valeurs............................................................................ 300 14.3.2.1. Fonctionnalités de base des valarray ........................................... 301 14.3.2.2. Sélection multiple des éléments d’un valarray............................ 306 14.3.2.2.1. Sélection par un masque ................................................. 307 14.3.2.2.2. par indexation explicite................................... 308 14.3.2.2.3. Sélection par indexation implicite .................................. 309 14.3.2.2.4. Opérations réalisables sur les sélections multiples......... 311 14.3.3. Les champs de bits................................................................................... 312 15. Les flux d’entrée / sortie.................................................................................................... 318 15.1. Notions de base et présentation générale.............................................................. 318 15.2. Les tampons.......................................................................................................... 320 8 15.2.1. Généralités sur les tampons ..................................................................... 321 15.2.2. La classe basic_streambuf........................................................................ 321 15.2.3. Les classes de tampons basic_streambuf et basic_filebuf........................ 328 15.2.3.1. La classe basic_stringbuf............................................................. 328 15.2.3.2. La classe basic_filebuf................................................................. 331 15.3. Les classes de base des flux : ios_base et basic_ios ............................................. 333 15.3.1. La classe ios_base.................................................................................... 333 15.3.2. La classe basic_ios................................................................................... 341 15.4. Les flux d’entrée / sortie....................................................................................... 343 15.4.1. La classe de base basic_ostream.............................................................. 344 15.4.2. La classe de base basic_istream............................................................... 351 15.4.3. La classe basic_iostream.......................................................................... 358 15.5. Les flux d’entrée / sortie sur chaînes de caractères .............................................. 358 15.6. Les flux / sortie sur fichiers .................................................................... 360 16. Les locales......................................................................................................................... 364 16.1. Notions de base et principe de fonctionnement des facettes ................................ 365 16.2. Les facettes standards ........................................................................................... 371 16.2.1. Généralités ............................................................................................... 371 16.2.2. Les facettes de manipulation des caractères ............................................ 372 16.2.2.1. La facette ctype ........................................................................... 372 16.2.2.2. La facette codecvt........................................................................ 376 16.2.3. Les facettes de comparaison de chaînes................................................... 381 16.2.4. Les f de gestion des nombres ........................................................ 385 16.2.4.1. La facette num_punct .................................................................. 385 16.2.4.2. La facette d’écriture des nombres ............................................... 386 16.2.4.3. La facette de lecture des ............................................... 387 16.2.5. Les facettes de gestion des monnaies....................................................... 389 16.2.5.1. La facette money_punct .............................................................. 389 16.2.5.2. Les facettes de lecture et d’écriture des montants....................... 392 16.2.6. Les facettes de gestion du temps.............................................................. 393 16.2.6.1. La facette d’écriture des dates..................................................... 395 16.2.6.2. La facette de lecture des dates..................................................... 396 16.2.7. Les facettes de gestion des messages....................................................... 398 16.3. Personnalisation des mécanismes de localisation................................................. 400 16.3.1. Création et intégration d’une nouvelle facette ......................................... 400 16.3.2. Remplacement d’une facette existante..................................................... 404 17. Les conteneurs................................................................................................................... 408 17.1. Fonctionnalités générales des conteneurs............................................................. 408 17.1.1. Définition des itérateurs ........................................................................... 409 17.1.2. des types de données relatifs aux objets contenus.................. 410 17.1.3. Spécification de l’allocateur mémoire à utiliser....................................... 410 17.1.4. Opérateurs de comparaison des conteneurs ............................................. 412 17.1.5. Méthodes d’intérêt général ...................................................................... 412 17.2. Les séquences ....................................................................................................... 413 9 17.2.1. Fonctionnalités communes....................................................................... 413 17.2.1.1. Construction et initialisation ....................................................... 413 17.2.1.2. Ajout et suppression d’éléments ................................................. 414 17.2.2. Les différents types de séquences ............................................................ 416 17.2.2.1. Les listes...................................................................................... 416 17.2.2.2. Les vecteurs................................................................................. 421 17.2.2.3. Les deques ................................................................................... 423 17.2.2.4. Les adaptateurs de séquences...................................................... 424 17.2.2.4.1. Les piles.......................................................................... 424 17.2.2.4.2. Les files........................................................................... 425 17.2.2.4.3. Les files de priorités........................................................ 426 17.3. Les conteneurs associatifs .................................................................................... 428 17.3.1. Généralités et propriétés de base des clefs............................................... 429 17.3.2. Construction et initialisation.................................................................... 430 17.3.3. Ajout et suppression d’éléments .............................................................. 431 17.3.4. Fonctions de recherche ............................................................................ 433 18. Les algorithmes ................................................................................................................. 436 18.1. Opérations générales de manipulation des données ............................................. 436 18.1.1. Opérations d’initialisation et de remplissage........................................... 437 18.1.2. de copie.................................................................................. 438 18.1.3. Opérations d’échange d’éléments............................................................ 439 18.1.4. de suppression d’éléments..................................................... 440 18.1.5. Opérations de remplacement.................................................................... 443 18.1.6. Réorganisation de séquences ................................................................... 444 18.1.6.1. Opérations de rotation et de permutation .................................... 445 18.1.6.2. d’inversion et de symétrisation ................................. 447 18.1.6.3. Opérations de mélange ................................................................ 448 18.1.7. Algorithmes d’itération et de transformation........................................... 449 18.2. Opérations de recherche ....................................................................................... 455 18.2.1. Opération de recherche d’éléments.......................................................... 455 18.2.2. Opérations de de motifs........................................................... 456 18.3. Opérations d’ordonnancement.............................................................................. 459 18.3.1. Opérations de gestion des tas................................................................... 460 18.3.2. de tri....................................................................................... 462 18.3.3. Opérations de recherche binaire............................................................... 467 18.4. Opérations de comparaison .................................................................................. 470 18.5. ensemblistes ....................................................................................... 473 18.5.1. Opérations d’inclusion............................................................................. 473 18.5.2. d’intersection......................................................................... 474 18.5.3. Opérations d’union et de fusion............................................................... 475 18.5.4. de différence .......................................................................... 478 18.5.5. Opérations de partitionnement................................................................. 480 19. Conclusion ................................................................................................................................. 483 A. Priorités des opérateurs............................................................................................................. 484 10
Soyez le premier à déposer un commentaire !

17/1000 caractères maximum.