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 © 2002 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". 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.4 21/09/2002 Revu par : CC Correction de l’exemple de recherche sur les chaînes de caractères. Ajout des initialiseurs C99. Précisions sur la portabilité des type Version 1.40.3 12/05/2002 Revu par : CC Nombreuses corrections orthographiques. Quelques corrections et précisions. Clariﬁcation de quelques exemples. Version 1.40.2 26/01/2001 Revu par : CC Corrections orthographiques. Ajout d’un lien sur les spéciﬁcations Single Unix de l’Open Group. 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ﬁxés 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 bibliothèque standard. Modiﬁcation de la présentation sommaire des ﬂux dans le chapitre Version 1.39.3 03/05/2001 Revu par : CC Description des algorithmes de la bibliothèque standard. Version 1.39.2 22/04/2001 Revu par : CC Description des conteneurs de la bibliothèque standard. Ajout d’une traduction de la licence FDL. Suppression des symboles &colo Version 1.39.1 05/03/2001 Revu par : CC Description des types de données complémentaires de la bibliothèque standard C++. Correction du comportement du bloc catch de 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 biblio 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 ........................................................................................................................................i I. Le langage C++.................................................................................................................................i 1. Première approche du C/C++..................................................................................................1 1.1. Les commentaires en C++..........................................................................................2 1.2. Les types prédéﬁnis du C/C++ ...................................................................................2 1.3. Notation des valeurs ...................................................................................................5 1.4. La déﬁnition des variables..........................................................................................7 1.5. Instructions et opérations............................................................................................9 1.6. Les fonctions ............................................................................................................12 1.6.1. Déﬁnition des fonctions...............................................................................12 1.6.2. Appel des fonctions......................................................................................13 1.6.3. Déclaration des fonctions.............................................................................13 1.6.4. Surcharge des fonctions ...............................................................................14 1.6.5. Fonctions inline............................................................................................15 1.6.6. Fonctions statiques.......................................................................................16 1.6.7. Fonctions prenant un nombre variable de paramètres .................................16 1.7. La fonction main.......................................................................................................18 1.8. Les fonctions d’entrée / sortie de base .....................................................................19 1.8.1. Généralités sur les ﬂux d’entrée / sortie en C ..............................................19 1.8.2. La fonction printf.........................................................................................21 1.8.3. La fonction scanf..........................................................................................23 1.9. Exemple de programme complet..............................................................................24 2. Les structures de contrôle .....................................................................................................25 2.1. La structure conditionnelle if....................................................................................25 2.2. La boucle for.............................................................................................................26 2.3. Le while....................................................................................................................27 2.4. Le do.........................................................................................................................27 2.5. Le branchement conditionnel ...................................................................................28 2.6. Le saut ......................................................................................................................29 2.7. Les commandes de rupture de séquence ..................................................................29 3. Types avancés et classes de stockage....................................................................................31 3.1. Structures de données et types complexes................................................................31 3.1.1. Les structures ...............................................................................................31 3.1.2. Les unions....................................................................................................33 3.1.3. Les énumérations .........................................................................................34 3.1.4. Les champs de bits.......................................................................................35 3.1.5. Initialisation des structures et des tableaux..................................................36 3.1.6. Les alias de types .........................................................................................37 3.1.7. Transtypages ................................................................................................38 3.2. Les classes de stockage ............................................................................................38 4. Les pointeurs et références....................................................................................................43 4.1. Notion d’adresse.......................................................................................................43 4.2. Notion de pointeur....................................................................................................43 4.3. Déréférencement, indirection ...................................................................................44 4.4. Notion de référence ..................................................................................................46 4.5. Lien entre les pointeurs et les références..................................................................46 4.6. Passage de paramètres par variable ou par valeur ....................................................47 4.6.1. Passage par valeur........................................................................................47 4.6.2. Passage par variable.....................................................................................48 v 4.6.3. Avantages et inconvénients des deux méthodes...........................................48 4.6.4. Comment passer les paramètres par variable en C ?....................................49 4.6.5. Passage de paramètres par référence............................................................49 4.7. Références et pointeurs constants et volatiles ..........................................................51 4.8. Arithmétique des pointeurs.......................................................................................54 4.9. Utilisation des pointeurs avec les tableaux...............................................................55 4.9.1. Conversions des tableaux en pointeurs ........................................................55 4.9.2. Paramètres de fonction de type tableau .......................................................56 4.10. Les chaînes de caractères : pointeurs et tableaux à la fois ! ...................................57 4.11. Allocation dynamique de mémoire ........................................................................58 4.11.1. Allocation dynamique de mémoire en C ...................................................58 4.11.2. Allocation dynamique en C++...................................................................62 4.12. Pointeurs et références de fonctions.......................................................................65 4.12.1. Pointeurs de fonctions................................................................................65 4.12.2. Références de fonctions.............................................................................67 4.13. Paramètres de la fonction main - ligne de commande............................................67 4.14. DANGER................................................................................................................68 5. Le préprocesseur C................................................................................................................71 5.1. Déﬁnition..................................................................................................................71 5.2. Les commandes du préprocesseur............................................................................71 5.2.1. Inclusion de ﬁchier.......................................................................................71 5.2.2. Constantes de compilation et remplacement de texte..................................72 5.2.3. Compilation conditionnelle..........................................................................73 5.2.4. Autres commandes.......................................................................................74 5.3. Les macros................................................................................................................74 5.4. Manipulation de chaînes de caractères dans les macros...........................................76 5.5. Les trigraphes ...........................................................................................................77 6. Modularité des programmes et génération des binaires........................................................79 6.1. Pourquoi faire une programmation modulaire ?.......................................................79 6.2. Les différentes phases du processus de génération des exécutables.........................79 6.3. Compilation séparée en C/C++ ................................................................................82 6.4. Syntaxe des outils de compilation ............................................................................83 6.4.1. Syntaxe des compilateurs.............................................................................83 6.4.2. Syntaxe de make ..........................................................................................84 6.5. Problèmes syntaxiques relatifs à la compilation séparée .........................................85 6.5.1. Déclaration des types...................................................................................85 6.5.2. Déclaration des variables .............................................................................85 6.5.3. Déclaration des fonctions.............................................................................86 6.5.4. Directives d’édition de liens ........................................................................86 7. Comment faire du code illisible ? .........................................................................................89 8. C++ : la couche objet ............................................................................................................91 8.1. Généralités................................................................................................................91 8.2. Extension de la notion de type du C.........................................................................92 8.3. Déclaration de classes en C++..................................................................................92 8.4. Encapsulation des données.......................................................................................96 8.5. Héritage ....................................................................................................................98 8.6. Classes virtuelles ....................................................................................................100 8.7. Fonctions et classes amies......................................................................................102 8.7.1. Fonctions amies .........................................................................................102 8.7.2. Classes amies .............................................................................................103 8.8. Constructeurs et destructeurs..................................................................................104 8.8.1. Déﬁnition des constructeurs et des destructeurs........................................104 vi 8.8.2. Constructeurs de copie...............................................................................109 8.8.3. Utilisation des constructeurs dans les transtypages ...................................110 8.9. Pointeur this............................................................................................................111 8.10. Données et fonctions membres statiques..............................................................112 8.10.1. Données membres statiques.....................................................................112 8.10.2. Fonctions membres statiques ...................................................................113 8.11. Surcharge des opérateurs......................................................................................114 8.11.1. Surcharge des opérateurs internes............................................................115 8.11.2. Surcharge des opérateurs externes...........................................................118 8.11.3. Opérateurs d’affectation...........................................................................120 8.11.4. Opérateurs de transtypage........................................................................122 8.11.5. Opérateurs de comparaison......................................................................122 8.11.6. Opérateurs d’incrémentation et de décrémentation .................................122 8.11.7. Opérateur fonctionnel ..............................................................................123 8.11.8. Opérateurs d’indirection et de déréférencement......................................126 8.11.9. Opérateurs d’allocation dynamique de mémoire.....................................126 8.12. Des entrées - sorties simpliﬁées ...........................................................................133 8.13. Méthodes virtuelles ..............................................................................................135 8.14. Dérivation .............................................................................................................137 8.15. Méthodes virtuelles pures - Classes abstraites .....................................................140 8.16. Pointeurs sur les membres d’une classe ...............................................................144 9. Les exceptions en C++........................................................................................................149 9.1. Lancement et récupération d’une exception...........................................................150 9.2. Remontée des exceptions........................................................................................152 9.3. Liste des exceptions autorisées pour une fonction .................................................154 9.4. Hiérarchie des exceptions.......................................................................................155 9.5. Exceptions dans les constructeurs ..........................................................................157 10. Identiﬁcation dynamique des types...................................................................................161 10.1. Identiﬁcation dynamique des types ......................................................................161 10.1.1. L’opérateur typeid....................................................................................161 10.1.2. La classe type_info ..................................................................................163 10.2. Transtypages C++.................................................................................................163 10.2.1. Transtypage dynamique...........................................................................164 10.2.2. Transtypage statique ................................................................................166 10.2.3. Transtypage de constance et de volatilité.................................................167 10.2.4. Réinterprétation des données...................................................................167 11. Les espaces de nommage ..................................................................................................169 11.1. Déﬁnition des espaces de nommage.....................................................................169 11.1.1. Espaces de nommage nommées...............................................................169 11.1.2. Espaces de nommage anonymes..............................................................170 11.1.3. Alias d’espaces de nommage...................................................................172 11.2. Déclaration using..................................................................................................172 11.2.1. Syntaxe des déclarations using ................................................................172 11.2.2. Utilisation des déclarations using dans les classes ..................................174 11.3. Directive using......................................................................................................175 12. Les template ......................................................................................................................179 12.1. Généralités............................................................................................................179 12.2. Déclaration des paramètres template....................................................................179 12.2.1. Déclaration des types template ................................................................179 12.2.2. Déclaration des constantes template........................................................180 12.3. Fonctions et classes template................................................................................181 12.3.1. Fonctions template...................................................................................181 vii 12.3.2. Les classes template.................................................................................182 12.3.3. Fonctions membres template ...................................................................185 12.4. Instanciation des template ....................................................................................188 12.4.1. Instanciation implicite..............................................................................188 12.4.2. Instanciation explicite ..............................................................................189 12.4.3. Problèmes soulevés par l’instanciation des template...............................190 12.5. Spécialisation des template...................................................................................191 12.5.1. Spécialisation totale .................................................................................191 12.5.2. Spécialisation partielle.............................................................................192 12.5.3. Spécialisation d’une méthode d’une classe template...............................194 12.6. Mot-clé typename.................................................................................................195 12.7. Fonctions exportées ..............................................................................................196 II. La bibliothèque standard C++ .................................................................................................197 13. Services et notions de base de la bibliothèque standard ...................................................199 13.1. Encapsulation de la bibliothèque C standard........................................................199 13.2. Déﬁnition des exceptions standards .....................................................................201 13.3. Abstraction des types de uploads/Litterature/ cours-c 9 .pdf