Langage C

éléments de base

Langage C: Structure d’un programme en C

informe le compilateur
d’inclure le fichier stdio.h
qui contient les fonctions
d’E/S (printf, scanf)

et des variables globales

La fonction main est la fonction principale

(instructions) toute instruction simple est

terminée par un point-virgule ;

Une ou plusieurs fonctions dont l’une s’appelle obligatoirement main(), celle-ci

constitue le programme principal. Chaque fonction contient la déclaration de toutes
les variables ainsi que les instructions;
Des commentaires débutent par /* et finissent par */, ils peuvent s’étendre sur
plusieurs lignes. 2

1
 Langage C: Structure d’un programme en C

Directives de pré-compilation :
Elles commencent toutes par un #. Parmi ces directives, une seule est
obligatoire pour le bon fonctionnement d’un programme en langage C:
#include <stdio.h> : En effet, sans elle, on ne peut pas utiliser les
fonctions utiles pour l’affichage à l’écran et la lecture des données au clavier.
#include <math.h> :permet d’utiliser les fonctions mathématiques de base
(sqrt, cos).
#include <stdlib.h> : permet d’utiliser des fonctions générales.
#include<string.h> : permet de manipuler des chaînes de caractères.

Fonction main()
Elle commence par une accolade ouvrante { et se termine par une
accolade fermante }. A l’intérieur, chaque instruction se termine par
un point-virgule. Toute variable doit être déclarée.

Langage C

Langage C :
Les variables

2
 Langage C: Les variables

Elles servent à stocker les valeurs des données utilisées pendant

l’exécution d’un programme.
Elles doivent être déclarées avant d’être utilisées.
Une variable est caractérisée par un :
• nom (Identificateur) : constitué de lettres, de chiffres et du
caractère
• type (entier, réel, …) : l’ensemble des valeurs qu’elle peut
prendre.

Noms des variables :

Le C fait la différence entres les MAJUSCULES et les minuscules. Pour éviter
les confusions, on écrit les noms des variables en minuscule et on réserve
les majuscules pour les constantes.
Les noms doivent commencer par une lettre et ne contenir aucun blanc. Le
seul caractère spécial admis est le soulignement (_).
Il existe un certain nombre de noms réservés (while, if, case, ...), dont on
ne doit pas se servir pour nommer les variables. De plus, on ne doit pas
utiliser les noms des fonctions pour des variables.
5

Langage C: Les variables

Déclaration des variables:

Pour déclarer une variable, on fait précéder son nom par son type. Il existe
6 types de variables :
• char :caractère codé sur 1 octet
int a, b ;
• short :entier codé sur 1 octet int somme;
• int: entier codé sur 4 octets float x,y;
char ch;
• long :entier codé sur 8 octets
• float: réel codé sur 4 octets
• double :réel codé sur 8 octets
On peut faire précéder chaque type par le préfixe unsigned, ce qui force les
variables à prendre des valeurs uniquement positives.

3
 Langage C: Les variables

Déclaration :
La déclaration introduit les variables qui seront
utilisées, leur type et parfois aussi leur valeur de
départ (initialisation).
Syntaxe :
Type NomVar1, NomVar2,..., NomVarN ;
Exemples :
int i, j, k;
float x, y ;
double z=1.5;
short compteur;
char c=`A`;

Langage C: Les Constantes

Déclaration des constantes:

Une constante est une variable dont la valeur est inchangeable lors
de l'exécution d'un programme.
Constante : zone mémoire qui conserve sa valeur pendant toute
l’exécution d’un programme.
Déclaration :
En langage C, les constantes sont définies grâce à la directive du
préprocesseur #define : #define nom_constante valeur; qui
permet de remplacer toutes les occurrences du mot qui le suit par la
valeur immédiatement derrière elle.
Exemple 1 :
#define Pi 3.14; (la constante ne possède pas de type)
Il est ainsi préférable d'utiliser le mot clef const, qui permet de
déclarer des constantes typées :
const type nom = expression ;
Exemple 2:
8
const float Pi =3.14; (la constante est typée)

4
 Langage C

Langage C :
Expression,
opérateurs,
Affectation
9

Langage C: Expressions et opérateurs

