Cours pour programmer en langage C avec exercices corrigés, tutoriel & guide de travaux pratiques langage C en pdf.

QUELQUES RÈGLES D’ÉCRITURE

Ce paragraphe vous expose un certain nombre de règles générales intervenant dans l’écriture d’un programme en langage C. Nous y parlerons précisément de ce que l’on appelle les « identificateurs » et les « mots clés », du format libre dans lequel on écrit les instructions, de l’usage des séparateurs et des commentaires.
Les identificateurs
Les identificateurs servent à désigner les différents « objets » manipulés par le programme : variables, fonctions, etc. Comme dans la plupart des langages, ils sont formés d’une suite de caractères choisis parmi les lettres ou les chiffres, le premier d’entre eux étant nécessairement une lettre.
En ce qui concerne les lettres :
le caractère « souligné » (_) est considéré comme une lettre. Il peut donc apparaître en début d’un identificateur. Voici quelques identificateurs corrects :
les majuscules et les minuscules sont autorisées mais ne sont pas équivalentes (contrairement, par exemple, à ce qui se produit en Pascal). Ainsi, en C, les identificateurs ligne et Ligne désignent deux objets différents.
En ce qui concerne la longueur des identificateurs, la norme ANSI prévoit qu’au moins les 31 premiers caractères soient « significatifs » (autrement dit, deux identificateurs qui diffèrent par leurs 31 premières lettres désigneront deux objets différents).
Les m ots clés
Certains « mots clés » sont réservés par le langage à un usage bien défini et ne peuvent pas être utilisés comme identificateurs. En voici la liste, classée par ordre alphabétique.
Remarque : contrairement à ce qui se passe dans un langage comme le Pascal, il n’y a pas en C de notion d’identificateur prédéfini dont la signification peut, le cas échéant, être modifiée par l’utilisateur.
Nous rencontrerons ultérieurement les autres objets manipulés par le langage C : constantes, étiquettes (de structure, d’union ou d’énumération), membres (de structure ou d’union), types, étiquettes (d’instruction GOTO), macros.
8 I. Généralités sur le langage C
Les séparateurs
Dans notre langue écrite, les différents mots sont séparés par un espace, un signe de ponctuation ou une fin de ligne.
Il en va quasiment de même en langage C dans lequel les règles vont donc paraître naturelles. Ainsi, dans un programme, deux identificateurs successifs entre lesquels la syntaxe n’impose aucun signe particulier2 doivent impérativement être séparés soit par un espace, soit par une fin de ligne. Par contre, dès que la syntaxe impose un séparateur quelconque, il n’est alors pas nécessaire de prévoir d’espaces supplémentaires (bien qu’en pratique cela améliore la lisibilité du programme).
Ainsi, vous devrez impérativement écrire :
int x,y
et non :
intx,y
En revanche, vous pourrez écrire indifféremment :
int n,compte,total,p
ou plus lisiblement :
int n, compte, total, p
Le form atlibre
Comme Pascal, le langage C autorise une « mise en page » parfaitement libre. En particulier, une instruction peut s’étendre sur un nombre quelconque de lignes, et une même ligne peut comporter autant d’instructions que voulu. Les fins de ligne ne jouent pas de rôle particulier, si ce n’est celui de séparateur, au même titre qu’un espace3 (un identificateur ne peut être « coupé en deux » par une fin de ligne, ce qui correspond à l’intuition).
Bien entendu, cette liberté de mise en page possède des contreparties. Notamment, le risque existe, si l’on n’y prend garde, d’aboutir à des programmes peu lisibles.
A titre d’exemple, voyez comment pourrait être (mal) présenté notre programme précédent :
________________________________________________________________________
#include <stdio.h>
#include <math.h>
#define NFOIS 5
main() { int i ; float
x
; float racx ; printf (« Bonjour\n ») ; printf
(« Je vais vous calculer %d racines carrées\n », NFOIS) ; for (i=
0 ; i<NFOIS ; i++) { printf (« Donnez un nombre : « ) ; scanf (« %f »
, &x) ; if (x < 0.0)
printf (« Le nombre %f ne possède pas de racine carrée\n », x) ; else
{ racx = sqrt (x) ; printf (« Le nombre %f a pour racine carrée : %f\n »,
x, racx) ; } } printf (« Travail terminé – Au revoir ») ;}
________________________________________________________________________
Exemple de programm e malprésenté
Tel que : , = ; * ( ) [ ] { }
Sauf dans les « constantes chaînes » où elles sont interdites ; de telles constantes doivent impérativement être écrites à l’intérieur d’une seule ligne.
Les com m entaires
Comme tout langage évolué, le langage C autorise la présence de commentaires dans vos programmes source. Il s’agit de textes explicatifs destinés aux lecteurs du programme et qui n’ont aucune incidence sur sa compilation.
Ils sont formés de caractères quelconques placés entre les symboles /* et */. Ils peuvent apparaître à tout endroit du programme où un espace est autorisé. En général, cependant, on se limitera à des emplacements propices à une bonne lisibilité du programme.
Voici quelques exemples de commentaires :
/* programme de calcul de racines carrées */
/* commentaire fantaisiste &ç§{<>} ?%!!!!!! */
/* commentaire s’étendant
sur plusieurs lignes
de programme source */
/* ============================================
* commentaire quelque peu esthétique *
* et mis en boîte, pouvant servir, *
* par exemple, d’en-tête de programme *
============================================ */
Voici un exemple de commentaires qui, situés au sein d’une instruction de déclaration, permettent de définir le rôle des différentes variables :
int i ;
float x ;
float racx ;
/* compteur de boucle */
/* nombre dont on veut la racine carrée */
/* racine carrée du nombre */

