Le C en 20 heures

Date de publication : octobre 2010.

Par Eric Berthomier
Daniel Schang

L'ouvrage que vous tenez dans les mains ou que vous consultez sur votre écran a pour objectif de vous faire découvrir, par la pratique, la programmation en langage C.

Il a été testé par de nombreux étudiants qui n'avaient aucune connaissance préalable de ce langage. En 20 à 30 heures de travail, ils sont tous parvenus au terme de leur apprentissage. Si vous ne connaissez encore rien à la programmation et que vous désirez apprendre, vous serez donc probablement très intéressé(e) par le contenu de cet ouvrage : il est très facile d'accès et destiné aux grands débutants.

Il existe une multitude de façons de programmer un ordinateur, qui dépendent du matériel dont vous disposez, du système d'exploitation que vous utilisez et du langage de programmation que vous choisirez. Nous avons fait le choix d'un système d'exploitation libre : Gnu/Linux et du langage C, très répandu, largement enseigné, et finalement assez simple dans ses constructions.

Néanmoins, même si vous n'utilisez pas Gnu/Linux, vous pouvez sans risque vous lancer dans la lecture de cet ouvrage. Plus de quatre-vingt-quinze pour cent de ce vous y trouverez est

utilisable sans modification avec d'autres systèmes d'exploitation. (1)

Ce livre n'est pas un ouvrage de référence, que vous garderez sur une étagère pour vous y reporter en cas de doute ou d'oubli. Il a été écrit pour être lu d'un bout à l'autre, dans l'ordre : il vous guidera dans votre apprentissage et vous suggèrera de programmer telle chose, de tester telle autre. En ce sens, il est orienté vers la pratique de la programmation et l'enseigne sans doute à la manière dont les auteurs l'ont apprise : devant un ordinateur, à essayer de programmer quelque chose. Vous ne pourrez donc pas profiter pleinement de cet ouvrage sans essayer de faire les nombreux exercices qu'il contient. Et lorsque vous aurez fait ces exercices, vous pourrez comparer vos solutions avec celles indiquées à la fin de chaque chapitre : vous apprendrez en écrivant du code, et en lisant du code. Vous pourrez aussi travailler à votre vitesse. Vous irez peut être vite au début et vous trouverez tout ceci très facile. Il sera néanmoins nécessaire de prendre le temps de ne pas aller trop vite : c'est pourquoi nous vous encourageons à ne pas nécessairement faire des copier/coller du code, mais à le saisir à nouveau, afin de l'assimiler, et aussi de commettre des erreurs que vous devrez ensuite corriger.

Les premières briques de cet ouvrage ont pour origine un cours de Turbo Pascal (2) qu'Éric Berthomier dispensait au sein de l'association Fac Info à l'Université de Poitiers. La seconde rangée de briques fut posée avec l'association Les Mulots à Chasseneuil du Poitou où Eric donna des cours bénévoles de C sous Turbo C 2.0 et MS/DOS. Grâce à cette association, Éric rencontra le GULP (Groupement des Utilisateurs de Linux de Poitiers) qui lui fit découvrir Gnu/Linux : la troisième rangée de briques pouvait commencer. Accompagné par d'autres membres du Gulp, Éric donna des cours de C au sein de cette association à l'Espace Mendès France de Poitiers.

Le contenu de l'ouvrage alors disponible sous forme de fichiers Postscript a stagné quelques années avant d'être récupéré et adapté par Daniel Schang, qui l'a utilisé et enrichi d'une quatrième rangée de briques dans un cadre plus académique à l'ESEO d'Angers.

Il ne nous sera pas possible de dire combien de versions de ce cours ont existé mais là n'est pas le plus important, ce qui compte c'est que vous ayez maintenant ce livre entre les mains et ceci grâce à l'association FramaSoft.

Note de Developpez : cette page présente le livre publié par Framasoft et adapté à la charte graphique de Developpez. Aucune modification du contenu n'a été apportée
Commander le livre

2 commentaires

Sommaire Suivant

Version PDF Version hors-ligne