Expression :
peut être une valeur, une variable ou une
opération.
Exemples : 1, b, a*2, a+ 3*b-c, …
Opérateur :
symbole qui permet de manipuler des variables pour produire
un résultat.
On distingue :
• les opérateurs binaires : nécessitent deux opérandes (ex : a + b)
• les opérateurs unaires : nécessitent un seul opérande ( ex: a++)
• l'opérateur conditionnel ? : nécessite trois opérandes.
Une expression fournit une seule valeur, elle est évaluée en
respectant des règles de priorité et d’associativité.
10

5
 Langage C: Opérateurs

Exemples d’opérateurs du langage C :

opérateurs arithmétiques : +, -, *, /, % (modulo)
opérateurs d’affectation : =, +=, -=,*=,/=,…
opérateurs logiques : &&, ||, !
opérateurs de comparaison : ==, !=, <, >, <=, >=
opérateurs d’incrémentation et de décrémentation : ++, --
opérateurs sur les bits : &, |, ~, ^, <<, >>
autres opérateurs particuliers : ?:, sizeof, cast, …
Exemples:
5%2 est le reste de la division de 5 par 2 et vaut 1 (opération modulo,
5mod2).
i+=5 ; /* i=i+5 */
i-=3 ; /* i=i-3 */
i*=4 ; /* i=i*4 */
i/=2 ; /* i=i/2 */
11

Langage C: Opérateurs d’affectation

Affectation:
Pour utiliser l’affectation , on utilise le signe "=".
L’expression: a=b ; il sert à mettre dans la variable de gauche la
valeur de ce qui est à droite. Le membre de droite est d’abord
évalué, et ensuite, on affecte cette valeur à la variable de gauche.
Exemples:
char c;
c=‘A’;
est équivalent à char c=‘A’; /*c prend le code ascii de la lettre A 65*/
int i ;
i=50;
Est équivalent à int i=50; /*i prend le valeur 50*/

12

6
 Langage C: Opérateurs

Opérateurs arithmétiques :
Les opérandes peuvent être des entiers ou des réels sauf
pour % qui agit uniquement sur des entiers.
Lorsque les types des deux opérandes sont différents il y’a
conversion implicite dans le type le plus fort.

Conversion implicite se fait comme suit :

int long float double long double. (short et char sont
convertis en int).
Exemple de conversion implicite :

n * p + x (int n ; long p ; float x)

13

Langage C: Opérateurs

Opérateurs incrémentation /décrémentation:

En C, il existe un certain nombre d’opérateurs spécifiques,
qu’il faut utiliser prudemment sous peine d’erreurs.
++ incrémente la variable d’une unité.
- - décrémente la variable d’une unité.
Ces deux opérateurs ne s’utilisent pas avec des réels.

Exemples d’utilisation :
i++ ; /* effectue i=i+1 */
i-- ; /* effectue i=i-1 */

14

7
 Langage C: Opérateurs

Opérateurs incrémentation /décrémentation:

Leur utilisation devient délicate quand on les utilise avec
d’autres opérateurs.
Exemples :
int i=1 , j ;
(j=i)++ ; /* effectue d’abord j=i et ensuite i=i+1 */
/* on a alors j=1 et i=2 */
j=++i ; /* effectue d’abord i=i+1 et ensuite j=i */
/* on a alors j=2 et i=2 */
Quand l’opérateur ++ est placé avant une variable,
l’incrémentation est effectuée en premier. L’incrémentation
est faite en dernier quand ++ est placé après la variable. Le
comportement est similaire pour - -.
15

Langage C: Opérateurs

Opérateurs Logiques :
Les opérateurs qui servent à comparer deux variables sont :
== égal à
!= différent de
< inférieur
<= inférieur ou égal
> supérieur
>= supérieur ou égal
&& ’et’ logique
|| ’ou’ logique

ATTENTION :
Ne pas confondre l’opérateur d’affectation = et l’opérateur de
comparaison ==.

16

8
 Langage C: Opérateurs

Opérateurs de forçage de type (cast) :

Il est possible d’effectuer des conversions explicites
(casting) ou de forcer le type d’une expression.
Syntaxe :
(type) expression;
Exemple :
int n, p;
(double) (n / p); convertit l’entier n/p en double

17

Langage C: Opérateurs

Opérateurs conditionnel ? :
Syntaxe :
exp1 ? exp2 : exp3
exp1 est évaluée, si sa valeur est non nulle c’est exp2 qui est exécutée,
sinon exp3.
Exemple1 :
max = a > b ? a : b
Si a>b alors on affecte à max le contenu de a, sinon on lui affecte b.
Exemple2 :
a>b ? i++ : i--;
Si a>b on incrémente i sinon on décrémente i.

