Techniques de

Programmation
Pr. : Mohamed El KAMILI
Contact : [Link]@[Link]
Cycle : Ingénieur
Département : GE
Année : 2018/2019

Techniques de Programmation 1/102

Plan

 Généralités
 Programmation informatique
 Algorithmique
 Programmation en langage C
Introduction
Notion de variable en C
Mots-clés du langage C
Structures de contrôle
Les tableaux
Variables composites
Les fonctions
La récursivité
Les fichiers
Techniques de Programmation 2/102
Programmation en C
Historique
 L’histoire du C est très liée à l'histoire du système UNIX.

 En 1969, la 1ère version du système UNIX voit le jour

programmée en assembleur.
 Ken Thompson créa un nouveau langage de programmation,
nommé B.
 En 1971, création du successeur de B, nommé C, créé par
Dennis Ritchie.

 En 1983, un standard pour le langage C est créé :

 la norme ANSI (American National Standards Institute).

 La plupart des compilateurs (Borland, Microsoft, GNU CC,
GCC, …) utilisent ce standard.
 un programme écrit en ANSI C est compilable presque
partout.

Techniques de Programmation 3/102

Programmation en C
Caractéristiques du langage C
 Langage structuré;

 Langage modulaire : Peut être découpé en modules qui

peuvent être compilés séparément;

 Langage universel : Permet de développer tout type

d’applications ; OS, jeux, …;

 Langage typé : Tout objet C doit être préalablement déclaré

avant d’être utilisé;

 Langage puissant et efficace;

 Langage portable : Sur n'importe quel système en possession

d'un compilateur C.

Techniques de Programmation 4/102

Programmation en C
Caractéristiques du langage C

 Le langage C est un langage compilé;

 Les compilateurs assurent les opérations suivantes:

 Analyse lexicale;
 Pré-traitement (préprocesseur);
 Analyse syntaxique (parsing);
 Analyse sémantique; et
 Génération de code optimisé en langage bas niveau.

Techniques de Programmation 5/102

Programmation en C
Caractéristiques du langage C

Fichier Compilateur C
Source C

Code
Assembleur

Assembleur

Code Objet
Code Linker
exécutable

Techniques de Programmation 6/102

Programmation en C
Anatomie d’un programme C

Programme typique en C

include
Main() toujours la
1ère fonction appelée
main()

fonction a() instructions

fonction b() instructions

instructions

Techniques de Programmation 7/102

Programmation en C
Programme typique en C
/* exemple de programme C :
-somme des nb de 1 à 10 et affichage de la valeur*/
En C le programme principal 1
#include <stdio.h> 0 s'appelle toujours main
int main (void) 1
{ déclarations de variables de
type entier (cases mémoire 2
int somme; int i; 2 pouvant contenir un entier)
somme = 0; 3
instruction d'affectation de
valeur à la variable somme 3
for (i = 1; i <= 10; i++)
4 { l'instruction entre accolades
somme = somme + i; est exécutée pour les valeurs 4
de i allant de 1 à 10
}
printf ("%d\n", somme); 5 affiche à l'écran la valeur de 5
somme = 0; l'entier contenu dans somme
}

Techniques de Programmation 8/102

Programmation en C
Instruction en langage C
 Les actions ou "instructions" en langage C ne sont en fait que
des opérations élémentaires (+,-, * etc…) sur des données
unitaires (variables).
 Chaque instruction est suivie d'un ;
 Le début d'un bloc est signalé par un { , la fin d'un bloc par }.
Un bloc devient l'équivalent syntaxique d'une instruction.

Exemple: {
x=1 Obligatoire
x=1;
y=2
Calcul
y=2;
z = x+y z=x+y;
imprimer z printf("%d",z);
};
optionnel
Techniques de Programmation 9/102
Programmation en C
Type d’instructions en langage C

 Déclarations des variables

 Affectations

 Opérations

 Fonctions

 Contrôle

Techniques de Programmation 10/102

Programmation en C
La notion de variable en C
Nom d’une variable

La norme ANSI C est assez souple pour ce qui concerne le

nommage des variables, mais aussi assez stricte sur certains
points : Un nom de variable :

Peut contenir des lettres de A à Z, et de a à z, ainsi que les

dix chiffres de 0 à 9, et le caractère underscore ('_');
Ne doit pas commencer par un chiffre;

Le langage C est sensible à la casse.

Techniques de Programmation 11/102

