Langage C : maîtriser la programmation procédurale : avec exercices pratiques

Auteur(s) :

Drouillon, Frédéric Découvrir l'auteur

Résumé

Des notions théoriques, des exercices et des études de cas pour apprendre la conception algorithmique avec le langage C. Le code source des exemples est disponible en téléchargement.

Éditeur(s)
- Édition ENI
Date
- C 2021
Notes
- La couv. porte en plus : "En téléchargement : code des exemples" ; "Version en ligne offerte pendant un an !" ; "+ quiz"
- La 4e de couv. indique : "Sur www.editions-eni.fr : le code source des exemples du livre"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (900 p.) : ill. ; 22 cm
Collections
- Ressources informatiques
Sujet(s)
ISBN
- 978-2-409-03101-4
Indice
- 681.229(07) Langages C. Manuels
Quatrième de couverture
- Langage C
  Maîtriser la programmation procédurale
  Ce livre s'adresse aux développeurs débutants qui souhaitent maîtriser la conception algorithmique en s'appuyant sur le langage C. Il est particulièrement adapté aux étudiants en licence d'informatique, école d'ingénieur et prépa scientifique L'efficacité, la modularité et la généricité du langage C vont permettre au lecteur d'acquérir un savoir-faire fondamental en programmation informatique.
  Au-delà du fonctionnement du langage, l'auteur fournit ce qu'il faut de précision et de pratique pour que le lecteur se l'approprie et le maîtrise ; chaque section théorique est suivie d'une section « Mise en pratique » dédiée, composée d'exercices diversifiés et une section « Expérimentation » propose des études de cas.
  Les dix premiers chapitres concernent l'apprentissage du langage C et les premières armes en algorithmique : variables et opérations, concepts de sauts, de branchements, de boucles et de fonctions, structures, tableaux, unions et bien entendu les pointeurs. La suite du livre apporte des approfondissements avec l'étude des listes en C. Les listes chainées dynamiques, mais également les piles et les files ainsi que les arbres, essentiellement les arbres binaires, sont expliqués. Pour ce faire, un chapitre expose la récursivité, élément incontournable pour l'implémentation des arbres. Pour finir, un chapitre consacré à la bibliothèque multimédia Allegro 5 fournit une introduction au graphisme et à la programmation de jeu vidéo.
  Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.
