STRUCTURE DE DONNEES AVANCEES ET

PROGRAMMATION

Dr Ibrahima GAYE - Université Alioune DIOP de Bambey

19 mai 2021

CHAPITRE I : CONCEPTS DE BASE DU LANGAGE C

2
SRT - Licence2

Table des matières

1 INTRODUCTION 5

2 Cycle de Développement d’un Programme C 5

2.1 Création du code source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2 Compilation du code source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.3 Création du fichier exécutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.4 Schéma récapitulatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 STRUCTURE D’UN PROGRAMME C 7

3.1 Exemple 2 : somme.c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3.2 Commentaires de l’exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

4 LES OBJETS 10

4.1 Nom de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.2 Mots clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.3 Les types de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.3.1 Les variables entières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.3.2 Les variables flottantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.4 Les fonctions d’affichage et de saisie . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.5 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.6 Les constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.6.1 Constantes littérales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.6.2 Constantes symboliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

5 Les Instructions 18

6 Les Expressions 19

7 Les Opérateurs 20

7.1 L’opérateur d’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Dr Ibrahima GAYE 3 UADB

SRT - Licence2

7.2 Les opérateurs mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

7.2.1 Les opérateurs unaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

7.2.2 Les opérateurs binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

7.2.3 Priorités (hierarchie) relatives et parenthésage . . . . . . . . . . . . . . . . . 24

7.2.4 Ordre de traitement des sous-expressions . . . . . . . . . . . . . . . . . . . 25

7.3 Les opérateurs relationnels (ou de comparaison) . . . . . . . . . . . . . . . . . . . . 25

7.4 Les opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

7.5 Les opérateurs d’affectation composés . . . . . . . . . . . . . . . . . . . . . . . . . 29

7.5.1 L’opérateur de condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

7.6 Les opérateurs de manipulation de bits . . . . . . . . . . . . . . . . . . . . . . . . . 30

7.7 L’opérateur séquentiel : la virgule . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Dr Ibrahima GAYE 4 UADB

SRT - Licence2

1 INTRODUCTION

Le langage C a été créé par Dennis Ritchie aux Laboratoires Bell de Téléphonie entre 1970 et
1972. L’objectif du langage était de développer le système d’exploitation UNIX (Multipostes et
Multitâche) déjà présent sur de nombreux ordinateurs. Très tôt, le langage se révéla puissant et
souple, d’où sa facile adoption par les programmeurs professionnels.

Les avantages du C sont nombreux :

– Une grande bibliothèque de fonctions : Le C, suivant les machines utilisées, dispose d’un
grand nombres de fonctions, que ce soit des fonctions mathématiques, de gestion de fichiers ou
d’entrées & sorties.
– Proche de la machine : Le C est très proche de la machine en pouvant accéder aux adresses
des variables.
– Très rapide : Aucun contrôle de débordement n’est effectué, ce qui apporte une plus grande
vitesse.

Pour faire un programme en langage C (comme dans d’autres langages), une logique fondamen-
tale serait de :

– définir les objectifs du programme,

– choisir les méthodes que l’on veut utiliser pour écrire ce programme,
– créer le programme,
– enfin, l’exécuter et observer les résultats.

2 Cycle de Développement d’un Programme C

Les différentes étapes de développement d’un programme C la création du code source, la compi-
lation et la création du fichier exécutable.

2.1 Création du code source

Il s’agit de la phase de saisie, éventuellement de modification du texte du programme. Le texte

saisi est constitué d’une série de commandes et de déclarations et est appelé code source. C’est la
première étape du développement ; le code source est créé à l’aide d’un éditeur.

Exemple 1

] include <stdio.h>

Dr Ibrahima GAYE 5 UADB

SRT - Licence2

main()
{

printf ("le langage C vous souhaite la bienvenue") ;

Le code source sera sauvegardé dans un fichier dont le nom aura l’extension .c

Par exemple, au programme précédent, on pourra donner le nom suivant : premier.c

2.2 Compilation du code source

L’ordinateur ne peut pas comprendre le code source C. Il ne comprend que des instructions binaires
(langage machine). Le code source devra alors être transmis au compilateur qui le transforme
en langage machine.On parle de compilation. Le résultat de la compilation est l’obtention d’un
code objet qui sera rangé dans un fichier d’extension .o(ici premier.o). Le code objet contiendra
les mêmes instructions que le code source.

2.3 Création du fichier exécutable

Le fichier objet n’est pas directement exécutable ; son contenu n’est pas complet. On le complète par
l’incorporation des modules objets des routines et fonctions prédéfinies que le programme utilise.
Un compilateur C dispose de routines ou fonctions telle que printf(), réalisant rapidement les
opérations les plus fréquentes. L’opération d’incorporation est réalisée par un programme dit de
chaînage (linker) ou d’édition des liens, qui combine les instructions de programmes présentes dans
le fichier objet avec les routines fournies par le compilateur, pour aboutir enfin au code exécutable.
On obtiendra alors un fichier exécutable de même nom que le fichier objet mais d’extension .exe(ici
premier.exe).

2.4 Schéma récapitulatif

Dr Ibrahima GAYE 6 UADB

SRT - Licence2

Figure 1 –

3 STRUCTURE D’UN PROGRAMME C

3.1 Exemple 2 : somme.c

3.2 Commentaires de l’exemple

Appel d’un fichier ]include