I. Premiers pas
I-A. Système d'exploitation et C
I-B. Utiliser un éditeur sous Gnu/Linux
I-C. Exemple de programme
I-D. Normalisation du programme
I-E. Petit mot sur ce qu'est une bibliothèque
I-F. Un exemple de fichier en-tête
I-G. Compléments
I-H. Squelette de programme
I-I. Blocs
I-J. Commentaires
I-K. Exercice d'application
I-L. Corrigé de l'exercice du chapitre
I-M. À retenir

II. Variables (1re partie)
II-A. Objectif
II-B. Affichage: la fonction printf
II-C. Notion de variable
II-D. Déclaration d'une variable
II-E. Application : exemples
II-F. Utilisation de % dans printf
II-G. Exercices
II-H. Réutilisation d'une variable
II-I. Caractères spéciaux
II-J. Corrigés des exercices du chapitre
II-K. À retenir

III. Variables (2e partie)
III-A. Objectif
III-B. Exercice de mise en bouche
III-C. Déclaration des variables
III-D. Saisie des variables
III-E. Les types flottants
III-F. D'autres fonctions utiles
III-G. Corrigés des exercices du chapitre
III-H. À retenir

IV. Conditions
IV-A. Objectif
IV-B. Exercice de mise en bouche
IV-C. Condition : Si Alors Sinon
IV-D. Opérateurs de comparaison
IV-E. Opérateurs logiques
IV-F. Vrai ou faux
IV-G. Combinaison
IV-H. Accolades
IV-I. Exercices
IV-J. Corrections des exercices du chapitre
IV-K. À retenir

V. Mise au point
V-A. Objectif
V-B. Plus petit ou plus grand
V-C. Retour sur getchar()
V-D. Boucle : Faire . Tant que (condition)
V-E. Nombres pseudo-aléatoires
V-F. Corrigés des exercices du chapitre

VI. Et les Shadoks pompaient : je pompe donc je suis
VI-A. Objectifs
VI-B. Boucle While
VI-C. Et les Shadoks apprenaient que reprendre équivaut à apprendre
VI-D. Fonction toupper()
VI-E. Ô tant qu'en emporte le Shadok
VI-F. Et les Shadoks continuaient à pomper pour obtenir le résultat
VI-G. Dans le clan des Shadoks, on trie, voyelles, chiffres premiers
VI-H. Incrémentations, pré-incrémentations.
VI-I. Corrigés des exercices du chapitre
VI-J. À retenir

VII. Boucles
VII-A. Et les Shadoks pédalèrent pendant 15 tours
VII-B. Syntaxe
VII-C. Notion de double boucle
VII-D. Et les Shadoks fêtèrent Noël.
VII-D-1. Affichage des ramures du sapin
VII-D-2. Affichage du tronc
VII-E. Table Ascii
VII-F. Corrigés des exercices du chapitre
VII-G. À retenir

VIII. Chapitre 8 : Pointeurs et fonctions
VIII-A. Objectifs
VIII-B. Binaire, octets.
VIII-B-1. Binaire
VIII-B-2. Compter en base 2, 3, 10 ou 16
VIII-C. Variables : pointeurs et valeurs
VIII-C-1. Variables et mémoire
VIII-C-2. Pointeurs
VIII-C-3. Exercice d'application
VIII-D. Fonctions
VIII-D-1. Type void
VIII-D-2. Variables globales et locales
VIII-D-2-1. Variables locales
VIII-D-2-2. Variables globales
VIII-D-3. Utilisation et modification de données dans les fonctions
VIII-D-4. Prototypes des fonctions
VIII-E. Corrigés des exercices du chapitre
VIII-F. À retenir
VIII-F-1. Les différentes bases de numération
VIII-F-2. Pointeur
VIII-F-3. Structure d'un programme C