18

9
 Langage C: Opérateurs

Opérateurs sizeof :
Fournit la taille en octets d'un type ou d'une variable.
Syntaxe :
sizeof (type); ou sizeof (variable);
Exemples :
double n;
printf ("%d \n",sizeof(int)); affiche 4
printf ("%d \n",sizeof(n)); affiche 8
Opérateur Sizeof(type):
L’opérateur sizeof(type) renvoie le nombre d’octets réservés en
mémoire pour chaque type d’objet :
Exemple:
n= sizeof(char); /*n vaut 1*/
n= sizeof(int); /*n vaut 4*/
n= sizeof(float); /*n vaut 8*/ 19

Langage C: Opérateurs

Priorités des opérateurs en C :

Priorité 1 (la plus forte) ()

Priorité 2: ! ++ --
Priorité 3: * / %
Priorité 4: + -
Priorité 5: < <= > >=
Priorité 6: == !=
Priorité 7: &&
Priorité 8: ||
= += -= *= /=
Priorité 9 (la plus faible)
%=

20

10
 Langage C

Langage C :
Entrées/sorties

21

Langage C: Entrées-sorties

Les instructions de lecture et d’écriture permettent à

la machine de dialoguer avec l’utilisateur.
La bibliothèque standard <stdio.h> contient un
ensemble de fonctions qui assurent la lecture et
l’écriture des données.

Les principales fonctions qui assurent la lecture et

l’écriture des données sont :
printf() : pour l’écriture formatée de données.
scanf() : pour la lecture formatée de données.

22

11
 Langage C: Entrées-sorties

Printf():
Elle sert à afficher à l’écran la chaîne de caractère donnée en argument,
c’est-à-dire entre parenthèses.
Syntaxe : printf ("format", expr1, expr2, …);
expr1,… : variables et expressions dont les valeurs sont à afficher.
Format : chaîne de caractères qui peut contenir :
1. du texte ;
2. des séquences d’échappement (\n, \t, \r …) ;
3. des spécificateurs de format : indiquant le format d’affichage.

séquences d’échappement
\n retour à la ligne
\t tabulation horizontale
\v tabulation verticale
\" "
\’ ’
\? ?
\! !
\\ \ 23

Langage C: Entrées-sorties

Printf(): Syntaxe : printf ("format", expr1, expr2, …);

spécificateurs de format
Le caractère % indique le format d’écriture à l’écran. Dès qu’un
format est rencontré dans la chaîne de caractère entre " ", le
programme affiche la valeur de l’argument correspondant.
Les formats pour la fonction printf sont :
%d integer entier (décimal);
%u unsigned entier non signé (positif);
%hd short entier court;
%f float réel, notation avec le point décimal (ex. 123.15);
%e float réel, notation exponentielle (ex. 0.12315E+03);
%lf double réel en double précision, notation avec le point
décimal
%le double réel en double précision, notation exponentielle;
%c char caractère;
%s chaîne de caractères. 24

12
 Langage C: Entrées-sorties