CRÉATION D’UN PROGRAMME EN LANGAGE C

La manière de développer et d’utiliser un programme en langage C dépend naturellement de l' »environnement de programmation » dans lequel vous travaillez. Nous vous fournissons ici quelques indications générales (s’appliquant à n’importe quel environnement) concernant ce que l’on pourrait appeler les grandes étapes de la création d’un programme, à savoir : édition, compilation et édition de liens.
L’édition du program m e 4
L’édition du programme (on dit aussi parfois « saisie ») consiste à créer, à partir d’un clavier, tout ou partie du texte d’un programme :
on parle alors de « programme source ». En général, ce texte sera conservé dans un fichier que l’on nommera « fichier source ».
Chaque système possède ses propres conventions de dénomination des fichiers (par exemple : noms d’au plus 14 caractères sous UNIX, noms d’au plus 8 caractères sous DOS). En général, un fichier peut, en plus de son nom, être caractérisé par un groupe de caractères (généralement 3) qu’on appelle une « extension » (ou, parfois un « type ») ; la plupart du temps, en langage C, les fichiers source porteront l’extension C (c’est le cas sous DOS et sous UNIX).
La compilation
Elle consiste à traduire le programme source (ou le contenu d’un fichier source) en langage machine, en faisant appel à un programme nommé compilateur. En langage C, compte tenu de l’existence d’un préprocesseur, cette opération de compilation comporte en fait deux étapes :
traitement par le préprocesseur : ce dernier exécute simplement les directives qui le concernent (il les reconnaît au fait qu’elles commencent par un caractère #). Il produit, en résultat, un programme source en langage C « pur ». Notez bien qu’il s’agit de connaître le résultat fourni par le préprocesseur. compilation proprement dite, c’est-à-dire traduction en langage machine du texte en langage C fourni par le préprocesseur. Le résultat de compilation porte le nom de module objet.
L’édition de liens
Le module objet créé par le compilateur n’est pas directement exécutable. Il lui manque, au moins, les différents modules objet correspondant aux fonctions prédéfinies (on dit aussi « fonctions standard ») utilisées par votre programme (comme printf, scanf, sqrt).
C’est effectivement le rôle de l’éditeur de liens que d’aller rechercher dans la « bibliothèque standard » les modules objet nécessaires. Notez que cette bibliothèque est une collection de modules objet organisée, suivant l’implémentation concernée, en un ou plusieurs fichiers.
Le résultat de l’édition de liens est ce que l’on nomme un « programme exécutable », c’est-à-dire un ensemble autonome d’instructions en langage machine. Si ce programme exécutable est rangé dans un fichier, il pourra ultérieurement être exécuté sans qu’il soit nécessaire de faire appel à un quelconque composant de l’environnement de programmation en C.
Les fich iers en-tête
Nous avons vu que, grâce à la directive #include, vous pouviez demander au préprocesseur d’introduire des instructions (en langage
provenant de ce que l’on appelle des fichiers « en-tête ». De tels fichiers comportent, entre autres choses :
des déclarations relatives aux fonctions prédéfinies
des définitions de macros prédéfinies.
Lorsque l’on écrit un programme, on ne fait pas toujours la différence entre fonction et macro, puisque celles-ci s’utilisent de la même manière. Toutefois, les fonctions et les macros sont traitées de façon totalement différente par l’ensemble « préprocesseur + compilateur + éditeur de liens ».
En effet, les appels de macros sont remplacés (par du C) par le préprocesseur, du moins si vous avez incorporé le fichier en-tête correspondant. Si vous ne l’avez pas fait, aucun remplacement ne sera effectué, mais aucune erreur de compilation ne sera détectée : le compilateur croira simplement avoir affaire à un appel de fonction ; ce n’est que l’éditeur de liens qui, ne la trouvant pas dans la bibliothèque standard, vous fournira un message.
Les fonctions, quant à elles, sont incorporées par l’éditeur de liens. Cela reste vrai, même si vous omettez la directive #include correspondante ; dans ce cas, simplement, le compilateur n’aura pas disposé d’informations appropriées permettant d’effectuer des contrôles d’arguments (nombre et type) et de mettre éventuellement en place d’éventuelles conversions ; aucune erreur ne sera signalée à la compilation ni à l’édition de liens ; les conséquences n’apparaîtront que lors de l’exécution : elles peuvent être invisibles dans le cas de fonctions comme printf ou, au contraire, conduire à des résultats erronés dans le cas de fonctions comme sqrt.

I. GÉNÉRALITÉS SUR LE LANGAGE C
1 – PRÉSENTATION PAR L’EXEMPLE DE QUELQUES INTRUCTIONS DU LANGAGE C
2 – QUELQUES RÈGLES D’ÉCRITURE
3 – CRÉATION D’UN PROGRAMME EN LANGAGE C
II. LES TYPES DE BASE DU LANGAGE C
1 – LA NOTION DE TYPE
2 – LES TYPES ENTIERS
3 – LES TYPES FLOTTANTS
4 – LES TYPES CARACTÈRES
5 – INITIALISATION ET CONSTANTES
III. LES OPÉRATEURS ET LES EXPRESSIONS EN LANGAGE C
1 – L’ORIGINALITÉ DES NOTIONS D’OPÉRATEUR ET D’EXPRESSION EN LANGAGE C
2 – LES OPÉRATEURS ARITHMÉTIQUES EN C
3 – LES CONVERSIONS IMPLICITES POUVANT INTERVENIR DANS UN CALCUL D’EXPRESSION
4 – LES OPÉRATEURS RELATIONNELS
5 – LES OPÉRATEURS LOGIQUES
6 – L’OPÉRATEUR D’AFFECTATION ORDINAIRE
7 – LES OPÉRATEURS D’INCRÉMENTATION ET DE DÉCRÉMENTATION
8 – LES OPÉRATEURS D’AFFECTATION ÉLARGIE
9 – LES CONVERSIONS FORCÉES PAR UNE AFFECTATION
10 – L’OPÉRATEUR DE CAST
11 – L’OPÉRATEUR CONDITIONNEL
12 – L’OPÉRATEUR SÉQUENTIEL
13 – L’OPÉRATEUR SIZEOF
14 – RÉCAPITULATIF DES PRIORITÉS DE TOUS LES OPÉRATEURS  EXERCICES
IV. LES ENTRÉES-SORTIES CONVERSATIONNELLES
1 – LES POSSIBILITÉS DE LA FONCTION PRINTF
2 – LES POSSIBILITÉS DE LA FONCTION SCANF
EXERCICES
V. LES INSTRUCTIONS DE CONTRÔLE
1 – L’INSTRUCTION IF
2 – L’INSTRUCTION SWITCH
3 – L’INSTRUCTION DO… WHILE
4 – L’INSTRUCTION WHILE
5- L’INSTRUCTION FOR
6 – LES INSTRUCTIONS DE BRANCHEMENT INCONDITIONNEL : BREAK, CONTINUE ET GOTO
EXERCICES
VI. LA PROGRAMMATION MODULAIRE ET LES FONCTIONS
1 – LA FONCTION : LA SEULE SORTE DE MODULE EXISTANT EN
2 – EXEMPLE DE DÉFINITION ET D’UTILISATION D’UNE FONCTION EN C
3 – QUELQUES RÈGLES
4 – LES FONCTIONS ET LEURS DÉCLARATIONS
5 – RETOUR SUR LES FICHIERS EN-TÊTE
6 – EN C, LES ARGUMENTS SONT TRANSMIS PAR VALEUR
7 – LES VARIABLES GLOBALES
8 – LES VARIABLES LOCALES
9 – LA COMPILATION SÉPARÉE ET SES CONSÉQUENCES
10 – LES DIFFÉRENTS TYPES DE VARIABLES, LEUR PORTÉE ET LEUR CLASSE D’ALLOCATION
11 – INITIALISATION DES VARIABLES
EXERCICES
VII. LES TABLEAUX ET LES POINTEURS
1 – LES TABLEAUX À UN INDICE
2 – LES TABLEAUX À PLUSIEURS INDICES
3 – INITIALISATION DES TABLEAUX
4 – NOTION DE POINTEUR – LES OPÉRATEURS * ET &
5 – COMMENT SIMULER UNE TRANSMISSION PAR ADRESSE AVEC UN POINTEUR 92
6 – UN NOM DE TABLEAU EST UN POINTEUR CONSTANT
7 – LES OPÉRATIONS RÉALISABLES SUR DES POINTEURS
8 – LES TABLEAUX TRANSMIS EN ARGUMENT
9 – UTILISATION DE POINTEURS SUR DES FONCTIONS
EXERCICES
VIII. LES CHAÎNES DE CARACTÈRES
1 – REPRÉSENTATION DES CHAÎNES
2 – POUR LIRE ET ÉCRIRE DES CHAÎNES
3 – POUR FIABILISER LA LECTURE AU CLAVIER : LE COUPLE GETS – SCANF
4 – GÉNÉRALITÉS SUR LES FONCTIONS PORTANT SUR DES CHAÎNES
5 – LES FONCTIONS DE CONCATÉNATION DE CHAÎNES
6 – LES FONCTIONS DE COMPARAISON DE CHAÎNES
7 – LES FONCTIONS DE COPIE DE CHAÎNES
8 – LES FONCTIONS DE RECHERCHE DANS UNE CHAÎNE
9 – LES FONCTIONS DE CONVERSION
10 – QUELQUES PRÉCAUTIONS À PRENDRE AVEC LES CHAÎNES
EXERCICES
IX. LES STRUCTURES
1 – DÉCLARATION D’UNE STRUCTURE
2 – UTILISATION D’UNE STRUCTURE
3 – POUR SIMPLIFIER LA DÉCLARATION DE TYPES : DÉFINIR DES SYNONYMES AVEC TYPEDEF
4 – IMBRICATION DE STRUCTURES
5 – À PROPOS DE LA PORTÉE DU MODÈLE DE STRUCTURE
6 – TRANSMISSION D’UNE STRUCTURE EN ARGUMENT D’UNE FONCTION123
7 – TRANSMISSION D’UNE STRUCTURE EN VALEUR DE RETOUR D’UNE FONCTION 125
EXERCICES
X. LES FICHIERS
1 – CRÉATION SÉQUENTIELLE D’UN FICHIER
2 – LISTE SÉQUENTIELLE D’UN FICHIER
3 – L’ACCÈS DIRECT
4 – LES ENTRÉES-SORTIES FORMATÉES ET LES FICHIERS DE TEXTE
5 – LES DIFFÉRENTES POSSIBILITÉS D’OUVERTURE D’UN FICHIER
6 – LES FICHIERS PRÉDÉFINIS
XI. LA GESTION DYNAMIQUE
1 – LES OUTILS DE BASE DE LA GESTION DYNAMIQUE : MALLOC ET FREE
2 – D’AUTRES OUTILS DE GESTION DYNAMIQUE : CALLOC ET REALLOC
3 – EXEMPLE D’APPLICATION DE LA GESTION DYNAMIQUE : CRÉATION D’UNE LISTE CHAÎNÉE
EXERCICE
XII. LE PRÉPROCESSEUR
1 – LA DIRECTIVE #INCLUDE
2 – LA DIRECTIVE #DEFINE
3 – LA COMPILATION CONDITIONNELLE
XIII. LES POSSIBILITÉS DU LANGAGE C PROCHES DE LA MACHINE
1 – COMPLÉMENTS SUR LES TYPES D’ENTIERS
2 – COMPLÉMENTS SUR LES TYPES DE CARACTÈRES
3 – LES OPÉRATEURS DE MANIPULATION DE BITS
4 – LES CHAMPS DE BITS
5 – LES UNIONS
ANNEXE : LES PRINCIPALES FONCTIONS DE LA BIBLIOTHEQUE STANDARD
1 – ENTRÉES-SORTIES (STDIO.H)
2 – TESTS DE CARACTÉRES ET CONVERSIONS MAJUSCULES-MINUSCULES (CTYPE.H)
4 – FONCTIONS MATHÉMATIQUES (MATH.H)
5 – UTILITAIRES (STDLIB.H)
CORRECTION DES EXERCICES

…………