Ce support 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...
Ce support 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 chaîné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.
2.1.6 Plus grand commun dénominateur (PGCD), algorithme d'Euclide
2.2 Dessins
2.2.1 Tracé d'une règle graduée : "diviser pour résoudre"
2.2.2 Tracé de cercles
2.2.3 Tracé de carrés
2.2.4 Tracé d'un arbre
2.3 Créations et jeux
2.3.1 Trouver un chemin dans un labyrinthe
2.3.2 Création d'un labyrinthe
2.4 Les tours de Hanoï
2.5 Tri rapide d'un tableau de nombres
3. Mise en pratique : récursivité
Listes en C
1. Listes chaînées dynamiques
1.1 Qu'est-ce qu'une liste chaînée ?
1.1.1 Une chaîne constituée de maillons
1.1.2 Trois types de listes chaînées
1.1.3 Les actions sur une liste chaînée
1.1.4 Listes chaînées contre tableaux
1.2 Implémenter une liste simple
1.2.1 Structure de données d'un maillon
1.2.2 Début et fin de la liste
1.2.3 Initialiser un maillon
1.2.4 Ajouter un maillon au début d'une liste
1.2.5 Insérer un maillon dans une liste
1.2.6 Parcourir la liste
1.2.7 Supprimer un maillon au début de la liste
1.2.8 Supprimer un élément sur critère
1.2.9 Détruire la liste
1.2.10 Sauvegarder la liste
1.2.11 Test dans le main()
1.3 Implémenter une liste simple circulaire
1.3.1 Structure de données d'une liste circulaire
1.3.2 Liste vide
1.3.3 Début et fin de la liste
1.3.4 Initialiser un maillon
1.3.5 Ajouter un maillon
1.3.6 Parcourir la liste
1.3.7 Supprimer un maillon
1.3.8 Détruire la liste
1.3.9 Test dans le main()
1.4 Implémenter une liste symétrique
1.4.1 Structure de données
1.4.2 Liste vide
1.4.3 Début et fin de la liste
1.4.4 Initialiser un élément
1.4.5 Ajouter un élément au début
1.4.6 Ajouter un élément à la fin
1.4.7 Parcourir et afficher la liste
1.4.8 Supprimer un élément
1.4.9 Supprimer un élément selon un critère
1.4.10 Détruire la liste
1.4.11 Copier une liste
1.4.12 Test dans le main()
1.5 Mise en pratique : listes chaînées
2. Piles
2.1 Principes de la pile
2.1.1 Modèle de données pile
2.1.2 Implémentation statique ou dynamique
2.1.3 Primitives de gestion des piles
2.1.4 Applications importantes des piles
2.2 Implémentation d'une pile en dynamique
2.2.1 Structure de données
2.2.2 Pile vide, pile pleine
2.2.3 Initialisation
2.2.4 Empiler
2.2.5 Lire le sommet
2.2.6 Dépiler
2.2.7 Vider, détruire
2.2.8 Affichage
2.2.9 Test dans le main()
2.3 Implémentation d'une pile en statique (tableau)
2.3.1 Structure de données
2.3.2 Initialisation
2.3.3 Pile vide, pile pleine
2.3.4 Empiler
2.3.5 Lire le sommet
2.3.6 Dépiler
2.3.7 Vider, détruire
2.3.8 Affichage
2.3.9 Test dans le main()
2.4 Mise en pratique : les piles
3. Files
3.1 Principes de la file
3.1.1 Modèle de données file
3.1.2 Implémentation statique ou dynamique
3.1.3 Primitives de gestion des files
3.1.4 Applications importantes des files
3.2 Implémentation d'une file en dynamique
3.2.1 Structure de données
3.2.2 File vide, file pleine
3.2.3 Initialisation
3.2.4 Enfiler
3.2.5 Lire la tête, lire la queue
3.2.6 Défiler
3.2.7 Vider, détruire
3.2.8 Affichage
3.2.9 Test dans le main()
3.3 Implémentation d'une file en statique (tableau)
3.3.1 Structure de données
3.3.2 File vide, file pleine
3.3.3 Initialisation
3.3.4 Enfiler
3.3.5 Lire la tête, lire la queue
3.3.6 Défiler
3.3.7 Vider, détruire
3.3.8 Affichage
3.3.9 Test dans le main()
3.4 Mise en pratique : les files
4. Arbres
4.1 Généralités sur les arbres
4.1.1 Principe
4.1.2 Exemples d'utilisation des arbres
4.1.3 Nomenclature des arbres
4.2 Types d'arbre
4.2.1 Arbre binaire
4.2.2 Arbre n-aire
4.2.3 Transformer un arbre n-aire en arbre binaire
4.3 Représentations en mémoire
4.3.1 Arbre n-aire
4.3.2 Arbre binaire
4.3.3 Structures de données statiques ou dynamiques
5. Contrôler un arbre binaire
5.1 Créer un arbre binaire
5.1.1 Créer un arbre à partir d'un schéma descriptif
5.1.2 Créer un arbre à partir des données aléatoires d'un tableau
5.1.3 Créer un arbre en insérant des éléments ordonnés
5.2 Parcourir l'arbre
5.2.1 Parcours en profondeur
5.2.2 Parcours en largeur, par niveau
5.3 Afficher l'arbre
5.3.1 Afficher un arbre avec indentation
5.3.2 Dessiner l'arbre sans les liens
5.4 Obtenir des propriétés de l'arbre binaire
5.4.1 Connaître la taille
5.4.2 Connaître la hauteur
5.4.3 Savoir si un nœud est une feuille
5.4.4 Compter le nombre des feuilles de l'arbre
5.4.5 Lister toutes les feuilles
5.4.6 Faire la somme des valeurs des nœuds
5.4.7 Comparer des valeurs des nœuds de l'arbre
5.4.8 Ramener un nœud de l'arbre à partir d'une valeur
5.5 Dupliquer l'arbre
5.6 Détruire l'arbre
5.7 Conversion statique-dynamique d'un arbre binaire
5.7.1 Conversion d'un arbre statique en dynamique
5.7.2 Conversion d'un arbre dynamique en statique
5.8 Sauvegarde et chargement d'un arbre binaire
5.8.1 Sauvegarder un arbre dynamique
5.8.2 Charger (load) un arbre dynamique
5.9 Arbres binaires sur fichiers
5.9.1 Structure de données
5.9.2 Lecture et écriture d'un nœud à partir de son numéro d'enregistrement
5.9.3 Adaptation des fonctions pour les arbres binaires dynamiques ou statiques
5.10 Mise en pratique : arbre binaire
6. Arbres binaires de recherche
6.1 Définition
6.2 Structure de données
6.3 Insérer un élément dans l'arbre selon sa clé
6.3.1 Comparer deux clés
6.3.2 Insérer un élément à la bonne place
6.4 Rechercher dans l'arbre un élément selon sa clé
6.5 Supprimer un élément dans l'arbre de recherche
6.5.1 Trois cas
6.5.2 Fonction de recherche du nœud max
6.5.3 Fonction de suppression
6.6 Lister tous les éléments de l'arbre (parcours en largeur)
6.7 Afficher l'arbre
6.8 Test dans le main()
6.9 Mise en pratique : arbres
Graphisme et jeux sous Allegro
1. Introduction
1.1 Installer la bibliothèque
1.1.1 Package NuGet sous Visual Studio
1.1.2 À propos de Code::Blocks
1.2 Paramétrages indispensables
1.2.1 Choisir un type de bibliothèque
1.2.2 Sélectionner des modules
1.2.3 Vérifier l'installation : premier programme
1.3 Créer une fenêtre
1.4 Obtenir le clavier
1.4.1 Capture simple
1.4.2 Correction des répétitions
1.5 Obtenir la souris
1.5.1 Capture simple
1.5.2 Correction des répétitions
1.6 Création d'un modèle de projet
1.7 Précisions à propos de la fenêtre console
1.7.1 Projet sans console Windows
1.7.2 Console multiplateforme native Allegro 5
2. Contrôler la fenêtre
2.1 Taille et position
2.2 Attribut de redimensionnement
2.3 Obtenir le plein écran
2.4 Contrôle des résolutions de l'écran
2.4.1 Résolutions supportées
2.4.2 Obtenir la plus grande résolution
3. Dessiner
3.1 Couleur, transparence
3.2 Installation du module de dessin
3.3 Lignes, triangles, rectangles, cercles
3.4 Autres fonctions de tracés
3.4.1 Arcs
3.4.2 Courbe de Bézier (spline)
3.4.3 Ruban
4. Images
4.1 Bitmap en mémoire
4.1.1 Créer une bitmap
4.1.2 Dessiner dans une bitmap
4.2 Image
4.2.1 Charger une image
4.2.2 Afficher une image
4.2.3 Sélectionner une image pour la modifier
4.2.4 Obtenir les propriétés de l'image
4.2.5 Sauvegarder une image
4.2.6 Expérimentation de sauvegarde d'une image
4.3 L'image pixel par pixel
4.3.1 Accéder aux pixels
4.3.2 Expérimenter le verrouillage al_get_pixel(), al_put_pixel()
5. Événements
5.1 Mettre en place une boucle d'événements
5.1.1 Création d'une file d'événements
5.1.2 Sélection des types d'événements à prendre en compte
5.1.3 Capture des événements
5.1.4 Identification de l'événement
5.1.5 Autres possibilités de capture d'événements
5.1.6 Récupérer le clavier et la souris dans une boucle d'événements
5.2 Piloter un carré avec les flèches
5.3 Contrôler l'exécution d'un programme avec un minuteur
5.4 Donner de la fluidité aux mouvements du rectangle
6. Animation, sprites
6.1 Introduction
6.2 Un personnage marchant sur place
6.3 Un personnage piloté par le clavier
6.4 Gestion de la couleur du masque
6.5 Contrôle de la vitesse de l'animation
6.6 Récupération d'une série d'images sur un fichier unique
6.7 Plusieurs séquences simultanées
6.7.1 Plusieurs balles qui rebondissent
6.7.2 Plusieurs personnages qui se déplacent
7. Modèle de jeu simple
7.1 Introduction
7.2 Le vaisseau
7.2.1 Mouvements du vaisseau
7.2.2 Structure de données du vaisseau
7.2.3 Initialisation
7.2.4 Affichage
7.2.5 Déplacements
7.3 Boucle événementielle du jeu, organisation du code
7.4 Lancement de missiles
7.4.1 Structure de données du missile
7.4.2 Initialisation
7.4.3 Affichage
7.4.4 Mouvement
7.4.5 Lancement
7.4.6 Mise à jour du code, action
7.5 Avancée des ennemis
7.5.1 Structure de données de l'ennemi
7.5.2 Initialisation
7.5.3 Affichage
7.5.4 Mouvement
7.5.5 Apparition
7.5.6 Mise à jour du code, action
7.6 Collisions
7.6.1 Point dans un rectangle
7.6.2 Point dans un triangle
7.6.3 Intersection de rectangles
7.6.4 Recherche d'une couleur sur un fond
7.7 Destruction des ennemis
7.7.1 Détection de collisions missiles-ennemis
7.7.2 Détection de collisions entre vaisseau et ennemis
7.8 Code complet du programme
Annexe : Priorité et associativité des opérateurs
Index
Frédéric DROUILLON
Frédéric DROUILLON est enseignant, chercheur et aussi créateur dans le domaine de l'informatique et des arts numériques. Il envisage la programmation et ses langages comme un moyen d'expression et de formulation d'idées, une véritable écriture, qui fait naître de la recherche et de la créativité. L'objectif de son enseignement en langage C++ est de permettre au lecteur d'acquérir un savoir-faire fondamental en programmation informatique pour qui lui donnera très certainement envie de pouvoir circuler dans les autres techniques et langages de programmation.