IX. Chapitre 9 : Tableaux et chaînes de caractères
IX-A. Objectifs
IX-B. Tableaux
IX-B-1. Définition
IX-B-2. Déclaration
IX-B-3. Utilisation
IX-C. Chaînes de caractères
IX-C-1. Déclaration d'une chaîne de caractères
IX-C-2. Affichage d'une chaîne de caractères
IX-C-3. Longueur d'une chaîne de caractères
IX-C-4. Initialisation d'une chaîne de caractères
IX-C-5. Exercices
IX-C-6. La fonction gets : saisie d'une chaîne de caractères
IX-C-7. Passage d'une chaîne de caractères en paramètres
IX-D. Quelques fonctions utiles
IX-D-1. La fonction strcat
IX-D-2. La fonction strncat
IX-D-3. La fonction strcmp
IX-D-4. Les fonctions sprintf et sscanf
IX-E. Tableaux à 2 dimensions
IX-F. Correction des exercices
IX-G. À retenir

X. Structures et fichiers
X-A. Les types synonymes
X-B. Structures
X-C. Bases sur les fichiers
X-D. Fichiers et structures

XI. Débogage dun programme
XI-A. Objectif
XI-B. Deux types d'erreurs
XI-B-1. Erreur à la compilation
XI-B-2. Erreur d'exécution
XI-C. Un phénomène surprenant.
XI-D. La chasse aux bugs.
XI-D-1. Localiser et produire le bug
XI-D-2. Corriger le bug
XI-E. Bonne chasse.
XI-F. Erreurs d'exécution : les erreurs de segmentation.
XI-F-1. Le debugger ddd
XI-F-2. Une autre chasse.
XI-F-3. Dernière sournoiserie.
XI-G. Solutions
XI-H. À retenir
XI-H-1. Le debugger ddd

XII. Compléments
XII-A. Objectif
XII-B. Conversions de type
XII-C. Usage très utile des conversions de type
XII-D. Fonction putchar
XII-E. Allocation dynamique de mémoire
XII-E-1. Fonctions malloc et sizeof
XII-E-2. Fonction free
XII-F. Avez-vous bien compris ceci ?
XII-G. Sur l'utilité des pointeurs
XII-G-1. Modifier une variable dans une fonction
XII-G-2. Saisie d'un nombre dans une fonction
XII-H. Un mot sur les warnings

XIII. Quelques exemples de programmes
XIII-A. Objectifs
XIII-B. Convertisseur francs/euros
XIII-C. Proportion de nombres pairs et impairs
XIII-D. Affichage d'une table de multiplication
XIII-E. Maximum d'un tableau
XIII-F. Inverser les éléments d'un tableau
XIII-G. Tri d'un tableau
XIII-H. Jeu de la vie
XIII-H-1. Historique
XIII-H-2. Règles du jeu
XIII-H-3. Images obtenues
XIII-H-4. Proposition de programme

XIV. En deuxième lecture
XIV-A. Quelques fonctions mathématiques
XIV-B. Pointeurs et structures
XIV-C. En finir avec les warnings du gets
XIV-D. Sortie standard : stdout
XIV-E. Utilité des prototypes
XIV-F. Opérateur ternaire
XIV-G. Tableaux de chaînes de caractères
XIV-H. Pointeurs et tableaux
XIV-I. Tableaux de pointeurs
XIV-J. Choix multiples avec switch
XIV-K. Édition de liens

XV. Exercices
XV-A. Objectifs
XV-B. Jeu de morpion
XV-B-1. Principe
XV-B-2. Affichage du plateau de jeu
XV-B-3. Saisie des coordonnées
XV-B-4. Alternance des joueurs
XV-B-5. Fin du jeu
XV-B-6. Améliorations possibles
XV-C. Jeu de pendu
XV-C-1. Principe
XV-C-2. Exemple
XV-C-3. Un peu d'aide
XV-C-3-1. Point de départ
XV-C-3-2. Algorithme
XV-C-4. Améliorations possibles
XV-D. Balle rebondissante
XV-D-1. Améliorations
XV-E. Solutions
XV-E-1. Le morpion
XV-E-2. Le pendu
XV-E-3. Balle rebondissante

XVI. Annexe A : Petit extrait de la table Ascii

XVII. Annexe B : Bon à savoir

Sommaire Suivant

Version PDF Version hors-ligne