Programmation en C
La notion de variable en C
Type d’une variable

Toutes les variables doivent être explicitement typées (pas

de déclaration implicite comme en fortran)

Il y a globalement trois (quatre ?) types de variables :

int,
Les entiers : short int, long int
Les réels : float, double, long double
Les caractères : char
Rien … : void
Exemples : short int ma_note;
double cheese;
char avoile;

Techniques de Programmation 12/102

Programmation en C
La notion de variable en C
Déclaration d’une variable

Déclarer une variable est une opération extrêmement

simple, qui nécessite deux choses :

 Le type de de variable que l'on souhaite créer,

 et le nom que l'on souhaite lui donner.

Le type de variable que l'on souhaite créer dépend, bien

évidemment, de nos besoins, et nous le choisirons parmi les
types disponible ou encore crées.

Exemple : int a;
float note;

Techniques de Programmation 13/102

Programmation en C
La notion de variable en C
Initialisation d’une variable

On appelle "initialisation" d'une variable le fait de lui

donner une valeur pour la première fois;
Pour donner une valeur à une variable (on dit "affecter"
une valeur à une variable), on utilise l'opérateur
d'affectation, '=' (Le symbole égal);
Cet opérateur affecte à la variable placée à sa gauche le
résultat de l'expression placée à sa droite.

En C, on peut initialiser une variable à sa déclaration !

Exemples :
short int age=21;
int x=-3, b=15;

Techniques de Programmation 14/102

Programmation en C
La notion de variable en C
Portée ou visibilité d’une variable

Variable globale : Une variable déclarée au début du code, c'est-à-dire

avant tout bloc de donnée, sera globale, on pourra alors l'utiliser à partir
de n'importe quel bloc d'instruction.

Variable locale : Une variable déclarée à l'intérieur d'un bloc

d'instructions (dans une fonction ou une boucle par exemple) aura une
portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est
inutilisable ailleurs. On parle alors de variable locale.

Techniques de Programmation 15/102

Programmation en C
La notion de variable en C
Le type Caractère

Caractère : Symboles alphanumériques (a,z,0,1,9) + caractères

spéciaux (retour à la ligne, beep, etc..)
Un caractère est représenté sur un octet (8 bits) suivant la
table ASCII (American Standard Code for Information
Interchange)
Exemple : 'a' = 9710 = 6116 = 0110 00012 =141
Table ASCII
ex : code ASCII du 'A' = 65
'A'<'B'<……..< 'Z'
'0'<'1'<'2'<…..<'9'
'a'<'b'<……….<'z'
Techniques de Programmation 16/102
Programmation en C
La notion de variable en C
Le type Caractère : Table ASCII

Techniques de Programmation 17/102

Programmation en C
La notion de variable en C
Le type Caractère : Table ASCII

A retenir :

les chiffres sont codés suivant un ordre croissant (48 à 57)

idem pour les lettres (65 à 90, 97 à 122)

code des majuscules est inférieur au code des minuscules

(différence constante = 32)

les codes supérieurs à 128 dépendent de la langue :

é, ö , ä, æ, œ etc…

Techniques de Programmation 18/102

Programmation en C
La notion de variable en C
Le type Entier

C’est une variable codée sur 2 ou 4 octets suivant le calculateur

n 1
x   xi 2i , xi  0,1, n  16 ou 32
i 0
 Sur deux octets on peut coder les nombres de 0 à 216-1 (0 à 65535)

Représentation en base 2: les bits sont rangés dans des cellules

correspondant à leur poids, on complète à gauche par des 0

Exemple : 13 = 8 + 4 +1 = 1*23+1*22+0*21+1*20
=0000000000001101
Déclaration d'une variable entier naturel x
unsigned int x;
short unsigned int x; (on force sur 16 bits)
long unsigned int x; (on force sur 32 bits)
Techniques de Programmation 19/102
Programmation en C
La notion de variable en C
Le type Entier relatif

La première idée est de marquer le signe du nombre de façon simple : le

signe puis la représentation de sa valeur absolue. Ainsi :

00000110 = +6 en décimal
Et
10000110 = −6 en décimal

Malheureusement cette représentation possède deux inconvénients:

Le premier (mineur) est que le nombre zéro (0) possède deux
représentations: 00000000 et 10000000, respectivement égales à 0 et −0.
L'autre inconvénient (majeur) est que cette représentation impose de
modifier l'algorithme d'addition ; si un des nombres est négatif, l'addition
binaire usuelle donne un résultat incorrect.
Exemple : 00000011 + 10000100 = 10000111
Soit 3 + (−4) = (−7) au lieu de (−1)
Techniques de Programmation 20/102
Programmation en C
La notion de variable en C
Le type Entier relatif : Complément à 2

Implantation sur 2 ou 4 octets suivant le compilateur

Représentation sur n bits : codage complément à 2
n2
x   xn 1 2 n 1   xi 2i , xi  0,1
i 0
Déclarations
int a,b;
….
a = 1;
….
b= -3;
Techniques de Programmation 21/102
Programmation en C
La notion de variable en C
Le type Entier relatif : Complément à 2

Si xn-1 = 0 : nombre positif,

xn-1 = 1 : nombre négatif

Exemple sur 16 bits

+5 = 1 * 22 + 0 * 21 + 1 * 20 = 0000 0000 0000 0101

-3 = -215+ 214 + 213 + 212 + 211 + 210 + 29 + 28 + 27 + 26 + 25 + 24

+ 23 + 1.22 + 0. 21 + 1.20
= 1111 1111 1111 1101
-3 = -27 + 26 + 25 + 24 + 23 + 1.22 + 0. 21 + 1.20

Techniques de Programmation 22/102

Programmation en C
La notion de variable en C
Le type Entier relatif : Complément à 2

Représentation non symétrique : le plus petit nombre n’a

pas d’opposé : sur n bits
le plus grand entier positif est 2n-1-1
le plus petit entier négatif est -2n-1
000
111 001
0
-1 1
Exemple sur 3 bits :
110 -2 2 010

-3 3
101 -4 011
100
Techniques de Programmation 23/102
Programmation en C
La notion de variable en C
Le type réel

Déclaration
float x,y;
x = 3.14;
y = 2.0 e+3;

Implantation sur 4 octets

Représentation suivant le compilateur
En général mantisse exposant (norme IEEE)
L’ensemble de valeurs : 10-38 < x < 1038
Extension :
double x; x est codé sur 8 octets

Techniques de Programmation 24/102

Programmation en C
La notion de variable en C
Le type réel : Représentation (virgule flottante selon la norme IEEE)

M : Mantisse ; calage = 2 -1 , k nombre de bits attribué à

l’exposant
Représentation IEEE 754 (signe 1 bit, mantisse et exposant : le
tout sur 32 ou 64 bits pour simple et double précision)
SM : signe de la mantisse : 1 bit
Eb : exposant biaisé (décalage) : 8 ou 11 bits (E=Eb+calage)
M : Mantisse : 23 ou 52 bits SM E M

Techniques de Programmation 25/102

Programmation en C
La notion de variable en C
Le type réel : Représentation

Signe : bit de poids fort (0 = + ; 1 = -)

Exposant
placé avant la mantisse pour simplifier les comparaisons (pour
ceci il ne doit pas être représenté en complément à deux : -1 > 2)
sur 8 bits : 0…256
sans signe mais décalé de 127 (simple précision) :
Eb = 1 ⇒ E = 1 + 127 = 128
Eb = -3 ⇒ E = -3 + 127 = 124
les exposants 255 (erreur) et 0 (nb dénormalisé) sont interdits
Mantisse
Normalisée : bit de poids fort n’est pas 0 et un seul chiffre avant
la virgule

Exemple : 11,012 = 1,101 * 21

Techniques de Programmation 26/102

Programmation en C
La notion de variable en C
Résumé sur les types

Caractère : 1 octet
Ex : 'a' = 6116 0 1 1 0 0 0 0 1

Entier relatif : 2 ou 4 octet, représentation complément à 2

Ex 1 : +5 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1

Ex 2 : -5 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1

x : indique le signe
Réel : 4 octets, représentation virgule flottante
Ex : -6,5 = -110,12 = -1,101 * 22 2+127 = 129 = 27 +20

1 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 … 0 0 0

Techniques de Programmation 27/102

Programmation en C
La notion de variable en C
Complément de type : static

Static : une telle variable maintient sa valeur à travers les appels de

la fonction

void inc( ) void inc( )

{ {
int i=0; static int i=0;
i++; //i=i+1; i++;
printf ("%d", i); printf ("%d", i);
} }

1, 1, 1, 1, … 1, 2, 3, 4, …
/* i est initialisée à chaque appel de /* i est initialisée à 0 à la
la fonction inc() */ compilation seulement */
Techniques de Programmation 28/102
Programmation en C
La notion de variable en C
Complément de type : register

