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 © 2005 Christian Casteyde Historique des versions Version 2.0.2 01/01/2007 Revu par : CC Conversion du document en XML pour permettre l’utilisation des feuilles de style XML et des outils de formatage XML-FO. Corre Version 2.0.1 26/02/2006 Revu par : CC Corrections orthographiques. Correction sur la gestion des exceptions dans les constructeurs par les constructeurs try. Précisions su Version 2.0.0 03/07/2005 Revu par : CC Ajout d’une introduction sur les langages de programmation et refonte de la première partie. Ajout des déﬁnitions des termes lors d Version 1.40.6 16/05/2004 Revu par : CC Correction de l’exemple d’allocation dynamique de mémoire en C. Correction de l’exemple de fonction à nombre variable de param Version 1.40.5 14/06/2003 Revu par : CC Correction de l’allocation dynamique de tableaux à plus d’une dimension. 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 .....................................................................................................................................xv I. Le langage C++............................................................................................................................xvii 1. Première approche du C/C++..................................................................................................1 1.1. Les ordinateurs, les langages et le C++......................................................................1 1.1.1. Les ordinateurs et la programmation .............................................................1 1.1.2. Les langages de programmation ....................................................................1 1.1.3. Le langage C/C++..........................................................................................3 1.1.4. Les outils de programmation .........................................................................3 1.2. Notre premier programme ..........................................................................................4 1.2.1. Hello World! ..................................................................................................4 1.2.2. Analyse du programme..................................................................................5 1.2.3. Généralisation ................................................................................................6 1.3. Les commentaires en C/C++ ......................................................................................8 1.4. Les variables...............................................................................................................9 1.4.1. Déﬁnition des variables..................................................................................9 1.4.2. Les types de base du C/C++ ........................................................................10 1.4.3. Notation des valeurs.....................................................................................12 1.4.3.1. Notation des valeurs booléennes .....................................................12 1.4.3.2. Notation des valeurs entières...........................................................13 1.4.3.3. Notation des valeurs en virgule ﬂottantes .......................................13 1.4.3.4. Notation des caractères....................................................................14 1.4.3.5. Notation des chaînes de caractères..................................................15 1.5. Les instructions.........................................................................................................15 1.5.1. Les instructions simples...............................................................................16 1.5.2. Les instructions composée...........................................................................19 1.5.3. Les structures de contrôle ............................................................................19 1.6. Les fonctions et les procédures.................................................................................19 1.6.1. Déﬁnition des fonctions et des procédures ..................................................20 1.6.2. Appel des fonctions et des procédures.........................................................21 1.6.3. Notion de déclaration...................................................................................22 1.6.4. Surcharge des fonctions ...............................................................................23 1.6.5. Fonctions inline............................................................................................24 1.6.6. Fonctions statiques.......................................................................................25 1.6.7. Fonctions prenant un nombre variable de paramètres .................................25 1.7. Les entrées / sorties en C..........................................................................................27 1.7.1. Généralités sur les ﬂux d’entrée / sortie.......................................................27 1.7.2. Les fonctions d’entrée / sortie de la bibliothèque C ....................................28 1.7.3. La fonction printf.....................................................................................29 1.7.4. La fonction scanf..........................................................................................31 2. Les structures de contrôle .....................................................................................................35 2.1. Les tests ....................................................................................................................35 2.1.1. La structure conditionnelle if.......................................................................35 2.1.2. Le branchement conditionnel.......................................................................36 2.2. Les boucles ...............................................................................................................37 2.2.1. La boucle for................................................................................................37 2.2.2. Le while .......................................................................................................38 2.2.3. Le do ............................................................................................................39 2.3. Les instructions de rupture de séquence et de saut...................................................39 2.3.1. Les instructions de rupture de séquence ......................................................39 v 2.3.2. Le saut..........................................................................................................40 3. Types avancés et classes de stockage....................................................................................43 3.1. Types de données portables......................................................................................43 3.2. Structures de données et types complexes................................................................44 3.2.1. Les tableaux .................................................................................................45 3.2.2. Les chaînes de caractères.............................................................................46 3.2.3. Les structures ...............................................................................................47 3.2.4. Les unions....................................................................................................49 3.2.5. Les champs de bits.......................................................................................50 3.2.6. Initialisation des structures et des tableaux..................................................51 3.3. Les énumérations......................................................................................................52 3.4. Les alias de types......................................................................................................53 3.4.1. Déﬁnition d’un alias de type........................................................................53 3.4.2. Utilisation d’un alias de type .......................................................................54 3.5. Transtypages et promotions......................................................................................55 3.6. Les classes de stockage ............................................................................................57 4. Les pointeurs et références....................................................................................................61 4.1. Notion d’adresse.......................................................................................................61 4.2. Notion de pointeur....................................................................................................61 4.3. Déréférencement, indirection ...................................................................................62 4.4. Notion de référence ..................................................................................................64 4.5. Lien entre les pointeurs et les références..................................................................64 4.6. Passage de paramètres par variable ou par valeur ....................................................65 4.6.1. Passage par valeur........................................................................................65 4.6.2. Passage par variable.....................................................................................66 4.6.3. Avantages et inconvénients des deux méthodes...........................................66 4.6.4. Comment passer les paramètres par variable en C ?....................................67 4.6.5. Passage de paramètres par référence............................................................67 4.7. Références et pointeurs constants et volatiles ..........................................................69 4.8. Arithmétique des pointeurs.......................................................................................72 4.9. Utilisation des pointeurs avec les tableaux...............................................................73 4.10. Les chaînes de caractères : pointeurs et tableaux à la fois ! ...................................74 4.11. Allocation dynamique de mémoire ........................................................................75 4.11.1. Allocation dynamique de mémoire en C ...................................................75 4.11.2. Allocation dynamique en C++...................................................................80 4.12. Pointeurs et références de fonctions.......................................................................82 4.12.1. Pointeurs de fonctions................................................................................82 4.12.2. Références de fonctions.............................................................................84 4.13. Paramètres de la fonction main - ligne de commande............................................85 4.14. DANGER................................................................................................................86 5. Le préprocesseur C................................................................................................................89 5.1. Déﬁnition..................................................................................................................89 5.2. Les directives du préprocesseur................................................................................89 5.2.1. Inclusion de ﬁchier.......................................................................................89 5.2.2. Constantes de compilation et remplacement de texte..................................90 5.2.3. Compilation conditionnelle..........................................................................91 5.2.4. Autres directives ..........................................................................................92 5.3. Les macros................................................................................................................92 5.4. Manipulation de chaînes de caractères dans les macros...........................................95 5.5. Les trigraphes ...........................................................................................................96 6. Modularité des programmes et génération des binaires........................................................97 6.1. Pourquoi faire une programmation modulaire ?.......................................................97 vi 6.2. Les différentes phases du processus de génération des exécutables.........................98 6.3. Compilation séparée en C/C++ ..............................................................................100 6.4. Syntaxe des outils de compilation ..........................................................................101 6.4.1. Syntaxe des compilateurs...........................................................................101 6.4.2. Syntaxe de make ........................................................................................102 6.5. Problèmes syntaxiques relatifs à la compilation séparée .......................................103 6.5.1. Déclaration des types.................................................................................103 6.5.2. Déclaration des variables ...........................................................................103 6.5.3. Déclaration des fonctions...........................................................................103 6.5.4. Directives d’édition de liens ......................................................................104 7. C++ : la couche objet ..........................................................................................................107 7.1. Généralités..............................................................................................................107 7.2. Extension de la notion de type du C.......................................................................108 7.3. Déclaration de classes en C++................................................................................108 7.4. Encapsulation des données.....................................................................................112 7.5. Héritage ..................................................................................................................114 7.6. Classes virtuelles ....................................................................................................117 7.7. Fonctions et classes amies......................................................................................118 7.7.1. Fonctions amies .........................................................................................119 7.7.2. Classes amies .............................................................................................119 7.8. Constructeurs et destructeurs..................................................................................120 7.8.1. Déﬁnition des constructeurs et des destructeurs........................................121 7.8.2. Constructeurs de copie...............................................................................125 7.8.3. Utilisation des constructeurs dans les transtypages ...................................126 7.9. Pointeur this............................................................................................................127 7.10. Données et fonctions membres statiques..............................................................128 7.10.1. Données membres statiques.....................................................................129 7.10.2. Fonctions membres statiques ...................................................................130 7.11. Surcharge des opérateurs......................................................................................131 7.11.1. Surcharge des opérateurs internes............................................................132 7.11.2. Surcharge des opérateurs externes...........................................................134 7.11.3. Opérateurs d’affectation...........................................................................137 7.11.4. Opérateurs de transtypage........................................................................138 7.11.5. Opérateurs de comparaison......................................................................139 7.11.6. Opérateurs d’incrémentation et de décrémentation .................................139 7.11.7. Opérateur fonctionnel ..............................................................................140 7.11.8. Opérateurs d’indirection et de déréférencement......................................142 7.11.9. Opérateurs d’allocation dynamique de mémoire.....................................143 7.12. Des entrées - sorties simpliﬁées ...........................................................................150 7.13. Méthodes virtuelles ..............................................................................................152 7.14. Dérivation .............................................................................................................154 7.15. Méthodes virtuelles pures - Classes abstraites .....................................................156 7.16. Pointeurs sur les membres d’une classe ...............................................................161 8. Les exceptions en C++........................................................................................................165 8.1. Techniques de gestion des erreurs ..........................................................................165 8.2. Lancement et récupération d’une exception...........................................................169 8.3. Hiérarchie des exceptions.......................................................................................171 8.4. Traitement des exceptions non captées...................................................................173 8.5. Liste des exceptions autorisées pour une fonction .................................................174 8.6. Gestion des objets exception ..................................................................................176 8.7. Exceptions dans les constructeurs et les destructeurs.............................................177 9. Identiﬁcation dynamique des types.....................................................................................181 vii 9.1. Identiﬁcation dynamique des types ........................................................................181 9.1.1. L’opérateur typeid......................................................................................181 9.1.2. La classe type_info ....................................................................................183 9.2. Transtypages C++...................................................................................................183 9.2.1. Transtypage dynamique.............................................................................184 9.2.2. Transtypage statique ..................................................................................186 9.2.3. Transtypage de constance et de volatilité...................................................187 9.2.4. Réinterprétation des données.....................................................................187 10. Les espaces de nommage ..................................................................................................189 10.1. Déﬁnition des espaces de nommage.....................................................................189 10.1.1. Espaces de nommage nommés.................................................................189 10.1.2. Espaces de nommage anonymes..............................................................191 10.1.3. Alias d’espaces de nommage...................................................................192 10.2. Déclaration using..................................................................................................192 10.2.1. Syntaxe des uploads/Litterature/ cours-c-c-christian-casteyde-2005.pdf