L’instruction d’appel (directive) ] include indique au compilateur C qu’il doit inclure le contenu
d’un fichier dans le programme pendant la compilation. Ce fichier inclus (fichier entête) contient
des informations destinées au programme ou au compilateur.Ces fichiers inclus, livrés avec le com-
pilateur, ne sont pas à modifier, et ont tous une extension .h.

La fonction main()

Dans les deux exemples donnés,on remarque la présence de la fonction main() (principale)qui est
le seul bloc obligatoire d’un programme C. L’exécution d’un programme C débute à la première
instruction de () et se termine avec la dernière instruction de cette fonction.

La définition de variable

Une variable est un nom donné à une zone mémoire. Le programme a besoin de mémoire pour
stocker ses données en cours d’exécution. En C, une variable doit être déclarée avant d’être utilisée.
La déclaration d’une variable précise son nom et son type. Par exemple, la ligne 3 de l’exemple 2
définit trois variables nommées , b et c, qui contiendront chacune une variable entière.

Déclaration de fonction

Dr Ibrahima GAYE 7 UADB

SRT - Licence2

1: /* Calcul de la somme de nombres entiers */

2: #include<stdio.h>
3: int a, b, c ;
4: int addition(int x, int y) ;
5: main()
6: {
7: /* Lecture du premier nombre */
8: printf("Entrer un nombre compris entre 0 et 50") ;
9: scanf("%d",&a) ;
10 : /* Lecture du second nombre */
11 : printf("Entrer un nombre compris entre 1 et 51") ;
12 : scanf("%d",&b) ;
13 : /* Calcul de la somme et affichage du résultat */
14 : c=addition(a, b) ;
15 : printf("%d plus %d = %d",a,b,c) ;
16 : return 0 ; /* avec ou sans */
17 : }
18 : /* La fonction renvoie la somme des deux arguments */
19 : int addition(int x,int y)
20 : {
21 : return (x+y) ;
22 : }

Dr Ibrahima GAYE 8 UADB

SRT - Licence2

La ligne 4 de l’exemple 2 est une déclaration de fonction de nom addition et de paramètres

entiers x et y. Cette déclaration (et non la définition)de fonction apparaître avant l’utilisation de
la fonction.

Les instructions

Elles constituent le travail réalisé par le programme. On peut avoir les instructions d’affichage,
de lecture (au clavier), d’appel de fonction, d’opérations mathématiques,d’affectation etc. Chaque
instruction occupe généralement(pas obligatoire) une ligne et se termine par un point virgule.

– L’instruction printf() :c’est une fonction de bibliothèque qui envoie des informations à l’écran.
Elle peut être utilisée pour afficher n’importe quel message texte qui sera encadré par des guille-
mets (double quottes). C’est le cas des lignes 8 et 11 par exemple. A la ligne 15, on a fournit
à la fonction printf() des arguments de type entier dont les premiers sont les formats %d qui
précisent comment seront affichées les informations contenues dans les variables entières a, b et
c. %d indique que ce qui suit n’est pas du texte mais un code de format qui précise qu’on affiche
la valeur reçue en argument (ici a, bet c). Toujours à la ligne 15, on remarque \n le caractère
de fin de ligne qui provoque le passage à la ligne suivante.
– L’instruction scanf() :c’est une autre fonction de bibliothèque qui lit les données entrées au
clavier et les attribue à des variables du programme. Dans l’exemple 2, on peut la retrouver aux
lignes 9 et 12. La fonction scanf() possède en argument un (code de) format %d qui correspond
à une valeur entière. L’argument &a indique à la fonction, l’adresse mémoire de rangement de
la valeur de a. Remarque : Sans l’opérateur & (adresse de), les informations lues seront rangées
dans des emplacements aléatoires et aucune erreur de compilation ne sera détectée.
– L’instruction return : celle de la fonction addition() renvoie le résultat de la somme de x et y
au programme appelant. Celle de la fonction principale (main) ne retourne aucune valeur ; elle
peut être facultative.

La définition de fonction

Une fonction est une portion de code indépendante qui effectue une certaine tâche. La fonction
addition() est une fonction utilisateur c’est-à-dire écrite par le programmeur.

Les commentaires du programme

/* ... ...*/ désigne un commentaire et est ignoré lors de la compilation. On ne doit pas imbriquer
les commentaires car cela peut provoquer des erreurs de compilation.

Les accolades{}

Dr Ibrahima GAYE 9 UADB

SRT - Licence2

Les lignes de programme des fonctions en C sont encadrées par des accolades. Tout bloc d’instruc-
tions doit aussi être entre accolades.

4 LES OBJETS

4.1 Nom de variables

Le nom d’une variable doit respecter certaines règles :

– il est formé d’une suite de caractères choisis parmi les lettres, les chiffres et le caractère "souligné"
(_)
– le premier caractère doit être une lettre ou le caractère "souligné" (_)
– les majuscules ne sont pas équivalentes aux lettres minuscules. Ainsi taux et Taux ne représentent
pas la même variable
– les mots clés (réservés au langage) ne peuvent pas être utilisés comme de variables

Noms de variable Validité

Taxe_annuelle ⇒ correct
Taxe-mensuelle ⇒ incorrect (-)
Z39_hdyd ⇒ correct
_taxe#juin ⇒ incorrect (#)
_taxe_60 ⇒ correct
double ⇒ incorrect (mot clé)
int ⇒ incorrect (mot clé)
6_taxe ⇒ incorrect (6)

Le Turbo C ne fixe pas de limite à priori en ce qui concerne la longueur des identificateurs (noms des
variables ou des fonctions). Cependant, seuls les 32 premiers caractères (norme ANSI : 8 premiers)
sont pris en compte.