Register

Une déclaration "registre" indique au compilateur qu'une variable

sera utilisée fréquemment.

Si c'est possible, le compilateur utilisera un registre pour implanter

la variable plutôt qu'un emplacement mémoire (vitesse d'exécution)

register int i;

Techniques de Programmation 29/102

Programmation en C
La notion de variable en C
Conversion de type : Le casting

Conversion explicite : ( type ) expression

Exemple :
int a; float x; char c;
a=2;
x=a;
x=2.3;
a= (int) (x+1);
a = 98;
c = (char) a; => c='b'
Conversion implicite : Conversion du type le plus faible vers le type le plus
fort : char < short ≤ int ≤ long < float < double
Exemple :
int a; float x; char c;
a=2; x= a;
x=2.3;
a= x+1;
a = 98;
c = a; => c='b'

Techniques de Programmation 30/102

Programmation en C
La notion de variable en C
Conversion de type : Le casting

Exemples :
char c; int i; float f;
// conversion entier vers char
c=98; // implicite : c prend le code ASCII 98 c-à-d 'b'
c = (char) 98; // explicite plus propre
// char vers entier
i= 'a' ; // i prend la valeur 97
i= (int) 'a' ; //plus propre
// entier vers réel
f=3; // f prend la valeur 3.0;
f=(float) 3; //+ propre
//réel vers entier, attention : troncature
i = 3.4; // i prend la valeur 3
i= -3.3; // i prend la valeur -3
i = (int) 3.4; // + propre

Techniques de Programmation 31/102

Programmation en C
La notion de variable en C
Conversion de type : Modifier la casse

Passer au caractère suivant

char c;
c ='a';
c = c+1; // calcul fait en entier puis résultat converti en char
c = (char) ((int) c+1) ; //+ propre

Conversions majuscule  minuscule

char c;
c='t';
// conversion en Majuscule
c=c-32; // c contient 'T'
ou mieux
c=c-('a'-'A');
c=c+1; // c contient 'U'
// conversion en minuscule
c=c+32;
ou c=c+('a'-'A')
// conversion en Majuscule
if ((c >= 'a') && (c <= 'z')) c = c-('a'-'A');
Techniques de Programmation 32/102
Programmation en C
La notion de variable en C
Les constantes

Une constante est une variable dont la valeur ne peut pas changer
durant la durée de vie d’un programme

Directive du préprocesseur
Utilisation du mot clé define qui est placé au début du programme

Instruction de déclaration
Utilisation du mot clé const qui est placé avant ou après le type de la
variable

Techniques de Programmation 33/102

Programmation en C
La notion de variable en C
Les constantes : exemples
#include <stdio.h>
#define CO 10
int c = 5;
void main(){
int a, b;
scanf("%d", &a);
scanf("%d", &b);
printf("La résultat est : %d", (a+b)*c/CO);
}
#include <stdio.h>
int const co = 5;
void main(){
int a, b;
scanf("%d", &a);
scanf("%d", &b);
printf("La résultat est : %d", (a+b)*co);
}
Techniques de Programmation 34/102
Programmation en C
Expression en C
Une expression représente une donnée élémentaire : constante, variable,
un élément de tableau, la référence à une fonction ou à une valeur, le
résultat d'un calcul etc ….

Exemples
3
a+b
x=y
c = a+b
x <= y
x == y
i++
sin(3.14)

Toute expression a une valeur !

Techniques de Programmation 35/102

Programmation en C
Opérateurs arithmétiques
Opérateurs binaires
+,-
* , / , % (modulo)
Les opérandes doivent être des valeurs numériques.
entier opérateur entier => résultat entier
réel opérateur réel => résultat réel
entier opérateur réel => résultat réel

Exemples
int a,b; float a,b;
a=10; b= 3 a=12.6; b= 3.0
a+b 13 a+b 13.6
a-b 7 a-b 9.6
a*b 30 a*b 37.8
a/b 3 (division euclidienne) a/b 4.2 (division réelle)
a%b 1 a%b erreur de syntaxe

Techniques de Programmation 36/102

Programmation en C
Opérateurs arithmétiques
Opérateurs binaires

Opérateur % :
- int a;
- float x;
(a+x) % 4 incorrect.
((int) (a+x))%4 correct

