COURS DE LANGAGE C
1.Généralité
1.1 Historique
Le C a été conçu en 1972 par Dennis Richie et Ken Thompson, chercheurs aux
Bell Labs, afin de développer un système d’exploitation UNIX sur un DEC PDP-
11. En 1978, Brian Kernighan et Dennis Richie publient la définition classique du
C dans le livre The C Programming language. Le C devenant de plus en plus
populaire dans les années 80, plusieurs groupes mirent sur le marché des
compilateurs comportant des extensions particulières. En 1983, l’ANSI
(American National Standards Institute) décida de normaliser le langage ; ce
travail s’acheva en 1989 par la définition de la norme ANSI C. Celle-ci fut reprise
telle quelle par l’ISO (International Standards Organization) en 1990.
1.2 Les outils nécessaires pour programmer en C
Plusieurs outils sont nécessaires pour programmer en C. On distingue :
• Un éditeur de texte pour écrire le code source du programme ;
Ex : CodeBlock, Visual studio, DevC++...
• Un compilateur pour transformer le code en binaire ;
• Un débogueur pour vous aider à traquer les erreurs dans votre programme.
1.3 Les composants élémentaires du C
Un programme en langage C est constitué des groupes de composants
élémentaires suivants :
– les variables,
– les mots-clés,
– les constantes,
– les opérateurs
On peut ajouter à ces groupes les commentaires.
1.3.1 Les variables
Une variable est une petite information temporaire que l’on stocke dans la
mémoire. C’est aussi une valeur qui peut changer pendant le déroulement d’un
programme. Une variable est constituée de :
- Une valeur : c’est le nombre qu’elle stocke, par exemple 1.
- Un nom ou identificateur : c’est ce qui permet de l’identifier.
Un identificateur est une suite de caractères parmi :
– les lettres (minuscules ou majuscules, mais non accentuées),
– les chiffres.
Le premier caractère d’un identificateur ne peut pas être un chiffre mais une lettre.
Par exemple, var1, tab 23 ou deb sont des identificateurs valides ; par contre, 1i
et i : j ne le sont pas. Les majuscules et minuscules sont différenciées : on parle
alors d’un langage qui respecte la casse. Les espaces sont interdits mais on peut
utiliser le underscore (_) pour séparer des mots. C’est le seul caractère différent
des lettres et chiffres autorisé.
➢ Les types de variables
Les principaux types de variables existant en langage C sont :
- ceux qui permettent de stocker des nombres entiers : int, long, signed char
- ceux qui permettent de stocker des nombres décimaux (nombres flottants)
: float, double.
NB : Pour les nombres à virgule, on utilise le pont à la place de la virgule.
Ex : 18.2 pour représenter 18,2.
➢ La déclaration des variables
Pour déclarer une variable, on met le type de la variable suivi de son identificateur.
Ex : int maVariable ; double somme...
NB : Toutes instructions se termine par un point-virgule (;) en C.
1.3.2 Les mots clés
Un certain nombre de mots, appelés mots-clés, sont réservés pour le langage lui-
meme et ne peuvent pas être utilisés comme identificateurs. Parmi ces mots, nous
pouvons citer : const, double, float, int, break, continue, else, for, long, switch,
void, case, default...
1.3.3 Les constantes
On appelle constante toute variable dont la valeur reste inchangée tout au long
d’un programme. Pour déclarer une constante, il faut utiliser le mot clé const juste
avant le type quand vous déclarez votre variable. Ex : const float NOMBRE_VIE
Par convention, on met le nom des variables en majuscules pour différencier ce
dernier du nom des variables.
1.3.4 Les operateurs
• L’affectation
En C, l’affectation est un opérateur à part entière. Elle est symbolisée par le
signe =. Sa syntaxe est la suivante :
variable = expression ;
Le terme de gauche de l’affectation peut être une variable simple, un élément de
tableau mais pas une constante. Cette instruction a pour effet d’évaluer expression
et d’affecter sa valeur à variable.
• Les operateurs arithmétiques
Les opérateurs arithmétiques classiques sont :
+ addition
- soustraction
* multiplication
/ division
% reste de la division (modulo)
L’opérateur % ne s’applique qu’`a des opérandes de type entier.
Notons enfin qu’il n’y a pas en C d’opérateur effectuant l’élévation à la puissance.
De façon générale, il faut utiliser la fonction pow (x, y) de la librairie math.h pour
calculer xy .
• Les opérateurs relationnels
> strictement supérieur
>= supérieur ou égal
< strictement inférieur
<= inférieur ou égal
== égal
! = différent
Attention à ne pas confondre l’opérateur de test d’égalité == avec l’opérateur
d’affection =.
• Les opérateurs logiques
&& et logique
|| ou logique
! négation logique
Comme pour les opérateurs de comparaison, la valeur retournée par ces opérateurs
est de type int qui vaut 1 si la condition est vraie et 0 sinon.
• Les opérateurs d’affectation composée
Les opérateurs d’affectation composée sont +=, -=, *=, /=, %= ...
Pour tout opérateur op, l’expression
a op= b est équivalente à a = a op b
Ex : x += 5 est équivalente à x = x + 5
• Les opérateurs d’incrémentation et de décrémentation
Les opérateurs d’incrémentation ++ et de décrémentation -- s’utilisent aussi bien
en suffixe (i++) qu’en préfixe (++i). Dans les deux cas la variable i sera
incrémentée, toutefois dans la notation suffixe la valeur retournée sera l’ancienne
valeur de i alors que dans la notation préfixe se sera la nouvelle.
Par exemple,
int a = 3, b, c ;
b = ++a ; /* a et b valent 4 */
c = b++ ; /* c vaut 4 et b vaut 5 */
• Règles de priorité des opérateurs
Le tableau suivant classe les opérateurs par ordres de priorité décroissants. Les
opérateurs placés sur une même ligne ont même priorité. Si dans une expression
figurent plusieurs opérateurs de même priorité, l’ordre d’évaluation est défini par
la flèche de la seconde colonne du tableau. On préferera toutefois mettre des
parenthèses en cas de doute...
1.3.5 Les commentaires
Quelque soit le langage de programmation, on a la possibilité d’ajouter des
commentaires à son code. Commenter un code c’est taper du texte au milieu de
votre programme pour indiquer ce qu’il fait, à quoi sert telle ligne de code sans
pour autant le voir après compilation. En C, ils commencent par /* et se termine
par */
2. Les fonctions de lecture et d’écriture et structure d’un code C
Les principales fonctions de lecture et d’écriture en langage C sont scanf et printf.
Ces deux fonctions font parties de la bibliothèques standard ‹ stdio ›.
✓ scanf est une fonction de saisie qui fonctionne avec un format décrivant la
nature de l’information à lire et donc la conversion à effectuer.
- char un_caractere ;
- int un_entier ;
- float un_reel ;
- double un_double ;
- scanf ("%c", &un_caractere) ;
- scanf ("%d", &un_entier) ;
- scanf ("%f", &un_reel) ;
- scanf ("%lf", &un_double) ;
- scanf ("%c%d%lf", &un_caractere, &un_entier, &un_double) ;
Chaque % rencontré dans le format (la chaîne de caractères) est suivi d’un
caractère indiquant la nature de l’information à lire (c pour caractère, d pour
entier, etc.). À chaque % doit correspondre une variable donnée après le format.
Les variables sont séparées par des virgules et sont précédées du signe &.
✓ printf est une fonction de saisie qui, comme scanf, fonctionne avec un
format décrivant la nature de l’information à écrire et donc la conversion à
effectuer.
- char un_caractere = ’A’ ;
- int un_entier = 10 ;
- float un_reel = 3.14 ;
- double un_double = 1.10e-2 ;
- printf ("%c\n", un_caractere) ;
- printf ("%d\n", un_entier) ;
- printf ("%f\n", un_reel) ;
- printf ("%f\n", un_double) ;
- printf ("2 * %d = %d\n", un_entier, un_entier * 2) ;
- printf ("c = %c et nb = %f\n", un_caractere, un_double) ;
✓ Structure
Exercice 1 : Cube d’un réel
Écrire un programme qui affiche le cube d’un nombre réel saisi au clavier.
Exercice 2 : Permuter deux caractères
Écrire un programme qui permute la valeur de deux variables c1 et c2 de type
caractère.
3. Les structures alternatives
• si ... alors .... fsi
Structure
if (condition) {
instruction1;
...
instructionn ;
}
Exercice 3 : Parité d’un nombre entier
Écrire un algorithme qui lit une valeur entière au clavier et affiche « paire » si elle
est paire.
• Si ... alors ... sinon .... fsi
Structure
if (condition) {
instructions ;
...
}
else { /* ! condition */
instructions ;
...
}
Exercice 4 : Maximum de deux valeurs réelles
Étant données deux valeurs réelles lues au clavier, afficher à l’écran la plus grande
des deux.
• La clause SinonSi
Structure
if (condition1){ /* séquence1 */
instructions ;
}
else if (condition2) { /* séquence2 */
instructions ;
}
...
else if (conditionn) { /* séquencen */
instructions;
}
else{
instructions;
}
4. Les structures de répétitions
Il existe trois sortes de structures répétitives : while, do while et for.
• while = tant que
Structure :
while(condition) tant que condition est vraie (≠0)
{ on exécute
bloc d'instructions ; bloc d'instructions
}
Exercice 5 : Écris un programme qui affiche 5 entiers consécutifs
• Do while = faire - tant que
Il est semblable au while, mais : while évalue la condition avant d’exécuter, alors
que do while exécute une fois avant d’évaluer la condition.
Structure :
do on exécute
{
bloc d'instructions ; bloc d'instructions
}
while(condition) ; tant que condition est vrai
Exercice 6 : Écris un programme qui amène l’utilisateur a entre un nombre positif
au clavier.
• for
Structure :
for (expr1 ; expr2 ; expr3) {
bloc d'instructions ;
}
expr1 est évaluée une fois avant le passage dans la boucle, elle est utilisée pour
initialiser les données de la boucle.
expr2 est évaluée à chaque passage de la boucle, elle est utilisée pour savoir si la
boucle est répétée ou non (c'est une condition de répétition, et non d'arrêt).
expr3 est évaluée à la fin de chaque passage de la boucle, elle est utilisée pour
réinitialiser ou incrémenter les données de la boucle.
Équivalent de la boucle for avec while est :
expr1 ;
while(expr2)
{
bloc d'instructions ;
expr3 ;
}
Exercice 7 : Écris un programme qui permet de calculer le factoriel d’un nombre
entier.
• La condition switch
Structure :
switch(condition)
{
case choix :
instructions ;
break ;
...
case choix :
instructions ;
break ;
default :
instructions ;
break ;
}
Exemple :
switch (age)
{
case 12 :
printf (“ Vous êtes adolescent”) ;
break ;
case 18 :
printf (“ Vous êtes juste majeur”) ;
break ;
case 65 :
printf (“ Vous êtes du troisième âge ”) ;
break ;
default :
printf (“Pas de réponse pour votre âge”) ;
break ;
}
Exercice 8 : Reproduire le menu ci-dessous et écrire un programme qui permet à
l’utilisateur de choisir un menu que vous allez l’afficher a l’écran.
__________ MENU__________
1.Igname pilé
2.Charwama
3.Frite
4.Pizza
5.Pâte noire
Entrez votre choix
5. Les tableaux
1) Tableaux à 1 dimension
Un tableau unidimensionnel est une variable structurée formée d’un nombre entier
N de variables simples du même type (composantes du tableau). Lors de la
déclaration de variable, N doit être défini.
a) Déclaration
type Nom_du_tableau[dimension] ;
Remarque : Nom_du_tableau est un identificateur
Exemples :
int A[25]; /*tableau de 25 entiers de type int*/
float B[10]; /*tableau de 10 décimaux de type float*/
char C[30]; /*tableau de 30 caractères (entiers de type char)*/
b) Initialisation et réservation automatique
- Il est possible d’initialiser un tableau lors de sa déclaration, en indiquant la liste
des valeurs
Exemple :
int A[5]={100,200,300,400,500};
Le premier élément du tableau, A[0] contiendra la valeur 100. Le second élément,
A[1], contiendra la valeur 200, le dernier élément, A[4], contiendra la valeur 500.
- Lors de sa déclaration, on peut initialiser le tableau, si le nombre de valeur dans
la liste est inférieur à la dimension du tableau, les composantes restantes sont
mises à 0.
Exemple :
int A[4]={10,20};
Le premier élément du tableau, A[0] contiendra la valeur 10. Le second élément,
A [1], contiendra la valeur 20, le troisième, A[2] sera mis par défaut à 0, de même
pour le dernier élément, A[3].
- Si la dimension n’est pas indiquée, l’ordinateur réserve automatiquement le
nombre d’octets nécessaires.
Exemple :
int A[]={10,20,30};
Les trois éléments du tableau sont initialisés à 10, 20 et 30, la taille du tableau sera
automatiquement mise à 3.
Remarque : Il faut bien évidemment que le nombre de valeurs dans la liste soit
inférieur ou égal à la dimension du tableau !
c) Accès aux composantes
Lorsque l’on déclare un tableau, (par exemple int A[5] ;), on définit un tableau
avec 5 composantes, auxquelles on peut accéder par : A[0], A[1], A[2], A[3], A[4]
Remarque : Le premier élément du tableau est l’élément 0, donc, pour un tableau
de dimension N, le premier sera l’élément 0, le dernier l’élément N-1.
d) Affichage et affectation
La structure for se prête particulièrement bien au travail avec les tableaux.
• Affichage du contenu d’un tableau
Exemple :
int A[5]={1,2,3,4,5} ;
int i ;
for(i=0; i < 5; i++)
printf (“ %d”,A[i]);
Remarque : Avant de pouvoir afficher les composantes d'un tableau, il faut bien
sûr leur affecter des valeurs !
• Affectation
Exemple :
int A[5] ={1,2,3,4,5} ;
int i ;
for(i=0 ;i < 5; i++)
scanf("%d",&A[i]);
2) Tableaux à 2 dimensions
En C, un tableau A à deux dimensions est à interpréter comme un tableau (à une
dimension) de dimension L dont chaque composante est un tableau
(unidimensionnel) de dimension C. On appelle L le nombre de lignes, C le nombre
de colonnes. L et C sont les dimensions du tableau.
Un tableau à deux dimensions contient donc L×C composantes. Rapprochement
avec les maths : "A est un vecteur de L vecteurs de dimension C", ou encore "A
est une matrice de dimensions L et C".
a) Déclaration, réservation automatique
• Déclaration :
type Nom_du_tableau[ligne][colonne] ;
Exemple :
int A[10][10]; /*tableau de 10×10 entiers de type int */
float B[5][4]; /*tableau de 5×4 décimaux de type float*/
char C[2][25]; /*tableau de 2×25 caractères*/
b) Accès aux composantes
Comme pour les tableaux à une dimension, les indices des tableaux varient de 0 à
N-1.
Soit un tableau à deux dimensions A[n][m]:
Premier élément→ A[0][0] ………… A[0][m-1]
: :
: :
A[n-1][0] ………… A[n-1][m-1] ←dernier élément
c) Affichage et affectation
Lors du travail avec les tableaux à deux dimensions, on utilisera (souvent
imbriqués) deux indices (par exemple i et j), et la structure for, pour parcourir les
lignes et les colonnes.
• Affichage
Exemple 1 :
int A[3][2]={{1,2},{10,20},{100,200}};
int i=2, j=1;
printf("élément [%d][%d ]= %d",i,j,A[i][j]);
Exemple 2 :
int A[3][2]={{1,2},{10,20},{100,200}};
int i, j;
for(i=0;i< 3;i++) /* boucle sur les lignes*/
{
for(j=0;j<2;j++) /* boucle sur les colonnes*/
{
printf("%5d",A[i][j]);
}
printf("\n");
}
• Affectation
Exemple :
int A[5][4];
int i, j;
for(i=0;i<5;i++) /* boucle sur les lignes*/
{
for(j=0;j<4;j++) /* boucle sur les colonnes */
{
scanf("%d",&A[i][j]);
}
}