Remarque

L’utilisateur peut fixer luimême le nombre de caractères significatifs d’un identificateur à l’aide de
la commande : Option/Compiler/Source/Identifier length.

Dr Ibrahima GAYE 10 UADB

SRT - Licence2

auto double int struct

break else long switch
case enum register typedef
char extern return union
const define include short
float unsigned void for
while do if static
long sizeof
continue goto volatile signed

Table 1 – Quelques mots clés

4.2 Mots clés

Les mots suivants sont réservés. Leur fonction est prévue par la syntaxe de C et ils ne peuvent pas
être utilisées dans un autre but. Dans le tableau 1, vous avez quelques exemples de mots clés

4.3 Les types de variables

Il existe en C plusieurs types de variables. Types de base

Nombres entiers

Anonymes

Petites tailles

singés char
non signés unsigned char

Tailles moyennes

singés short
non signés unsigned short

Grandes tailles

singés long
non signés unsigned long

Nommés

enum

Dr Ibrahima GAYE 11 UADB

SRT - Licence2

nombres flottants

Simples float
Grande précision double
Très grande précision long double

Types de dérivés

Tableau []
Pointeur *
Fonction ()
Structure struct
Union union

Le tableau ci-dessus présente l’ensemble des types connus du compilateur C. L’organisation générale
de cet ensemble est évidente : on dispose de deux sortes de types de base, les nombres entiers et les
nombres flottants, et d’une famille infinie de types dérivés obtenus en appliquant quelques procédés
récursifs de construction, soit à des types fondamentaux, soit à des types dérivés définis de la même
manière.

4.3.1 Les variables entières

La classification des types entiers obéit à deux critères :

– Si on cherche à représenter un ensemble de nombres tous positifs on pourra adopter un type
non signé ; par contre si on doit représenter un ensemble contenant des nombres positifs et des
nombres négatifs on devra utiliser un type signé.
– Le deuxième critère de classification des données numériques est la taille requise par leur repré-
sentation. Comme précédemment, c’est un attribut d’un ensemble, et donc d’une variable devant
représenter tout élément de l’ensemble, non d’une valeur particulière. Par exemple, le nombre
123 considéré comme un élément de l’ensemble 0, ..., 65535 est plus encombrant que le même
nombre 123 quand il est considéré comme un élément de l’ensemble 0, . . . , 255.
Avec N chiffres binaires (ou bits) on peut représenter :
– soit les 2N nombres positifs 0, 1,... 2N − 1 (cas non signé) ;
– soit les 2N nombres positifs et négatifs −2N −1 ,..., 2N −1 − 1 (cas signé).
unsigned short : N =16 bits pour représenter un nombre entier compris entre 0 et 65.535
short : N =16 bits pour représenter un nombre entier compris entre -32.768 et 32.767
unsigned long : N =32 bits pour représenter un nombre entier entre 0 et 4.294.967.296
long : N =32 bits pour représenter un entier entre -2.147.483.648 et 2.147.483.647

Dr Ibrahima GAYE 12 UADB

SRT - Licence2

Type Mots-cles Nombre d’octets

Caractère char 1
Entier int 2
Entier court short 2
Entier long long 4
Caractère non signé unsigned char 1
Entier non signé unsigned int 2
Entier court non signé unsigned short 2
Entier long non signé unsigned long 4

Remarque :

On remarque que short et int sont identiques, mais peuvent être différents sur d’autres types
machines. En principe, le type int correspond à la taille d’entier la plus efficace, c’est-à-dire la plus
adaptée à la machine utilisée. Sur certains systèmes et compilateurs int est synonyme de short,
sur d’autres il est synonyme de long.
Le type int peut donc poser un problème de portabilité : le même programme, compilé sur deux
machines distinctes, peut avoir des comportements différents. D’où un conseil important : n’utilisez
le type int que pour des variables locales destinées à contenir des valeurs raisonnablement petites
(inférieures en valeur absolue à 32767). Dans les autres cas il vaut mieux expliciter char, short ou
long selon le besoin.
Un type énuméré, ou énumération, est constitué par une famille finie de nombres entiers, chacun
associé à un identificateur qui en est le nom.

Exemple :

enum jour_semaine {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} ;

introduit un type énuméré, appelé enum jour_semaine, constitué par les constantes lundi valant
0, mardi valant 1, mercredi valant 2, etc. Ainsi, les expressions mardi + 2 et jeudi représentent
la même valeur. Les valeurs d’un type énuméré se comportent comme des constantes entières.

4.3.2 Les variables flottantes

Les variables à virgule flottante contiennent des valeurs pouvant avoir des chiffres après la virgule
(nombres réels). On distingue principalement trois (norme ANSI) types flottants : f loat (simple
précision), double (double précision) et long double (précision étendue).
Typiquement, sur des systèmes de taille moyenne, un f loat occupe 4 octets et un double 8, ce qui

Dr Ibrahima GAYE 13 UADB

SRT - Licence2

donne par exemple des f loat allant de -1.2 E-38 à 3.4 E+38 avec 7 chiffres décimaux significatifs,
et des double allant de -2.2 E-308 à 1.4 E+308 avec au moins 15 chiffres décimaux significatifs.

4.4 Les fonctions d’affichage et de saisie

La fonction d’affichage Elle permet d’afficher des messages et/ou des valeurs de variables sous
différents formats.

Syntaxe :

printf("Format 1, ...., Format n",identificateur 1, ....,identificateur n) ;