- si l'un des opérandes est négatif, le résultat est négatif.

Si l'un des opérandes est de type caractère, c'est la valeur du code ASCII
qui est prise (conversion implicite char vers int ou float)

Techniques de Programmation 37/102

Programmation en C
Opérateurs arithmétiques
Opérateurs unaires

1. a/ signe : + , -
Exemple : a = -a;

2. incrémentation, décrémentation : ++ (+1) , -- (-1)

Exemple :

int i =1;
++i;
printf("%d",i) ; -> 2;
Syntaxes : ++i ou i++
++i : la valeur de i est d'abord incrémentée, la valeur résultat est
utilisée dans l'expression courante
i++ : la valeur courante de i est utilisée dans l'expression courante,
puis i est incrémenté

Techniques de Programmation 38/102

Programmation en C
Opérateurs arithmétiques
Opérateurs unaires : i++ ou ++i ?

Exemples
i=1; i=1;
printf("i= %d\n",i); => i=1 printf("i= %d\n",i); => i=1
printf("i= %d\n",++i); => i=2 printf("i= %d\n",i++); => i=1
printf("i= %d\n",i); => i=2 printf("i= %d\n",i); => i=2

Conclusions
1. appendre la règle (pour comprendre des programmes)
2. à n'utiliser que lorsque il n'y a pas d'ambiguïté :
x=y+z++; // à éviter
x++; // pas de risque

Techniques de Programmation 39/102

Programmation en C
Affectation en C
Affectation simple
syntaxe : variable = expression
la valeur de l'expression est stockée dans la mémoire à l'endroit
réservé pour la variable

Exemples :
a = 2; b=1; c=0;
a = b+c;
a = b && c;
la valeur de l'expression vaut la valeur affectée

Attention : affectation et test d'égalité

if (a=1) instruction1; else instruction2;
L'instruction1 est toujours déclenchée.

a = b = 3; (évaluation de droite à gauche)

Techniques de Programmation 40/102

Programmation en C
Affectation en C
Affectation complexe
Affectation et opération : +=, -=, *=, /=, %=,<<= , >>=, &=, |=, ^=

Syntaxe : variable opérateur expression

équivalent à : variable = variable opérateur expression

Exemple
int i;
i= 3;
i+=2; (i=i+2;)
printf("%d\n",i);  5

Techniques de Programmation 41/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Deux fonction de base : putchar() et printf()

Fonction putchar()

Syntaxe : putchar (char)

Exemple

char c;
c='a';
putchar ( c );
putchar ('\n'); équivalent à printf("%c\n%c",c, 'b');
putchar('b');

Affichage sur écran

a
b

Techniques de Programmation 42/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction printf()

Syntaxe : printf (" liste des formats ", arg1, arg2, arg3, …, argn)

les arguments sont des valeurs d'expression à imprimer

le format donne le texte mort et le mode de décodage des arguments
le format est une chaîne de caractères !

Exemple
printf("bon"); printf("jour");printf("\n"); bonjour
i=j=1;
printf("i=%d\n",i); i=1
printf("%d%d%d\n",i,j,i+j); 112
printf("%d\t%d\t%d\t%d\n",i,j,i+j,sqrt(i)); 1 1 2 1
x=3.0;
printf("%f\t%d\n",x,i); 3.000000 1
printf("%d\n%d\n",i,i+j); 1
2

Techniques de Programmation 43/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction printf()

La valeur de retour du printf() est le nombre de caractères écrits et une

valeur négative si il y a eu un problème.

Exemple

int a,x;
a=42;
x = printf ("%d\n",a);
printf ("%d\n",x); => 3

Techniques de Programmation 44/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction printf()

Caractères spéciaux de format

%d : imprime les entiers sur le nombre de caractères nécessaires
%f : imprime les réels avec 6 chiffres de partie décimale
%e : imprime les réels en notation exponentielle
%c : imprime un caractère
%s : imprime une chaîne de caractères jusqu'à rencontrer le caractère
de fin de chaine 0 (erreur si absent)
…..

Caractères d’échapement
\n : saut à la ligne %% affichage du caractère '%'
\t : tabulation \a : alerte ; beep système
\p : saut à la page \\ : affichage du caractère '\'
\0 caractère null ; valeur 0, délimiteur de fin de chaîne de caractères
…. 45/102
Techniques de Programmation
Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction printf()

Forçage du nombre de caractères