Printf():
Exemple 1:
int n=3, m=4 ;
printf("%d",n) ; /*affiche la valeur de n au format décimal , c’est 3 */
printf("n=%d",n) ; /* affiche n=3 */
printf("n=%d, m=%d",n,m) ; /* affiche n=3, m=4*/
printf("n=%5d",n) ; /* affiche la valeur de n sur 5 caractères : n= 3*/
printf(" bonjour tout le monde") ; /* affiche la chaîne de caractère
bonjour tout le monde*/
printf ("code : %05d", 222); /* affiche code : 00222 */
printf ("salaire :%.2f", 4000);/*affiche salaire:4000.00, le format %.2f
affichera un nombre flottant avec 2 chiffres après la virgules.
printf ("donnée :%.3f", 7.54756);/*affiche donnée:7.548, une variable
de type float avec 3 décimales, en arrondissant au plus près.

25

Langage C: Entrées-sorties

Printf():
Exemple 2 :

26

13
 Langage C: Entrées-sorties

Scanf():
La fonction scanf() permet de lire la valeur que l’utilisateur rentre au
clavier et de la stocker dans la variable donnée en argument.
Syntaxe : scanf("format", AdrVar1, AdrVar2, …);
Format : format de lecture de données (le même que pour printf).
adrVar1, adrVar2, … : adresses des variables auxquelles les
données seront attribuées. Ces adresses sont indiquées par le nom
des variables précédé du signe &.
Exemple 1: un programme qui permet de lire deux entiers entrés au
clavier et les afficher :

27

Langage C: Entrées-sorties

Exemple 2:
int a ;
scanf("%d",&a) ;
On retrouve les formats de lecture précisés entre " " utilisés pour
printf(). Pour éviter tout risque d’erreur, on lit et on écrit une même
variable avec le même format.
Le & est indispensable pour le bon fonctionnement de la fonction. Il
indique l’adresse de la variable.
Autres Exemples :
scanf("%d", &a); // Lire un entier
scanf("%s", s); // lire une chaîne de caractères
scanf("%Lf", &f); // lire un réel
scanf("%c", &ch);// lire un caractère

28

14
 Langage C

La sélection en Langage C

1. Sélection avec deux alternatives

2. Sélection avec une seule alternative
3. Imbrication de la Sélection
4. Le choix multiple

29

Langage C: Les structures

Structure linéaire :
La structure linéaire se caractérise par
une suite d’actions à exécuter
successivement dans l’ordre énoncé.
Notation : faire action ;

30

15
 Langage C : Instructions conditionnelle
Instructions conditionnelle if :
L’opérateur de test s’utilise comme suit :
if (condition) { /* la condition est remplie */
instruction;
autre instruction;
} /* fin des instructions conditionnelles */

Exemple :
int a = 10;
if (a <= 20){
printf("la valeur de a est inférieure à 20 \n");
scanf("%d",&a);
}
Ceci va afficher la ligne « la valeur de a est inférieure à 20" à l’écran
car la condition est remplie. 31

Langage C : Instructions conditionnelle

Instructions conditionnelle if (suite if…else):

if (condition) {
instruction 1 ;
} else {
instruction 2 ;
}
/* Si condition est vraie alors l’instruction 1 est exécutée */
/* Sinon, c’est l’instruction 2 qui est exécutée */

Instruction 1 et instruction 2 : instructions quelconques, c’est-à-dire :

• simple (terminée par un point-virgule),
• bloc,
• instruction structurée.
32

16
 Langage C : Instructions conditionnelle

Instructions conditionnelle if (suite if…else):

Exemple :
int a = 10;
if (a > 10)
printf("la valeur de a est strictement supérieure à 10\n");
else
printf("la valeur de a est inférieure ou égale à 10\n");

/* pas d’accolades car il n’y a qu’une instruction */

33

Langage C : Instructions conditionnelle

Instructions conditionnelle : Imbrication des instructions if :

if (expression 1) {
instruction 1 ;
} else if (expression 2) {
instruction 2 ;
} else if (expression 3) {
instruction 3 ;
} else {
instruction 4 ; }

/* Souvent, on imbrique les tests les uns dans les autres */

34

17
 Langage C : Instructions conditionnelle

Instructions conditionnelle if :
L’instruction conditionnelle if nous permet d’utiliser les
testes logiques suivants.
If(a==b) /*si a égal b*/
If(a!=b) /*si a différent de b*/
If(a<=b)
If(a>b)
If(a>=b)
If((a>b)&&(c<d))
/*si la 1 ère comparaison ET la 2ème comparaison sont vraies*/
If((a>b)||(c<d))
/*si la 1 ère comparaison OU la 2ème comparaison sont vraies*/
If(!(a>b)) /*si la comparaison est fausse*/
35

Langage C : Instructions conditionnelle

Instructions conditionnelle switch :

Syntaxe de l’instruction switch

switch (expression)
{ case constante_1 : [ suite_d’instructions_1 ]
case constante_2 : [ suite_d’instructions_2 ]
..............
case constante_n : [ suite_d’instructions_n ]
[ default : suite_d’instructions ]
}
expression : expression entière quelconque,
constante : expression constante d’un type entier quelconque (char est
accepté car il sera converti en int),
suite_d’instructions : séquence d’instructions quelconques.
Les crochets ( [ et ] ) signifient que ce qu’ils renferment est facultatif.
36

18
 Langage C : Instructions conditionnelle

Instructions conditionnelle switch :