Le format : Il indique comment vont être affiché les valeurs des variables. Il est composé de texte
et de codes d’affichage suivant le type de variable.
Exemple :
printf("la valeur de %d au carré est de %d",i,i*i) ;
Codes d’affichage :

Type Format

Entier décimal %d
Entier octal %o
Entier Hexadécimal %x
Entier Non Signé %u
Caractère %c
Chaîne de Caractère %s
Flottant %f
Scientifique %e
Long Entier %ld
Long Entier non Signé %lu
Long Flottant %lf

Puts : Elle permet d’afficher une chaîne de caractères à l’écran.

Syntaxe : puts(identificateur de chaîne de caractères) ;

La fonction de saisie

Elle permet de saisir des valeurs de variables formatées à partir du clavier. Comme printf elle

Dr Ibrahima GAYE 14 UADB

SRT - Licence2

est composée des formats et des identificateurs de variables à saisir. A la différence de printf , le
format ne peut contenir de texte, il est juste composé du format des valeurs à saisir.
Syntaxe : scanf("Format1, ...., Format n",identificateur 1, ...., identificateur n) ;
Remarque : Le symbole & est obligatoire devant les identificateurs car scanf attend des adresses
et non des valeurs, sauf devant un identificateur de chaîne de caractères.
Les codes d’affichage pour printf deviennent les codes d’entrée pour scanf.

getchar : Elle permet de saisir un caractère au clavier. Syntaxe : identificateur1 = getchar(void) ;

NB : Au début d’un programme utilisant les fonctions d’affichage et de saisie il est nécessaire
d’écrire #include <stdio.h>, car toutes ces fonctions sont déclarées dans ce fichier d’entête.

Exercice

Réaliser un programme qui affiche la taille des types de variables. Indication : on utilisera l’opéra-
teur sizeof (type).

4.5 Déclaration des variables

Rappel : toute variable doit être déclarée avant son utilisation. La déclaration de variable indiquera
au compilateur le nom et le type de la variable. Si on utilise une variable non déclarée, alors le
compilateur génère un message d’erreurs. Syntaxe de la déclaration :
nom_type nom_variable
nom_type indique le type de la variable et doit faire partie des mots-clés répertoriés.
nom_variable est le nom de la variable déclarée.
Exemple :
int nombre, prix ;
float taux, note, moyenne ;

Remarque

Une déclaration de variable peut s’accompagner de l’initialisation de la variable.

Exemple :

int nombre =10 ;

float taux =0.05, note, moyenne ;
L’instruction
int nombre =10 ;

Dr Ibrahima GAYE 15 UADB

SRT - Licence2

réserve un emplacement mémoire pour une variable nommée nombre, mais de plus, elle y range la
valeur 10.

Remarque

Il ne faut initialiser une variable avec une valeur qui ne correspond pas au type déclarée. Le
programme pourra donner des résultats erronés sans détection d’erreurs par le compilateur. Les
deux initialisations suivantes sont incorrectes :

int nombre =10.000 ;

unsigned int prix = -2510 ;

Exercice :

Réaliser un programme qui change les valeurs des initialisations des variables.
Conclure.

Remarque

On peut également définir des types "synonymes" avec le mot-clé typedef.

Exemple :

La déclaration typedef int entier ; signifie que entier est "synonyme" de int, de sorte que les décla-
rations suivantes soient équivalentes :
int n, p ;
entier n, p ;
Remarque

typedef ne crée pas un nouveau type de donné ; il permet seulement d’utiliser un nom différent
pour un type de donnée déjà défini. typedef permet de faciliter la lecture des programmes et n’est
pas une simple substitution.

Exemple :

typedef int vecteur [10] ;

Les déclarations suivantes sont équivalentes :
int v[10], w[10] ; vecteur v, w ;
Exercice : Imaginer des exemples de manipulations de typedef.

Dr Ibrahima GAYE 16 UADB

SRT - Licence2

4.6 Les constantes

Une constante est un emplacement mémoire utilisé par un programme. Contrairement à une va-
riable, la valeur stockée dans une constante ne peut pas changer pendant l’exécution du programme.
Le langage C possède deux types de constante : les constantes littérales et les constantes symbo-
liques.

4.6.1 Constantes littérales

Une constante littérale est une valeur qui est introduite directement dans le code source.
Exemple : int nombre =10 ;
float taux =0.05 ;
10 et 0.05 sont des constantes littérales.

– Une constante avec virgule flottante est considérée par le compilateur C comme un nombre
double précision. Elle peut être représentée avec une notation décimale standard : 12.016, 20,
253.23
Une constante avec virgule flottante peut également être représentée en notation scientifique (ou
exponentielle)
2.31 E 2 (= 2.31*102 = 123)
8.04 e 6 (= 8.04*106 = 8040000)
0.53 e -4 (= 0.59*102 − 4 = 59 ∗ 106 = 0.000059)
26 e 13 (= 26*1013 )
– Une constante entière peut également se représenter sous trois formes :

– décimale (système numérique standard en base 10) : 658 , +254 , -723

– octale (système numérique à base 8) : la constante commence par le chiffre 0 ; elle peut contenir
les chiffres 0 à 7 accompagnés ou non de signe + ou -.
– hexadécimale (base 16 : 0 à 9 et A à F pour exprimer les constantes hexadécimales) : la
constante commence par 0x ou 0X

4.6.2 Constantes symboliques

Le langage C offre deux possibilités de représentations des constantes symboliques.

– l’ordre (directive) ] define
– le mot-clé const