entiers :
%5d l'entier est imprimé sur 5 caractères au moins (blancs)
avec cadrage à droite
%-5d l'entier est imprimé sur 5 caractères au moins (blancs)
avec cadrage à gauche

réels :
%10f le réel est imprimé sur 10 caractères (en tout) avec 6
chiffres en partie décimale (cadrage à droite)
%-10f idem + cadrage à gauche

limitation de la partie décimale

%20.3f le réel est imprimé sur 20 caractères (en tout) avec 3
chiffres en partie décimale

Techniques de Programmation 46/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction printf()

Format variable

printf("%*d", n, i) : n donne le nombre de caractères pour i

printf("%*.3f", n, x) : n donne le nombre total de caractères pour x

printf("%*.*f", n, m, x) : n donne le nombre de total caractères m donne le

nombre de caractères pour la partie décimale

Techniques de Programmation 47/102

Programmation en C
Fonctions d’entrée/sortie : Entrée standard
Lecture depuis le clavier

2 fonctions de base : getchar () et scanf()

Elles peuvent être appelées soit indépendamment soit au sein

d'expressions

Exemples

getchar();

while (c==getchar()) {
…..
};

Techniques de Programmation 48/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction getchar()
Sert à la lecture de caractères isolés
 la valeur de getchar() est le code ascii du caractère lu
 utilisation
char c;
c = getchar();

Exemple : on veut lire et mémoriser 2 caractères donnés sur 2 lignes

différentes
char c1,c2;
c1 = getchar(); // acquiert le 1er caractère
getchar (); // filtre le <cr>, on ne mémorise pas la valeur lue
c2 = getchar () // acquiert le 2ème caractère

Techniques de Programmation 49/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction scanf()
Sert à la lecture de données et convertit la succession de caractères donnés
en entiers, flottants, caractères, chaîne de caractères

Syntaxe : scanf (format, arg1, arg2, …, argn)

le nombre d'arguments est quelconque

arg1, arg2,……, argn sont les adresses des variables dans lesquelles on
stocke les valeurs lues

variable simple (entier, caractère, flottant) : &v

le format est une chaîne de caractères précisant le type des arguments afin
de convertir la suite de caractères lus dans les arguments

Techniques de Programmation 50/102

Programmation en C
Fonctions d’entrée/sortie : Sortie standard
Fonction scanf()
Format

chaîne de caractères composée de caractères % suivis d'une lettre et

éventuellement séparés par des blancs
la lettre indique le type de conversion à effectuer

Exemple
int i; float x;
scanf("%d %f", &i, &x);

le %d indique que le premier argument est un entier

le %f indique que le second est un réel
réponse : 23 12.6
23 est converti en entier et stocké dans i
12.6 est converti en flottant et stocké dans x
Techniques de Programmation 51/102
Programmation en C
Opérateurs relationnels et logiques
Valeur logique :
0 : faux
!0 : vrai
Exemple : if (3) traitement1 ; else traitement 2;
Equivalent à : traitement1;

Relationnels : >= , > , == , <, <= , !=

La valeur de l'expression est 1 si l'expression est vraie , 0 si elle est fausse
Exemple : 2 < 3 vaut 1 , 2 > 3 vaut 0
Attention à la confusion : test d'égalité == et l'affectation =
ex : if (x=0) traitement 1; // au lieu de x==0
else traitement 2;
Conséquence: non seulement le traitement 1 ne sera jamais exécuté
mais en plus x vaudra 0 quelle que soit sa valeur initiale

Techniques de Programmation 52/102

Programmation en C
Opérateurs relationnels et logiques
Opérateurs logiques :
&& : "et" logique
|| : "ou" logique
! : "non" logique

Dans l'évaluation de l'expression, 0 est considéré comme la valeur

logique "faux", toute autre valeur est considérée comme la valeur
logique "vraie »
La valeur de l'expression est 1 ou 0
Exemples: 2 && 0 vaut 0 et donc est faux
2 || 0 vaut 1 et donc est vrai
!0 vaut 1
!4 vaut 0

Techniques de Programmation 53/102