Tables des matières
- - Langage C
  - Maîtriser la programmation procédurale (avec exercices pratiques)
  - 2e édition
  - Editions Eni
  - Introduction
  - 1. Objectif : apprendre à programmer avec le C25
  - 2. Contenu26
  - 3. Librairies graphiques27
  - 4. Public visé27
  - 5. Organisation du livre28
  - 5.1 Chapitres28
  - 5.2 Des questions pour faciliter apprentissage et synthèse29
  - 5.3 Solutions des exercices30
  - 6. Comment apprendre à programmer ?30
  - 6.1 Comprendre n'est pas savoir faire30
  - 6.2 Trois niveaux de difficulté31
  - 6.2.1 Maîtriser les outils31
  - 6.2.2 Résoudre un problème33
  - 6.2.3 Concevoir un programme33
  - 6.3 Un apprentissage non linéaire34
  - 6.4 La programmation comme écriture34
  - Chapitre 1
  - Installations
  - 1. Qu'est-ce que programmer ?37
  - 2. Le positionnement par rapport à l'ordinateur38
  - 3. Les logiciels de la programmation39
  - 3.1 Le compilateur39
  - 3.2 L'IDE : environnement de développement39
  - 4. Travailler avec Visual Studio (conseillé)40
  - 4.1 Installer Visual Studio40
  - 4.2 Créer un projet sous Visual Studio41
  - 4.3 Premier programme sous Visual Studio46
  - 4.3.1 Ajouter une page de code au projet vide46
  - 4.3.2 La fonction main() : entrée du programme47
  - 4.3.3 Afficher du texte avec la fonction printf()48
  - 4.3.4 Compiler le programme49
  - 4.4 Lancer le programme50
  - 4.4.1 Lancer le programme sans débogage depuis Visual Studio (pratique)50
  - 4.4.2 Lancer le programme depuis l'exécutable sur le disque dur.50
  - 4.4.3 Lancer le programme en mode débogage51
  - 4.4.4 Lancer le programme depuis une invite de commandes52
  - 4.5 Conserver la fenêtre console ouverte56
  - 4.5.1 Insérer un point d'arrêt en mode débogage57
  - 4.5.2 Ajouter une instruction58
  - 4.6 Créer un modèle de projet60
  - 4.7 Plusieurs projets dans un même espace de travail64
  - 5. Travailler avec Code ::Blocks66
  - 5.1 Installer Code ::Blocks66
  - 5.2 Créer un projet sous Code ::Blocks66
  - 5.3 Compiler et lancer un programme sous Code ::Blocks72
  - 6. Base d'un programme73
  - 6.1 Des données et des instructions73
  - 6.2 Des librairies de fonctions74
  - 7. Mise en pratique : découverte du compilateur74
  - Chapitre 2
  - Variables simples
  - 1. Introduction77
  - 2. Qu'est-ce qu'une variable en informatique ?78
  - 3. Définir des variables dans un programme78
  - 3.1 Les types de variables élémentaires en C78
  - 3.2 Déclarer ses variables dans un programme80
  - 3.3 Contraintes pour le choix des noms80
  - 4. Mise en pratique : définir des variables dans un programme81
  - 5. Manipulations de base sur les variables81
  - 5.1 Affecter une valeur à une variable81
  - 5.2 Les suffixes L, LL et f83
  - 5.3 Des valeurs de type caractère (codage ASCII)84
  - 5.4 printf() pour afficher des valeurs85
  - 5.5 Obtenir des caractères accentués dans la console (sous Windows)87
  - 5.6 Obtenir et afficher la taille en mémoire d'une variable88
  - 5.7 Obtenir et afficher l'adresse mémoire d'une variable89
  - 5.8 Récupérer une valeur entrée par l'utilisateur90
  - 5.8.1 La fonction scanf()90
  - 5.8.2 Plusieurs entrées dans un seul appel de scanf91
  - 5.9 scanf ou scanf_s ?92
  - 5.9.1 La fonction scanf_s()92
  - 5.9.2 scanf() et scanf_s() sous Visual Studio94
  - 5.10 Précisions pour les emplois de scanf et scanf_s95
  - 5.10.1 Contrôler la saisie avec la valeur de retour de scanf et scanf_s95
  - 5.10.2 Les pièges de scanf et scanf_s96
  - 6. Mise en pratique : manipulations des variables98
  - 7. Les constantes99
  - 7.1 Définition, mot-clé const99
  - 7.2 Macro-constantes #define100
  - 7.3 Suite de constantes enum100
  - 8. Comprendre les variables101
  - 8.1 Codage et mesure de l'information101
  - 8.2 Plages de valeurs en décimal102
  - 8.3 Troncature102
  - 8.4 Codage des nombres négatifs103
  - 9. Expérimentation : variables simples, déclaration, affectation, affichage, saisie104
  - 10. Mise en pratique : codage des informations numériques105
  - Chapitre 3
  - Les opérations
  - 1. Introduction107
  - 2. La notion d'expression107
  - 3. Opérations arithmétiques108
  - 3.1 Les opérateurs +, -, *, /, %108
  - 3.2 Les affectations combinées109
  - 3.3 Opérateurs d'incrémentation et de décrémentation110
  - 3.4 Opérations entre types différents, opérateur de conversion (cast)111
  - 3.5 Priorités entre opérateurs112
  - 4. Mise en pratique : opérations arithmétiques, cast116
  - 5. Obtenir des valeurs aléatoires119
  - 5.1 Principe du pseudo-aléatoire119
  - 5.2 La fonction rand()119
  - 5.3 La fonction srand()121
  - 5.4 Valeurs aléatoires dans des fourchettes122
  - 6. Mise en pratique : opérations et nombres aléatoires124
  - 7. Opérations bit à bit124
  - 7.1 Et : opérateur &124
  - 7.2 Ou exclusif : opérateur ^125
  - 7.3 Ou inclusif : opérateur |126
  - 7.4 Complément : opérateur ~126
  - 7.5 Décalages gauche et droite : opérateurs >> et <<127
  - 7.6 Priorités des opérateurs bit à bit127
  - 8. Mise en pratique : opérations bit à bit127
  - 9. Expérimentation : opérations arithmétiques, valeurs aléatoires128
  - Chapitre 4
  - Les contrôles des blocs d'instructions
  - 1. Blocs d'instructions et conditions131
  - 1.1 Qu'est-ce qu'un bloc d'instructions ?131
  - 1.1.1 Définition131
  - 1.1.2 Exemple132
  - 1.1.3 Utilité d'un bloc d'instructions133
  - 1.2 Définir une condition133
  - 1.2.1 Pourquoi une condition ?133
  - 1.2.2 Comment définir une condition ?133
  - 1.2.3 Les opérateurs de comparaison134
  - 1.2.4 L'opérateur unaire NON : !135
  - 1.2.5 Priorités des opérateurs NON et de comparaison135
  - 1.3 Mise en pratique : opérateurs de comparaison et NON136
  - 2. Sauts conditionnels137
  - 2.1 L'instruction if137
  - 2.2 Le couple d'instructions if-else139
  - 2.3 La forme contractée du if-else, opérateur conditionnel ?140
  - 2.4 La cascade d'instructions if-else if-else142
  - 2.5 Expérimentation : les sauts conditionnels (les trois if)143
  - 2.6 Mise en pratique : les sauts conditionnels146
  - 3. Branchements147
  - 3.1 Branchement sélectif : switch, case et break147
  - 3.2 Rupture de séquence : goto avec étiquette150
  - 3.3 Expérimentation : branchement sélectif switch151
  - 3.4 Mise en pratique : l'aiguillage switch152
  - 4. Les tests multiconditions (ET/OU)154
  - 4.1 Conjonction ET : opérateur &&154
  - 4.1.1 ET avec deux expressions membres154
  - 4.1.2 ET avec plus de deux expressions membres155
  - 4.2 Disjonction OU, opérateur | |156
  - 4.2.1 OU avec deux expressions membres156
  - 4.2.2 OU avec plus de deux expressions membres157
  - 4.3 Et prioritaire sur OU157
  - 4.4 Priorité avec les autres opérateurs158
  - 4.5 Mise en pratique : les opérateurs logiques ET, OU158
  - 5. Boucles160
  - 5.1 Boucle TANT QUE : le while161
  - 5.2 Boucle Faire {...} TANT QUE : le do-while162
  - 5.3 Boucle comptée POUR : le for163
  - 5.4 Boucles imbriquées165
  - 5.5 Sortie et saut forcés dans une boucle165
  - 5.5.1 Sortir avec l'instruction break165
  - 5.5.2 Passer à l'itération suivante avec l'instruction continue166
  - 5.5.3 Sortir d'une ou de plusieurs boucles imbriquées avec l'instruction goto166
  - 5.6 Mise en pratique : les boucles while, do-while et for167
  - 6. Utilisations typiques de boucles170
  - 6.1 Créer un menu utilisateur171
  - 6.2 Boucle d'événements dans un jeu vidéo172
  - 6.2.1 Récupérer les entrées clavier : _kbhit() et _getch()172
  - 6.2.2 Boucle d'événements simple173
  - 6.2.3 Contrôler le temps d'exécution174
  - 6.3 Commencer la création d'un jeu en mode console175
  - 6.4 Mise en pratique : menus, boucles d'événements178
  - 7. Fonctions181
  - 7.1 Principe181
  - 7.2 Exemple de fonction sans retour et sans paramètre183
  - 7.3 Déclaration et visibilité d'une fonction184
  - 7.4 Exemples de fonction avec paramètres185
  - 7.4.1 Déplacer le curseur en écriture de la fenêtre console185
  - 7.4.2 Changer le couleur des caractères186
  - 7.4.3 À propos de la couleur en console187
  - 7.4.4 Afficher une lettre à une position et d'une couleur données dans la console188
  - 7.4.5 Tracer une ligne horizontale189
  - 7.4.6 Le programme complet189
  - 7.5 Exemples de fonctions avec retour191
  - 7.5.1 Retourner un nombre aléatoire entre 0 et 1191
  - 7.5.2 Retourner le résultat d'un lancer de deux dés à six faces191
  - 7.5.3 Programme complet191
  - 7.6 Exemple de fonction avec retour et avec paramètres192
  - 7.6.1 Conversion en chiffres romains192
  - 7.7 Transformer les paramètres d'entrée en sorties195
  - 7.7.1 Précision sur le passage par valeur195
  - 7.7.2 Passage par référence196
  - 7.8 Fonctions avec liste variable de paramètres200
  - 7.8.1 Liste variable de paramètres de même type201
  - 7.8.2 Liste variable de paramètres de types différents202
  - 7.8.3 Transformer printf()204
  - 7.9 Fonctions récursives205
  - 7.10 Mise en pratique : fonctions206
  - 7.10.1 Identifier les composants d'une fonction206
  - 7.10.2 Déclaration de fonctions207
  - 7.10.3 Procédures sans paramètre207
  - 7.10.4 Fonctions sans paramètre208
  - 7.10.5 Fonctions avec paramètres208
  - 8. Gestion des variables213
  - 8.1 Visibilité des variables213
  - 8.1.1 Profondeur de la déclaration213
  - 8.1.2 Portée des variables214
  - 8.1.3 Masquage d'une variable214
  - 8.2 Durée de vie des variables215
  - 8.2.1 Variables globales215
  - 8.2.2 Variables locales (auto)216
  - 8.2.3 Variables static216
  - 8.3 Remarques méthodologiques217
  - 8.4 Mise en pratique : gestion des variables218
  - 8.5 Expérimentations : circuit de voiture220
  - 8.5.1 Principe du circuit220
  - 8.5.2 Structure de données du circuit221
  - 8.5.3 Structure de données de la voiture221
  - 8.5.4 Etapes de l'algorithme, fonctions nécessaires222
  - 8.5.5 Programme commenté222
  - 8.5.6 Conclusion227
  - 8.6 Mise en pratique : recherches algorithmiques227
  - 8.6.1 Création de circuits aléatoires227
  - 8.6.2 Création de trajets non bouclés227
  - 8.6.3 Ascenseur de la tour infernale227
  - 8.6.4 Tracer des lignes229
  - 9. Style, commentaires et indentations229
  - 9.1 Pourquoi soigner le style ?229
  - 9.2 Typographie et choix des noms230
  - 9.3 Indentations rigoureuses et accolades232
  - 9.4 Parenthèses pour dissiper les ambiguïtés234
  - 9.5 Commentaires pertinents235
  - 9.6 Mise en pratique : style, indentations, commentaires235
  - Chapitre 5
  - Les structures
  - 1. Structure237
  - 1.1 Qu'est-ce qu'une structure ?238
  - 1.2 Disposer d'une structure dans un programme238
  - 1.2.1 Définir un type de structure238
  - 1.2.2 Où placer sa définition de structure239
  - 1.2.3 Déclarer ses variables structure239
  - 1.2.4 Utiliser un typedef240
  - 1.3 Utiliser une structure242
  - 1.3.1 Accès aux éléments avec l'opérateur point242
  - 1.3.2 Priorité de l'opérateur point242
  - 1.3.3 Une structure comme champ dans une structure243
  - 1.3.4 Initialiser une structure à la déclaration244
  - 1.3.5 Copier une structure246
  - 1.4 Mise en pratique : définir, déclarer, initialiser des structures246
  - 2. Structures et fonctions247
  - 2.1 Retourner une structure248
  - 2.2 Structures en paramètre de fonction249
  - 2.3 Mise en pratique : structures et fonctions251
  - 2.4 Expérimentation252
  - 2.4.1 Fourmi 1 : une fourmi mobile à l'écran252
  - 2.4.2 Voiture 2 : structure circuit, structure voiture256
  - Chapitre 6
  - Les tableaux
  - 1. Tableaux statiques265
  - 1.1 Qu'est-ce qu'un tableau ?265
  - 1.2 Disposer d'un tableau statique dans un programme266
  - 1.2.1 Définir et déclarer un tableau266
  - 1.2.2 Utiliser des #define pour les tailles266
  - 1.3 Utiliser un tableau267
  - 1.3.1 Accéder aux éléments du tableau avec l'opérateur [ ]267
  - 1.3.2 Priorité de l'opérateur [ ]268
  - 1.3.3 Débordement de tableau268
  - 1.3.4 Initialiser un tableau à la déclaration268
  - 1.3.5 Parcourir un tableau avec une boucle for269
  - 1.3.6 Trier un tableau270
  - 1.4 Précisions sur #define et enum271
  - 1.4.1 Utiliser un #define (directive macroprocesseur)271
  - 1.4.2 Utiliser un enum273
  - 1.5 Tableaux à plusieurs dimensions275
  - 1.5.1 Déclarer un tableau à plusieurs dimensions275
  - 1.5.2 Initialiser à la déclaration277
  - 1.5.3 Parcourir un tableau à plusieurs dimensions277
  - 1.6 Expérimentation : tableaux statiques278
  - 1.7 Mise en pratique : opérations de base sur les tableaux statiques (non dynamiques)283
  - 1.7.1 Déclaration de tableaux, accès aux éléments283
  - 1.7.2 Initialisation de tableaux à la déclaration283
  - 1.7.3 Tableaux à plusieurs dimensions284
  - 1.7.4 Boucles et tableaux285
  - 2. Exemples d'utilisations de tableaux287
  - 2.1 Chaînes de caractères287
  - 2.2 Image bitmap289
  - 2.3 Stocker des données localisées290
  - 2.4 Expérimentation : utilisation de chaînes de caractères291
  - 2.5 Mise en pratique : tableaux292
  - 2.5.1 Chaînes de caractères292
  - 2.5.2 Image, terrain de jeux294
  - 2.5.3 Localisation de données via plusieurs dimensions296
  - 3. Tableaux et structures297
  - 3.1 Tableau comme champ dans une structure297
  - 3.2 Tableau de structures298
  - 3.3 Différences entre tableaux et structures300
  - 3.4 Mise en pratique : tableaux de structures301
  - 3.5 Expérimentations : amélioration du programme voiture 2305
  - 3.5.1 Voiture 3 : une structure trait et un tableau de traits305
  - 3.5.2 Voiture 4 : tableau de structures voiture312
  - 3.5.3 Voiture 5 : un circuit par voiture314
  - 3.5.4 Voiture 5b : un circuit différent pour chaque voiture320
  - 4. Tableaux et fonctions327
  - 4.1 Utiliser un tableau déclaré en global327
  - 4.2 Tableau en paramètre de fonction329
  - 4.2.1 Précision sur le type tableau329
  - 4.2.2 La variable pointeur329
  - 4.2.3 En paramètre, conversion du tableau en pointeur330
  - 4.2.4 Choix pour l'écriture des tableaux en paramètre332
  - 4.2.5 Modification des données via un passage par adresse333
  - 4.2.6 Pas de tableau statique en valeur de retour335
  - 4.3 Quelques fonctions de traitement de chaînes de caractères336
  - 4.3.1 Récupérer une chaîne entrée par l'utilisateur336
  - 4.3.2 Obtenir la taille d'une chaîne336
  - 4.3.3 Copier une chaîne337
  - 4.3.4 Comparer deux chaînes338
  - 4.3.5 Concaténer deux chaînes338
  - 4.4 Expérimentation : tableaux et fonctions339
  - 4.5 Mise en pratique : tableaux et fonctions344
  - 4.5.1 Appels de fonctions, tableaux en paramètre344
  - 4.5.2 Manipulations sur les chaînes348
  - 4.6 Fourmi 2 : une colonie de fourmis349
  - 4.7 Fourmi 3 : plusieurs colonies de fourmis353
  - Chapitre 7
  - Les unions
  - 1. Principe de l'union359
  - 2. Unions discriminées361
  - 3. Union de structures et simulation d'héritage (concept programmation objet)368
  - 4. Tableau d'unions373
  - Chapitre 8
  - Concevoir et réaliser un programme
  - 1. Déterminer le sujet et définir des objectifs381
  - 1.1 Principe de l'automate cellulaire382
  - 1.2 Fonctionnement envisagé382
  - 2. Trouver une structure de données valable384
  - 3. Identifier les fonctions principales385
  - 4. Choisir le niveau des variables fondamentales386
  - 5. Écrire les fonctions387
  - 5.1 Fonction d'initialisation387
  - 5.2 Fonction d'affichage387
  - 5.3 Fonction de calcul388
  - 5.4 Fonction de comptage des voisins389
  - 5.5 Fonction de recopie390
  - 5.6 Montage dans le main()390
  - 6. Intégrer une librairie personnelle392
  - 7. Répartir son code sur plusieurs fichiers C394
  - 7.1 Code réparti en quatre fichiers C395
  - 7.2 Problème de redéfinition398
  - 8. Mise en pratique : structuration d'un programme401
  - 8.1 Simulation d'un feu de forêt401
  - 8.2 Tristus et rigolus402
  - 8.3 Simulation d'une attaque de microbes dans le sang402
  - 8.4 Bancs de poissons, mouvements de populations402
  - 8.5 Élection présidentielle402
  - 8.6 Chenille403
  - 8.7 Système de vie artificielle, colonies de fourmis403
  - 8.8 Boutons et pages403
  - 8.9 Panneaux de bois et entrepôts404
  - 8.10 Nenuphs et clans405
  - 8.11 Neige 1405
  - 8.12 Neige 2406
  - 8.13 Neige 3406
  - 8.14 Casse-brique simple406
  - 8.15 Casse-brique guru406
  - 8.16 Space Invaders simple406
  - 8.17 Space Invaders more407
  - 8.18 Space Invaders guru407
  - 8.19 Pacman débutant407
  - 8.20 Pacman intermediate407
  - 8.21 Pacman guru407
  - 8.22 Jeu de miroirs407
  - 8.23 Simulations football408
  - Chapitre 9
  - Les pointeurs
  - 1. Principe du pointeur409
  - 1.1 Qu'est-ce qu'un pointeur ?410
  - 1.1.1 Mémoire RAM410
  - 1.1.2 Une variable pointeur411
  - 1.1.3 Quatre opérateurs411
  - 1.1.4 Quatre utilisations fondamentales des pointeurs412
  - 1.2 Déclarer un pointeur dans un programme413
  - 1.3 Fonctionnement des quatre opérateurs413
  - 1.3.1 Opérateur adresse : &413
  - 1.3.2 Opérateur étoile : *414
  - 1.3.3 Opérateur flèche : ->416
  - 1.3.4 Opérateur crochet : [ ]417
  - 1.3.5 Priorité des quatre opérateurs417
  - 1.4 Allouer dynamiquement de la mémoire418
  - 1.4.1 La fonction malloc()418
  - 1.4.2 Libérer la mémoire allouée : la fonction free()419
  - 1.4.3 Le pointeur générique void*421
  - 1.4.4 La valeur NULL421
  - 1.5 Attention à la validité d'une adresse mémoire422
  - 1.5.1 Validité d'une adresse mémoire422
  - 1.5.2 Pourquoi caster le retour des fonctions d'allocation ?424
  - 1.6 Pointeurs et constantes425
  - 1.6.1 Pointeur variable sur un objet constant425
  - 1.6.2 Pointeur constant sur un objet variable427
  - 1.6.3 Pointeur constant sur un objet constant428
  - 1.7 Cas des tableaux de pointeurs428
  - 1.7.1 Une structure de données très utile428
  - 1.7.2 Un tableau de chaînes de caractères430
  - 1.7.3 Utiliser les arguments de lignes de commandes431
  - 1.8 Cas des pointeurs de fonction433
  - 1.8.1 Une fonction est une adresse433
  - 1.8.2 Reconnaître un type de fonction433
  - 1.8.3 Appeler une fonction via un pointeur434
  - 1.8.4 Pourquoi des pointeurs de fonction ?435
  - 1.9 Expérimentation : base pointeurs437
  - 1.10 Mise en pratique : base sur les pointeurs440
  - 1.10.1 Définir et manipuler des pointeurs440
  - 1.10.2 Tests tableaux/pointeurs441
  - 1.10.3 Base allocation dynamique443
  - 1.10.4 Attention aux erreurs444
  - 1.10.5 Tableaux de chaînes445
  - 2. Allocation dynamique de tableaux445
  - 2.1 Allouer un tableau en même temps qu'une structure445
  - 2.2 Allouer un tableau avec un pointeur447
  - 2.3 Allouer une matrice avec un pointeur de pointeur449
  - 2.4 Allouer un tableau dynamique de pointeurs453
  - 2.4.1 Tableau dynamique de pointeurs de structures454
  - 2.4.2 Allocation dynamique d'un tableau de pointeurs sur des unions455
  - 2.5 Différences entre tableaux statiques et dynamiques459
  - 2.6 Autres fonctions d'allocation dynamique459
  - 2.6.1 Fonction calloc()460
  - 2.6.2 Fonction realloc()460
  - 2.7 Mise en pratique : allocation dynamique461
  - 2.7.1 Allouer dynamiquement des tableaux461
  - 2.7.2 Allouer dynamiquement des matrices463
  - 2.7.3 Allocation dynamique calloc() et realloc()465
  - 3. Pointeurs en paramètres de fonction466
  - 3.1 Passage par référence466
  - 3.1.1 Cas général d'une variable quelconque466
  - 3.1.2 Exemple : une fonction qui retourne l'heure468
  - 3.1.3 Passage par référence d'une structure469
  - 3.1.4 Passage par référence d'une variable pointeur470
  - 3.2 Subtilités à propos des tableaux en paramètre de fonction474
  - 3.3 Mise en pratique : passage par référence477
  - 3.3.1 Passage par référence, base477
  - 3.3.2 Passage par référence, opérateurs bit à bit478
  - 3.3.3 Passage de pointeurs par référence479
  - 3.3.4 Passage de tableaux dynamiques481
  - 4. Etablir des relations entre structures482
  - 4.1 Association de structures de types différents482
  - 4.2 Association de deux structures de même type485
  - Chapitre 10
  - Introduction aux fichiers
  - 1. Fichiers (type FILE*)489
  - 2. Notions de base490
  - 2.1 Le type FILE*490
  - 2.2 Ouverture et fermeture d'un fichier490
  - 2.3 Spécifier un chemin d'accès493
  - 3. Fichiers binaires494
  - 3.1 Écriture et lecture en mode binaire494
  - 3.2 Détecter la fin d'un fichier binaire496
  - 3.3 Déplacements dans un fichier496
  - 4. Écriture et lecture en mode texte497
  - 4.1 Détecter la fin d'un fichier : EOF et feof()497
  - 4.2 Lecture/écriture de caractères497
  - 4.3 Lecture/écriture de chaînes499
  - 4.4 Lecture/écriture formatées500
  - 5. Sauvegarde d'éléments dynamiques503
  - 5.1 Sauvegarder et récupérer un tableau dynamique503
  - 5.2 Récupérer des données via des pointeurs505
  - 6. Expérimentation : récapitulation sauvegardes binaires505
  - 7. Mise en pratique : fichiers511
  - Chapitre 11
  - Récursivité
  - 1. Fonctions récursives515
  - 1.1 Qu'est-ce que la récursivité ?515
  - 1.2 Une fonction récursive basique516
  - 1.3 Pile d'appels et débordement518
  - 1.4 Retourner une valeur519
  - 1.5 Représentation et analyse du fonctionnement521
  - 1.5.1 Analyse descendante522
  - 1.5.2 Analyse ascendante523
  - 1.6 Choisir entre itératif ou récursif523
  - 2. Exemples classiques de fonctions récursives524
  - 2.1 Calculs524
  - 2.1.1 Afficher les chiffres d'un entier524
  - 2.1.2 Produit factoriel525
  - 2.1.3 Suite de Fibonacci525
  - 2.1.4 Changement de base arithmétique d'un nombre527
  - 2.1.5 Puissance529
  - 2.1.6 Plus grand commun dénominateur (PGCD), algorithme d'Euclide530
  - 2.2 Dessins532
  - 2.2.1 Tracé d'une règle graduée : « diviser pour résoudre »532
  - 2.2.2 Tracé de cercles535
  - 2.2.3 Tracé de carrés536
  - 2.2.4 Tracé d'un arbre538
  - 2.3 Créations et jeux541
  - 2.3.1 Trouver un chemin dans un labyrinthe541
  - 2.3.2 Création d'un labyrinthe545
  - 2.4 Les tours de Hanoï547
  - 2.5 Tri rapide d'un tableau de nombres549
  - 3. Mise en pratique : récursivité551
  - Chapitre 12
  - Listes en C
  - 1. Listes chaînées dynamiques557
  - 1.1 Qu'est-ce qu'une liste chaînée ?557
  - 1.1.1 Une chaîne constituée de maillons557
  - 1.1.2 Trois types de listes chaînées558
  - 1.1.3 Les actions sur une liste chaînée559
  - 1.1.4 Listes chaînées contre tableaux560
  - 1.2 Implémenter une liste simple560
  - 1.2.1 Structure de données d'un maillon561
  - 1.2.2 Début'et fin de la liste561
  - 1.2.3 Initialiser un maillon562
  - 1.2.4 Ajouter un maillon au début d'une liste562
  - 1.2.5 Insérer un maillon dans une liste564
  - 1.2.6 Parcourir la liste568
  - 1.2.7 Supprimer un maillon au début de la liste569
  - 1.2.8 Supprimer un élément sur critère570
  - 1.2.9 Détruire la liste573
  - 1.2.10 Sauvegarder la liste573
  - 1.2.11 Test dans le main()575
  - 1.3 Implémenter une liste simple circulaire578
  - 1.3.1 Structure de données d'une liste circulaire578
  - 1.3.2 Liste vide578
  - 1.3.3 Début et fin de la liste578
  - 1.3.4 Initialiser un maillon579
  - 1.3.5 Ajouter un maillon579
  - 1.3.6 Parcourir la liste580
  - 1.3.7 Supprimer un maillon580
  - 1.3.8 Détruire la liste581
  - 1.3.9 Test dans le main()581
  - 1.4 Implémenter une liste symétrique583
  - 1.4.1 Structure de données583
  - 1.4.2 Liste vide584
  - 1.4.3 Début et fin de la liste584
  - 1.4.4 Initialiser un élément584
  - 1.4.5 Ajouter un élément au début584
  - 1.4.6 Ajouter un élément à la fin585
  - 1.4.7 Parcourir et afficher la liste585
  - 1.4.8 Supprimer un élément586
  - 1.4.9 Supprimer un élément selon un critère586
  - 1.4.10 Détruire la liste587
  - 1.4.11 Copier une liste587
  - 1.4.12 Test dans le main()588
  - 1.5 Mise en pratique : listes chaînées590
  - 2. Piles593
  - 2.1 Principes de la pile593
  - 2.1.1 Modèle de données pile593
  - 2.1.2 Implémentation statique ou dynamique594
  - 2.1.3 Primitives de gestion des piles594
  - 2.1.4 Applications importantes des piles595
  - 2.2 Implémentation d'une pile en dynamique595
  - 2.2.1 Structure de données595
  - 2.2.2 Pile vide, pile pleine596
  - 2.2.3 Initialisation596
  - 2.2.4 Empiler597
  - 2.2.5 Lire le sommet597
  - 2.2.6 Dépiler597
  - 2.2.7 Vider, détruire597
  - 2.2.8 Affichage598
  - 2.2.9 Test dans le main()598
  - 2.3 Implémentation d'une pile en statique (tableau)599
  - 2.3.1 Structure de données599
  - 2.3.2 Initialisation600
  - 2.3.3 Pile vide, pile pleine600
  - 2.3.4 Empiler601
  - 2.3.5 Lire le sommet601
  - 2.3.6 Dépiler602
  - 2.3.7 Vider, détruire602
  - 2.3.8 Affichage603
  - 2.3.9 Test dans le main()603
  - 2.4 Mise en pratique : les piles604
  - 3. Files606
  - 3.1 Principes de la file606
  - 3.1.1 Modèle de données file606
  - 3.1.2 Implémentation statique ou dynamique607
  - 3.1.3 Primitives de gestion des files608
  - 3.1.4 Applications importantes des files608
  - 3.2 Implémentation d'une file en dynamique608
  - 3.2.1 Structure de données608
  - 3.2.2 File vide, file pleine609
  - 3.2.3 Initialisation609
  - 3.2.4 Enfiler610
  - 3.2.5 Lire la tête, lire la queue610
  - 3.2.6 Défiler611
  - 3.2.7 Vider, détruire611
  - 3.2.8 Affichage612
  - 3.2.9 Test dans le main()613
  - 3.3 Implémentation d'une file en statique (tableau)614
  - 3.3.1 Structure de données614
  - 3.3.2 File vide, file pleine615
  - 3.3.3 Initialisation615
  - 3.3.4 Enfiler616
  - 3.3.5 Lire la tête, lire la queue616
  - 3.3.6 Défiler617
  - 3.3.7 Vider, détruire617
  - 3.3.8 Affichage618
  - 3.3.9 Test dans le main()618
  - 3.4 Mise en pratique : les files619
  - 4. Arbres622
  - 4.1 Généralités sur les arbres622
  - 4.1.1 Principe622
  - 4.1.2 Exemples d'utilisation des arbres623
  - 4.1.3 Nomenclature des arbres625
  - 4.2 Types d'arbre626
  - 4.2.1 Arbre binaire626
  - 4.2.2 Arbre n-aire626
  - 4.2.3 Transformer un arbre n-aire en arbre binaire626
  - 4.3 Représentations en mémoire627
  - 4.3.1 Arbre n-aire627
  - 4.3.2 Arbre binaire629
  - 4.3.3 Structures de données statiques ou dynamiques631
  - 5. Contrôler un arbre binaire631
  - 5.1 Créer un arbre binaire631
  - 5.1.1 Créer un arbre à partir d'un schéma descriptif631
  - 5.1.2 Créer un arbre à partir des données aléatoires d'un tableau634
  - 5.1.3 Créer un arbre en insérant des éléments ordonnés636
  - 5.2 Parcourir l'arbre637
  - 5.2.1 Parcours en profondeur637
  - 5.2.2 Parcours en largeur, par niveau641
  - 5.3 Afficher l'arbre643
  - 5.3.1 Afficher un arbre avec indentation643
  - 5.3.2 Dessiner l'arbre sans les liens644
  - 5.4 Obtenir des propriétés de l'arbre binaire645
  - 5.4.1 Connaître la taille645
  - 5.4.2 Connaître la hauteur645
  - 5.4.3 Savoir si un noeud est une feuille646
  - 5.4.4 Compter le nombre des feuilles de l'arbre646
  - 5.4.5 Lister toutes les feuilles647
  - 5.4.6 Faire la somme des valeurs des noeuds648
  - 5.4.7 Comparer des valeurs des noeuds de l'arbre648
  - 5.4.8 Ramener un noeud de l'arbre à partir d'une valeur649
  - 5.5 Dupliquer l'arbre649
  - 5.6 Détruire l'arbre650
  - 5.7 Conversion statique-dynamique d'un arbre binaire651
  - 5.7.1 Conversion d'un arbre statique en dynamique651
  - 5.7.2 Conversion d'un arbre dynamique en statique651
  - 5.8 Sauvegarde et chargement d'un arbre binaire652
  - 5.8.1 Sauvegarder un arbre dynamique652
  - 5.8.2 Charger (load) un arbre dynamique653
  - 5.9 Arbres binaires sur fichiers654
  - 5.9.1 Structure de données654
  - 5.9.2 Lecture et écriture d'un noeud à partir de son numéro d'enregistrement654
  - 5.9.3 Adaptation des fonctions pour les arbres binaires dynamiques ou statiques655
  - 5.10 Mise en pratique : arbre binaire655
  - 6. Arbres binaires de recherche660
  - 6.1 Définition660
  - 6.2 Structure de données661
  - 6.3 Insérer un élément dans l'arbre selon sa clé661
  - 6.3.1 Comparer deux clés662
  - 6.3.2 Insérer un élément à la bonne place662
  - 6.4 Rechercher dans l'arbre un élément selon sa clé663
  - 6.5 Supprimer un élément dans l'arbre de recherche664
  - 6.5.1 Trois cas665
  - 6.5.2 Fonction de recherche du noeud max666
  - 6.5.3 Fonction de suppression666
  - 6.6 Lister tous les éléments de l'arbre (parcours en largeur)668
  - 6.7 Afficher l'arbre669
  - 6.8 Test dans le main()671
  - 6.9 Mise en pratique : arbres673
  - Chapitre 13
  - Graphisme et jeux sous Allegro 5
  - 1. Introduction675
  - 1.1 Installer la bibliothèque676
  - 1.1.1 Package NuGet sous Visual Studio676
  - 1.1.2 À propos de Code : :Blocks680
  - 1.2 Paramétrages indispensables681
  - 1.2.1 Choisir un type de bibliothèque681
  - 1.2.2 Sélectionner des modules683
  - 1.2.3 Vérifier l'installation : premier programme685
  - 1.3 Créer une fenêtre687
  - 1.4 Obtenir le clavier691
  - 1.4.1 Capture simple691
  - 1.4.2 Correction des répétitions694
  - 1.5 Obtenir la souris697
  - 1.5.1 Capture simple697
  - 1.5.2 Correction des répétitions700
  - 1.6 Création d'un modèle de projet703
  - 1.7 Précisions à propos de la fenêtre console704
  - 1.7.1 Projet sans console Windows704
  - 1.7.2 Console multiplateforme native Allegro 5706
  - 2. Contrôler la fenêtre709
  - 2.1 Taille et position709
  - 2.2 Attribut de redimensionnement710
  - 2.3 Obtenir le plein écran712
  - 2.4 Contrôle des résolutions de l'écran714
  - 2.4.1 Résolutions supportées714
  - 2.4.2 Obtenir la plus grande résolution717
  - 3. Dessiner718
  - 3.1 Couleur, transparence718
  - 3.2 Installation du module de dessin720
  - 3.3 Lignes, triangles, rectangles, cercles720
  - 3.4 Autres fonctions de tracés725
  - 3.4.1 Arcs725
  - 3.4.2 Courbe de Bézier (spline)731
  - 3.4.3 Ruban737
  - 4. Images741
  - 4.1 Bitmap en mémoire741
  - 4.1.1 Créer une bitmap742
  - 4.1.2 Dessiner dans une bitmap743
  - 4.2 Image747
  - 4.2.1 Charger une image747
  - 4.2.2 Afficher une image749
  - 4.2.3 Sélectionner une image pour la modifier757
  - 4.2.4 Obtenir les propriétés de l'image757
  - 4.2.5 Sauvegarder une image758
  - 4.2.6 Expérimentation de sauvegarde d'une image759
  - 4.3 L'image pixel par pixel762
  - 4.3.1 Accéder aux pixels762
  - 4.3.2 Expérimenter le verrouillage al_get_pixel(), al_put_pixel()765
  - 5. Événements767
  - 5.1 Mettre en place une boucle d'événements767
  - 5.1.1 Création d'une file d'événements768
  - 5.1.2 Sélection des types d'événements à prendre en compte768
  - 5.1.3 Capture des événements770
  - 5.1.4 Identification de l'événement771
  - 5.1.5 Autres possibilités de capture d'événements774
  - 5.1.6 Récupérer le clavier et la souris dans une boucle d'événements776
  - 5.2 Piloter un carré avec les flèches780
  - 5.3 Contrôler l'exécution d'un programme avec un minuteur784
  - 5.4 Donner de la fluidité aux mouvements du rectangle786
  - 6. Animation, sprites792
  - 6.1 Introduction792
  - 6.2 Un personnage marchant sur place792
  - 6.3 Un personnage piloté par le clavier797
  - 6.4 Gestion de la couleur du masque802
  - 6.5 Contrôle de la vitesse de l'animation803
  - 6.6 Récupération d'une série d'images sur un fichier unique808
  - 6.7 Plusieurs séquences simultanées815
  - 6.7.1 Plusieurs balles qui rebondissent815
  - 6.7.2 Plusieurs personnages qui se déplacent820
  - 7. Modèle de jeu simple832
  - 7.1 Introduction832
  - 7.2 Le vaisseau832
  - 7.2.1 Mouvements du vaisseau832
  - 7.2.2 Structure de données du vaisseau832
  - 7.2.3 Initialisation833
  - 7.2.4 Affichage834
  - 7.2.5 Déplacements834
  - 7.3 Boucle événementielle du jeu, organisation du code835
  - 7.4 Lancement de missiles841
  - 7.4.1 Structure de données du missile841
  - 7.4.2 Initialisation842
  - 7.4.3 Affichage842
  - 7.4.4 Mouvement843
  - 7.4.5 Lancement843
  - 7.4.6 Mise à jour du code, action844
  - 7.5 Avancée des ennemis847
  - 7.5.1 Structure de données de l'ennemi847
  - 7.5.2 Initialisation847
  - 7.5.3 Affichage848
  - 7.5.4 Mouvement848
  - 7.5.5 Apparition848
  - 7.5.6 Mise à jour du code, action849
  - 7.6 Collisions852
  - 7.6.1 Point dans un rectangle852
  - 7.6.2 Point dans un triangle852
  - 7.6.3 Intersection de rectangles856
  - 7.6.4 Recherche d'une couleur sur un fond859
  - 7.7 Destruction des ennemis862
  - 7.7.1 Détection de collisions missiles-ennemis862
  - 7.7.2 Détection de collisions entre vaisseau et ennemis864
  - 7.8 Code complet du programme865
  - Annexe : Priorité et associativité des opérateurs 877
  - Index 879
Origine de la notice:
- BPI