Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Cours de C/C++ Christian Casteyde Cours de C/C++ par Christian Casteyde Copyrig

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 modiﬁer 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 ofﬁcielle 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 postﬁxes et pré Version 1.40.0 30/07/2001 Revu par : CC Version ﬁnale. Réorganisation partielle de la première partie. Scission du chapitre contenant les structures de contrôle et les déﬁniti 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 Version 1.39.4 27/05/2001 Revu par : CC Description des ﬂux d’entrée / sortie de la librairie standard. Modiﬁcation de la présentation sommaire des ﬂux dans le chapitre sur 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 &colon;, & 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 con 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 librai 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 ﬁchier 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éﬁnitions 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érivati 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. Modiﬁcations 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éﬁnis du C/C++ .................................................................................23 1.3. Notation des valeurs .................................................................................................26 1.4. La déﬁnition des variables........................................................................................28 1.5. Instructions et opérations..........................................................................................30 1.6. Les fonctions ............................................................................................................33 1.6.1. Déﬁnition des fonctions...............................................................................33 1.6.2. Appel des fonctions......................................................................................34 1.6.3. Déclaration des fonctions.............................................................................35 1.6.4. Surcharge des fonctions ...............................................................................36 1.6.5. Fonctions inline............................................................................................37 1.6.6. Fonctions 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 ﬂux 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. Passage 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 pointeurs 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. Allocation dynamique 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 fonctions.............................................................................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éﬁnition..................................................................................................................92 5.2. Les commandes du préprocesseur............................................................................92 5.2.1. Inclusion de ﬁchier.......................................................................................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. Syntaxe 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. Déclaration 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éﬁnition des constructeurs et des destructeurs........................................125 8.8.2. Constructeurs de copie...............................................................................130 8.8.3. Utilisation des constructeurs 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 membres statiques ...................................................................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. Opérateurs de transtypage........................................................................144 8.11.5. Opérateurs de comparaison......................................................................145 8.11.6. Opérateurs 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. Opérateurs d’allocation dynamique de mémoire.....................................150 8.12. Des entrées - sorties simpliﬁé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. Identiﬁcation dynamique des types...................................................................................187 10.1. Identiﬁcation 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. Transtypage 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éﬁnition 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 déclarations 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 template ................................................................205 12.2.2. Déclaration des constantes template........................................................207 12.3. Fonctions et classes template................................................................................208 12.3.1. Fonctions template...................................................................................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. Instanciation 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. Spécialisation partielle.............................................................................220 12.5.3. Spécialisation 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 standard...............................................................228 13.2. Déﬁnition des exceptions standards .....................................................................231 13.3. Abstraction des types de données : les traits ........................................................234 13.4. Abstraction des pointeurs : les itérateurs..............................................................236 13.4.1. Notions de base et déﬁnition....................................................................236 13.4.2. Classiﬁcation des itérateurs......................................................................237 13.4.3. Itérateurs adaptateurs ...............................................................................240 7 13.4.3.1. Adaptateurs pour les ﬂux d’entrée / sortie standards ..................240 13.4.3.2. Adaptateurs 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. uploads/Litterature/ cours-c 3 .pdf