Programmation en C
Opérateurs bit à bit
Opèrent sur les représentations binaires des valeurs
& et binaire ,
| ou binaire,
^ ou-exclusif binaire,
~ complément à 1 ,
<<k décalage à gauche de k bits,
>>k décalage à droite de k bits,
Attention : & ≠ &&
Exemples
5 0000 0000 0000 0101
20 0000 0000 0001 0100
5 & 20 0000 0000 0000 0100  5 & 20 => 4
5 | 20 0000 0000 0001 0101  5 | 20 => 21
5 ^ 20 0000 0000 0001 0001  5 ^ 20 => 17
~5 1111 1111 1111 1010  -6
Affectation (bit-à-bit) : &=, |=, ^=, ~=
Techniques de Programmation 54/102
Programmation en C
L’opérateur conditionnel ternaire ?... : …
Syntaxe

expression1 ? expression2 : expression3

à peu près équivalent à :

if (expression1) expression2; else expression3;

Exemple

maximum = (x>y) ? x : y;

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

Conseil : ne pas utiliser (peu clair)

Techniques de Programmation 55/102

Programmation en C
L’opérateur d’adressage
Adresse de : &

Syntaxe : &variable //donne l'adresse mémoire de la variable

Exemple
int i, *adr;
adr = &i;
ne pas confondre avec le "et" bit à bit

Dont l'adresse est : *

Syntaxe : *expression // donne le mot mémoire dont l'adresse est

donnée par l'expression
Exemple
int i, *adr;
i=1;
adr = &i;
printf("%d", *adr);  1

Techniques de Programmation 56/102

Programmation en C
L’opérateur de taille
L’opérateur : sizeof

Donne la taille de l'implantation ou de l’expression

2 syntaxes possibles

1. sizeof expression
Exemple
int i,j ;
j= sizeof i;  2 ou 4 (octets)

2. sizeof (type)
Exemples
typedef char tab[100];
tab t;
int n;
n = sizeof(int), -> 2 ou 4 (octets)
n = sizeof(tab) -> 100 (char)

Techniques de Programmation 57/102

Programmation en C
Opérateurs divers

( ) force l'ordre des calculs

ex : 1 + 2 * 3 -> 7
(1+2) * 3 -> 9

[ ] pour les tableaux

t[2] équivalent à *(t+2)

-> et . (opérateurs sur structures, à étudier + tard)

Techniques de Programmation 58/102

Programmation en C
Priorité des opérateurs
Priorité Opérateurs Description Associativité
15 () [ ] -> . opérateurs d'adressage Gauche
++ -- incrément/décrément
~ complément à un (bit à bit)
! non unaire
14 Droite
&* adresse et valeur (pointeurs)
(type) conversion de type (cast)
+- plus/moins unaire (signe)
13 */% opérations arithmétiques Gauche
12 +- "" Gauche
11 << >> décalage bit à bit Gauche
10 < <= > >= opérateur relationnels Gauche
9 == != "" Gauche
8 & et bit à bit Gauche
7 ^ ou exclusif bit à bit Gauche
6 | ou bit à bit Gauche
5 && et logique Gauche
4 || ou logique Gauche
3 ?: conditionnel Droite
= += -= *= /= %=
2 assignations Droite
>>= <<= &= ^= |=
1 , séparateur Gauche

Techniques de Programmation 59/102

Programmation en C
Priorité des opérateurs (exercices)
main(){
int x, y , z;
x = 2; x =0 ; y =0; z=0;
x += 3 + 2; printf("%d\n",x); x+=y+=z;
x -= y = z = 4; printf("%d%d%d\n",x,y,z); printf("%d\n", x < y ? y : x) ;
x = y == z; printf("%d%d%d\n",x,y,z); printf("%d\n", x < y ? x++ : y++) ;
x == (y = z); printf("%d%d%d\n",x,y,z); printf("%d, %d\n", x , y);
printf("%d\n", z += x < y ? x++ : y++)
x = 3; y =2 ; z = 1; ;
x = x && y || z ; printf("%d\n", x); printf("%d, %d\n", y , z);
printf ("%d\n", x || ! y && z);
x = y = 0; x = 3; y = z = 4;
z = x ++ -1; printf ("%d, %d\n", x, z); printf("%d\n",( z >= y >= x) ? 1 : 0)
z += -x ++ + ++ y; printf ("%d, %d\n", x, z); ;
printf("%d\n", z >= y && y >= x ) ;
x =1 ; y =1; x = y = z = 0;
printf("%d\n", ! x | x); }
printf("%d\n", ~ x | x);
printf("%d\n", x ^ x);
x <<= 3 ; printf("%d\n", x);
y <<= 3 ; printf("%d\n", y);
y >>= 3 ; printf("%d\n", y);

Techniques de Programmation 60/102