Cette instruction s’utilise quand un entier ou un caractère
prend un nombre fini de valeurs et que chaque valeur
implique une instruction différente.
switch(i) {
case 1 : instruction 1 ; /* si i=1 on exécute l’instruction 1 */
break ; /* et on sort du switch */
case 2 : instruction 2 ; /* si i=2 ... */
break ;
case 10 : instruction 3 ; /* si i=10 ... */
break ;
default : instruction 4 ; /* pour les autres valeurs de i */
break ;
}
37

Langage C : Instructions de contrôle

Instructions conditionnelle switch:

Le bloc default n’est pas obligatoire.
L’instruction switch correspond à une cascade d’instruction if…else.
Remarque : on peut ne pas mettre les break ; dans les blocs
d’instructions. Mais alors on ne sort pas du switch, et on exécute
toutes les instructions des case suivants, jusqu’à rencontrer un
break ;.
Si on reprend l’exemple précédent en enlevant tous les break,
alors:
si i=1 on exécute les instructions 1, 2, 3 et 4;
si i=2 on exécute les instructions 2, 3 et 4;
si i=10 on exécute les instructions 3 et 4;
pour toutes les autres valeurs de i, on n’exécute que l’instruction 4.

38

19
 Langage C : Instructions de contrôle

Instructions conditionnelle switch: Exemple

#include <stdio.h>
#include <stdlib.h>
int main()
{
int i=1;
switch(i) {
case 1 : printf("Premier\n"); break;
case 2 : printf("Deuxième\n"); break;
case 3 : printf("Troisième\n"); break;
default : printf("erroné\n"); break;
}}
39

Les boucles en Langage C

1. Boucle do … while
2. Boucle while
3. Boucle for

40

20
 Langage C : Structure itérative

Structures répétitives (itératives ou encore

boucles) : permettent de répéter plusieurs fois
un ensemble donné d’instructions :

1. while,

2. do…while, et

3. for.

41

Langage C : Les Boucles

Boucle while :
Contrairement à la boucle for, on n’est pas obligés ici de
connaître le nombre d’itérations. Il n’y a pas de
compteur.
while (expression)
{
instructions ... ;
}
L’expression est évaluée à chaque itération. Tant qu’elle
est vraie, les instructions sont exécutées. Si dès le
début elle est fausse, les instructions ne sont jamais
exécutées.

42

21
 Langage C : Les Boucles
Boucle while: Exemple
#include <stdio.h>
main(){
float x,R ;
x=1.0 ;
R=10.0 ;
while (x < R) {
x = x+1 ;
printf("x=%f",x) ;
}
}
43

Langage C : Les Boucles

Boucle while: Exemple

44

22
 Langage C : Les Boucles
Boucle do ... While :
A la différence d’une boucle while, les instructions sont
exécutées au moins une fois : l’expression est évaluée
en fin d’itération.

do {
instructions ... ;
}
while (expression)

45

Langage C : Les Boucles

Boucle do ... While : Exemple

46

23
 Langage C : Les Boucles
Boucle for :
Elle permet d’exécuter des instructions plusieurs fois sans avoir
à écrire toutes les itérations. Dans ce genre de boucle, on doit
savoir le nombre d’itérations avant d’entrer dans la boucle. Elle
s’utilise ainsi (Structure for) :
for (expr1 ; expr2 ; expr3)
{
instructions ...;
}
expr1 : effectue l’initialisation (évaluée 1 fois au début de la
boucle).
expr2 : constitue le test de continuation .
expr3 : pour réinitialiser les données de la boucle.

47

Langage C : Les Boucles

Boucle for (suite):
Exemple pour la Structure for :
for (i=0 ; i<N ; i++)
{
instructions ...;
}
Dans cette boucle, i est le compteur. Il ne doit pas être modifié dans
les instructions, sous peine de sortie de boucle et donc d’erreur.
La 1 ère instruction entre parenthèses est l’initialisation de la
boucle.
La 2 ème est la condition de sortie de la boucle : tant qu’elle est
vraie, on continue la boucle.
La 3 ème est l’instruction d’itération : sans elle, le compteur reste à
la valeur initiale et on ne sort jamais de la boucle.
48

24
 Langage C : Les Boucles
Boucle for : Exemple

#include <stdio.h>
#include <stdlib.h>
int main()
{
int i;
for (i=1;i<6;i++)
{
printf("i= %d\n",i);
}
}
Cette boucle affiche 5 fois la valeur de i, c'est-à-dire
1, 2, 3, 4, 5.
49

25