Dr Ibrahima GAYE 17 UADB

SRT - Licence2

Exemples : (1)

] define nom_constante litterale (1)

La constante symbolique est représentée par son nom (symbole) nom_constante et par sa valeur
litterale qui est une constante littérale.
L’instruction (1) crée (définit) une constante appelée nom_constante de valeur litterale . ] define
PI 3.14159

Convention : on écrira les noms des constantes symboliques en lettres majuscules et les noms des
variables en lettres minuscules.
L’instruction ]define X Y ne se termine pas par un point virgule ( ;).

Remarque

L’instruction ] define peut se trouver n’importe où dans le code, mais son effet reste limité à la
partie du code qui la suit.
(2)
const int nombre =20 ;
const float pi=3.14159 ;
const long compte =21 000 000 , float taux =.05 ;
nombre, pi, compte et taux sont des constantes symboliques. Si le programme essaie de modifier
une variable, alors le compilateur génère un message d’erreurs.

Remarque

Les différences entre ces deux constantes symboliques (]define et const) concernent les pointeurs
et la portée des variables.

5 Les Instructions

Une instruction représente une tâche à accomplir par l’ordinateur. Elle s’écrit sur une ligne et se
termine par un point-virgule (à l’exception de #define et #include).
Exemples :
Affectation :
x = 2 + 3; (1)

Affichage :

Dr Ibrahima GAYE 18 UADB

SRT - Licence2

printf(" Apprentissage") ;

Saisie

scanf("%d", &a) ;

(1) équivaut à :

x=
2
+
3;

Cela signifie que le programme a une grande liberté pour la mise en page de son code.
Exception : pour une chaîne de caractère car le blanc est un caractère. Ainsi, l’instruction suivante
est correcte mais déconseillé :

printf(
"Bonjour, monsieur !"
);

Par contre l’instruction suivante est incorrecte :

printf("Bonjour,
monsieur !") ;

Pour continuer la chaîne de caractères sur la ligne suivante, on utilise l’antislash (\).

printf("Bonjour,\
monsieur !") ;

En plaçant un point-virgule seul sur une ligne, on crée une instruction nulle
Un bloc (ou instructions composées) est un groupe d’instructions entre accolades :

{ printf("Bonjour,") ;
printf("monsieur !") ; }

6 Les Expressions

définition
En langage C, on appelle expression tout ce qui représente une valeur numérique.

Dr Ibrahima GAYE 19 UADB

SRT - Licence2

On distingue des expressions simples et des expressions complexes

L’expression la plus simple peut être constituée d’une seule variable, d’une constante littérale ou
d’une constante symbolique.
Exemples
Expression Description
PI Constante symbolique
20 Constante littérale
taux variable
−2.51 Constante littérale
Les expression complexes sont constituées de plusieurs expressions simples avec des opérateurs.
Exemples

1. 7 + 12 ; /* 7 et 12 sont 2 sous-expressions et + l’opérateur d’addition*/

2. −2.51/16 + 5 ∗ taux ∗ taux/nombre est expression avec plusieurs opérateurs. Son évaluation
dépend de l’ordre dans lequel les opérations sont effectuées et des priorités des opérateurs.

Remarque : Une instruction d’affectation est elle-même une expression. Ainsi, on peut écrire :

y = x = a + b;

ou
x = 6 + (y = 4 + 5);

7 Les Opérateurs

définition
Un opérateur est un symbole qui décrit une opération ou une action à effectuer sur une ou plusieurs
opérandes.
Remarque : En langage C, les opérandes sont toujours des expressions.
Les opérateurs seront toujours classées en quatre catégories :

1. l’opérateur d’affectation ;

2. les opérateurs mathématiques ;

3. les opérateurs relationnels (ou de comparaison) ;

4. les opérateurs logiques.

Dr Ibrahima GAYE 20 UADB

SRT - Licence2

7.1 L’opérateur d’affectation

C’est le signe égal (=).

variable = expression;

7.2 Les opérateurs mathématiques

définition
Les opérateurs mathématiques de C réalisent des opérations mathématiques comme l’addition ou
la soustraction. On en distingue deux qui unaires et cinq binaires.

7.2.1 Les opérateurs unaires

Ils opèrent sur une seule valeur ou opérande.

Tableau : opérateurs mathématiques unaires

Opérateurs Symboles Opérations Exemples

Incrémentation ++ augmente de 1 la valeur de l’opérande ++x , x++

Décrémentation −− diminue de 1 la valeur de l’opérande −−x , x−−

Remarque : Ces deux opérateurs ne peuvent être utilisées qu’avec des variables.
Les instructions
+ + x;

− − y;

sont respectivement équivalentes aux instructions suivantes :

x = x + 1;

y = y − 1;

L’opérateur peut être placé en avant (mode préfix) ou après (mode postfix) l’opérande :

– En mode préfix, l’incrémentation ou la décrémentation sont effectuées avant l’utilisation de

l’opérande.

Dr Ibrahima GAYE 21 UADB

SRT - Licence2

– En mode postfix, les opérateurs d’incrémentation et de décrémentation modifient l’opérande

après son utilisation
Illustration :

1.
x = 90;

y = x + +;

Après ces 2 instructions, x a la valeur 91 et y la valeur 90

2.
x = 90;

y = + + x;

Après ces 2 instructions, x a la valeur 91 et y la valeur 91

Exemple :Démonstrations des modes préfix et postfix.

#include<stdio.h>
main()
{int x, y, a, b ;
a=b=5 ;
x=++a ;
y=b + + ;
printf("\n x vaut %d , y vaut %d et a vaut %d et b vaut %d ", x, y,a, b) ;
a=b=5 ;
x=−−a ;
y=b−− ;
printf("\n x vaut %d , y vaut %d et a vaut %d et b vaut %d ", x, y,a,b) ;
}

Exécution :
x vaut 6 , y vaut 5 et a vaut 6 et b vaut 6
x vaut 4 , y vaut 5 et a vaut 4 et b vaut 4

Exercice : Réaliser un programme C qui met en exergue les 2 opérateurs unaires sous leurs différents
modes.

Dr Ibrahima GAYE 22 UADB

SRT - Licence2

7.2.2 Les opérateurs binaires

Ils travaillent avec deux opérandes.

Tableau : opérateurs mathématiques binaires

Opérateurs Symboles Opérations Exples

Addition + additionne 2 opérandes x+y

Soustraction − soustrait la valeur du 2nd opérande à celle du 1er x−y
Multiplication ∗ multiplie 2 opérandes x∗y
Division / divise le 1er opérande par le 2nd x/y
er nd
Modulo % donne le reste de la division du 1 opérande par le 2 x%y
#include<stdio.h>
#define SEC MIN 60
#define SEC HEU 3600
long secondes, minutes, heures, sec rest, min rest ;
main()
{
printf("\n Entrer le nombre de secondes") ;
scanf("%ld", &secondes) ;
heures=secondes/SEC HEU ;
minutes=secondes/SEC MIN ;
min rest = minutes % SEC MIN ;
sec rest = secondes % SEC MIN ;
printf(" \n %ld secondes représentent", secondes) ;
printf(" %ld h %ld min %ld sec \n",heures, min rest, sec rest) ;
}

Exercice :

1. Réaliser un programme qui calcule le PGCD de 2 nombres entiers.

2. Réaliser un programme qui affiche les diviseurs premiers d’un nombre entier donné.

Remarque : A l’exception de l’opérateur % qui ne porter que sur des entiers, ces opérateurs peuvent
s’appliquer à tous les types numériques.

Dr Ibrahima GAYE 23 UADB

SRT - Licence2

7.2.3 Priorités (hierarchie) relatives et parenthésage

Lorsque plusieurs opérateurs apparaissent dans une même expression, il est important de savoir
dans quel ordre les opérations seront effectuées.
Remarque : En langage C, comme dans les autres langages, les règles sont souvent celles de l’Al-
gèbre traditionnelle pour ce qui concerne les opérateurs arithmétiques classiques.
Question naïve : Quel le résultat de y = 6 + 7 ∗ 5 ?

Tableau : Hierarchie des opérateurs mathématiques.

Opérateurs Niveau de Priorité par ordre décroissant

++, −− 1
∗, / , % 2
+, − 3
– Si une expression contient plusieurs opérateurs de même niveau, les calculs s’effectuent de gauche
à droite.
Exemple :
x = 12%5 ∗ 2;
La valeur de x est 4.
– Pour outrepasser ces règles de priorité, il faut utiliser les parenthèses.
Exemple :
x = (4 + 5) ∗ 3;
La valeur de x est 27.
Une expression peut contenir des parenthèses multiples ou imbriquées ; l’évaluation se fait de
l’“intérieur” vers l’“extérieur”.
Ainsi, l’expression suivante x se calcule dans l’ordre suivant .

Expression : x = 25 − (2 ∗ (10 + (8/2)));

1. 25 − (2 ∗ (10 + 4))

2. 25 − (2 ∗ 14)

3. 25 − 28)

Et enfin x vaut −3.

Question :
a + b ∗ c ⇐⇒ a + (b ∗ c)?

a ∗ b + c ⇐⇒ a + (b ∗ c)?

Dr Ibrahima GAYE 24 UADB

SRT - Licence2

7.2.4 Ordre de traitement des sous-expressions

Une expression qui contient plusieurs opérateurs de même niveau de priorité est de gauche à droite.
Par exemple, dans l’expression
w ∗ x/y ∗ z

w est multiplié par x, le résultat de la multiplication est divisé par y et le résultat de la division
est multiplié par z.
Si l’expression contient plusieurs opérateurs de priorités différentes, l’ordre de traitement de gauche
à droite n’est plus garanti.
Exemple :
w ∗ x/y + z/y (2)

La multiplication et la division doivent être traitées avant l’addition. Les règles du langage ne
permettent pas de savoir si w ∗ x/y doit être calculé avant ou après z/y.
Si on transforme l’expression (2), le résultat sera différent selon l’ordre dans lequel seront évaluées
les sous expressions : w ∗ x/ + +y + z/y
ATTENTION : Il faut éviter ce genre d’expression indéterminée. Pour cela, utilisez les paren-
thèses pour que l’ordre ne soit pas ambigu.

7.3 Les opérateurs relationnels (ou de comparaison)

Ils sont utilisés pour comparer des expressions. Le résultat de la comparaison vaut 1 si l’expression
est vrai ou 0 sinon.

Tableau : Les opérateurs de comparaison.

Opérateurs signification Exemples

< inférieur à x<y
<= inférieur ou égal à x <= y
> supérieur à x>y
>= supérieur ou égal à x >= y
== égal à x == y
6= différent x! = y

Remarque :
Les opérateurs de comparaison sont principalement utilisés avec les instructions if et while.

Dr Ibrahima GAYE 25 UADB

SRT - Licence2

Exemple d’utilisation de if :

#include<stdio.h>
main()
{int x, y ;
printf(" \n Entrer la valeur de x :") ;
scanf("%d", &x) ;
printf(" \n Entrer la valeur de y :") ;
scanf("%d", &y) ;
if (x==y)

printf(" x est égal à y \n") ;

if (x>y)

printf(" x est plus grand que y \n") ;

if (x<y)

printf(" x est plus petit que y \n") ;

return 0 ;
}

Exemple d’utilisation de if et else :

#include<stdio.h>
main()
{int x, y ;
printf(" \n Entrer la valeur de x :") ;
scanf("%d", &x) ;
printf(" \n Entrer la valeur de y :") ;
scanf("%d", &y) ;

Dr Ibrahima GAYE 26 UADB

SRT - Licence2

if (x==y)

printf(" x est égal à y \n") ;

else

if (x>y)

printf(" x est plus grand que y \n") ;

else

printf(" x est plus petit que y \n") ;

return 0 ;
}

ATTENTION : L’erreur la plus courante avec les opérateurs de comparaison est d’utiliser l’opé-
rateur d’affectation (=) en lieu et place de l’opérateur (==).
Exemple :

x = 5;
if (x = 5)
printf(“x est égal à 5”) ;

Le message apparaîtra dans tous les cas, l’expression sera évaluée toujours comme vrai quelque
soit la valeur de x.
Les opérateurs de comparaison ont tous une priorité de traitement inférieure à celle des opérateurs
mathématiques. Ainsi si on écrit
if (x + 2 > y) (3)

alors 2 est ajouté à la valeur de x et le résultat est comparé à y.

(3) ⇐⇒ if ((x + 2) > y)

Tableau : Hierarchie des opérateurs de comparaison.

Dr Ibrahima GAYE 27 UADB

SRT - Licence2

Opérateurs Ordre de priorité

<, <=, >, >= 1
! =, == 2
Ainsi l’expression
a < b == c < d

est interprétée comme

(a < b) == (c < d)

7.4 Les opérateurs logiques

C dispose de trois opérateurs logiques classiques

Opérateurs Signification
&& et (conjonction)
|| ou (inclusif)
! non (négation)

L’opérateur ! a la même priorité que les opérateurs mathématiques unaires ++ et −−.

Par contre, les opérateurs && et || seront traités après tous les autres opérateurs mathématiques
et de comparaison. L’opérateur && a une priorité supérieure à celle de ||.
L’expression
(a < b)&&(c < d)

prends la valeur 1 (vraie) si les 2 expressions a < b et c < d sont toutes deux vraies (de valeur 1),
la valeur 0 (faux) dans le cas contraire.

(a < b)||(c < d)

vaut la valeur 1 (vraie) si l’une au moins des deux 2 conditions a < b et c < d est vraie (valeur 1)
, 0 (faux) dans le cas contraire.

!(a < b)

prends la valeur 1 si la condition a < b est fausse et la valeur 0 sinon. Elle est équivalente à :
a >= b.
Remarque : Comme C ne possède pas de type logique, alors les opérateurs logiques produisent un
résultat de type int. Ainsi le compilateur accepte les expressions suivantes :

Dr Ibrahima GAYE 28 UADB

SRT - Licence2

n&&p, n||p, !n

où n et p sont des entiers.

Exercice : Comparer if (!n) et if (n == 0)
Exemples

1. !a == b sera interprétée comme (!a) == b

2. a < b&&c < d ⇐⇒ (a < b)&&(c < d)

3. a < b||c < d ⇐⇒ (a < b)||(c < d)

4. a < b||a < c&&c < d ⇐⇒ a < b||(a < c&&c < d)

Exemple :

Hierarchie des opérateurs logiques

#include<stdio.h>
int a=5, b=6, c=5 , d=1, x ;
main()
{
x=a<b || a<c && c<d ;
printf(" \n L’expression sans parenthèse vaut %d",x) ;
x=(a<b || a<c) && c<d ;
printf(" \n L’expression avec les parenthèses vaut %d",x) ;
}

7.5 Les opérateurs d’affectation composés

Ils permettent d’associer une opération mathématique binaire avec une opération d’affectation.

x+ = 5; ⇐⇒ x = x + 5;

syntaxe générale :
exp1 op = exp2 (4)

où représente un opérateur binaire.

4 ⇐⇒ exp1 = exp1 op exp2

Dr Ibrahima GAYE 29 UADB

SRT - Licence2

7.5.1 L’opérateur de condition

C’est le seul opérateur ternaire c’est-à-dire qu’il prend 3 opérandes.

syntaxe générale :
exp1 ? exp2 : exp3; (5)

1. x = y ? 1 : 100; signifie que x prend la valeur 1 si y est vraie (= 1), sinon x prend la valeur
100.

2. z = (x > y) ? x : y; qui équivaut à

if (x > y)
z = x;
else
z = y;

3. printf("la plus grande valeur est %d", z = (x > y) ? x : y) ;

5 signifie que si exp1 est vraie (6= 0), alors l’expression complète prendra la valeur de exp2, sinon
l’expression complète prendra la valeur de exp3

Application : valeur absolue d’un nombre.

7.6 Les opérateurs de manipulation de bits

Ces opérateurs portent exclusivement sur des types entiers (y compris les caractères qui sont aussi
des entiers de tailles petites).
On en distingue cinq (5) qui sont (opérateurs) binaires et un qui unaire. Ils permettent de travailler
directement sur le motif binaire.

Tableau : Les opérateurs de type binaire.

Opérateurs Signification
& et (bit à bit)
| ou inclusif (bit à bit)
∧ ou exclusif
 décalage à gauche
 décalage à droite

L’opérateur unaire est le suivant ∼ il permet le complément à un.

Exemples

Dr Ibrahima GAYE 30 UADB

SRT - Licence2

opérande X 0 0 1 1
opérande Y 0 1 0 1
1. X&Y 0 0 0 1
X|Y 0 1 1 1
X ∧Y 0 1 1 0
L’opérateur unaire ∼ inverse chacun des bits de son unique opérande (0 donne 1 et 1 donne
0).
∼
X = 1 1 0 0
∼
Y = 1 0 1 0
Remarque : Le qualificatif de “signed/unsigned” des opérandes n’a pas d’incidence sur le
motif binaire crée par ces opérateurs.

2. n  2 (resp n  2) fournit comme résultat la valeur obtenue en décalant le “motif binaire”

de n de 2 bits vers la gauche (resp. la droite) ; les bits de gauche (de poids forts) (resp. de
droite) sont perdus tandis que des bits à zéro apparaissent à droite (resp. à gauche).
Si le premier opérande (n) est de type unsigned, alors les bits ainsi créés à gauche seront à
zéro.. S’il s’agit de signed, les bits ainsi créés seront identiques au bit de signe du premier
opérande ; il y a propagation du signe.
Soit n de type signed int et q de type unsigned int.

n 1 0 1 0 1 1 0 1 1 1 0 1 1 1 1 0
q 1 0 1 0 1 1 0 1 1 1 0 1 1 1 1 0
n2 1 0 1 1 0 1 1 1 0 1 1 1 1 0 0 0
n3 1 1 1 1 0 1 0 1 1 0 1 1 1 0 1 1
q3 0 0 0 1 0 1 0 1 1 0 1 1 1 0 1 1

syntaxe
Xn

Xn

Chacun de ces opérateurs décalent les bits de la variable X de n positions dans la direction cor-
respondante.
Intérêt : Ces opérateurs permettent dans certains cas de multiplier ou de diviser une ariable entière
par une puissance de 2. En décalant un entier de n positions vers la gauche, on obtient une multi-
plication par 2n à condition de ne “perdre” bit significatif dans cette opération. Ce même décalage
vers la droite permet d’obtenir une division entière par 2n puisqu’on perd la fraction décimale du
résultat.

Dr Ibrahima GAYE 31 UADB

SRT - Licence2

Les opérateurs de décalage :

#include<stdio.h>
main()
{
unsigned int y, x = 255 ;
int compte ;
printf("Valeur Décimale \t Décalage à gauche \t Résultats \n") ;
for (compte = 1 ; compte < 8 ; compte++)
{
y = x « compte ;
printf("%d\t\t\t\t %d\t\t %d\n", x, compte, y) ;
}
printf("Valeur Décimale \t Décalage à droite \t Résultats \n") ;
for (compte = 1 ; compte < 8 ; compte++)
{
y = x » compte ;
printf("%d\t\t\t\t %d\t\t %d\n", x, compte, y) ;
}

return 0 ;
}

7.7 L’opérateur séquentiel : la virgule

Il permet de réaliser plusieurs calculs successifs au sein d’un même expression.

Exemple :
x = (a + +, a + b);

L’instruction précédente incrémente a, puis attribue la valeur de a + b à x.

Avec la virgule, on peut former une expression à partir de deux sous-expressions et dont le résultat
est le suivant :

1. Les 2 sous-expressions sont évaluées en commençant par celle de gauche

2. L’expression enrière prend la valeur de l’expression de droite.

Dr Ibrahima GAYE 32 UADB

SRT - Licence2

Remarque : L’usage des parenthèses est obligatoire.

Exemples d’utilisation

1. if (i + +, k > 0) pour remplacer i + +; if(k > 0)

2. for (i = 1, k = 0; · · · ; · · · ) remplace i = 1; for (k = 0; · · · ; · · · )

3. for (i = 1, k = 0; printf (“ on commence 00 ); · · · ; · · · )

Remarque : Ne pas confondre l’opérateur séquentiel avec la virgule utilisée (même priorité) comme
séparateur dans une liste d’arguments.
Exemple :

printf(“%d %d”, a, (b = 5, 3 ∗ b)) ;

imprime la valeur de a, évalue l’expression b = 5, 3 ∗ b, ce qui conduit à affecter 5 à b et calcule

ensuite la valeur de 3 ∗ b, et enfin affiche la valeur de 3 ∗ b.
Remarque Générale
La notion d’expression telle qu’utilisée en langage C est beaucoup plus générale que dans la pluart
des autres langages.

Exercice : Faire un programme qui demande deux nombres au clavier et qui affiche ?divisible ? si
le premier est divisible par le deuxième.
Exemple :
#include <stdio.h>
main ()
{
char operation ;
int r, a, b ;
printf("Entrez un signe d’opération : ") ;
scanf("%c", &operation) ;
a=273 ; b=158 ; r=0 ;
if (operation==’+’ || operation==’p’)
r = a + b;
else if (operation==’-’ || operation==’m’)
r = a - b;
else if (operation==’*’ || operation==’f’)
r = a * b;

Dr Ibrahima GAYE 33 UADB

SRT - Licence2

else if (operation==’/’ || operation==’d’)

r = a / b;
else
printf("Non valable : ") ;
printf("%d %c %d = %d\n", a, operation, b, r) ;
}

Dr Ibrahima GAYE 34 UADB