Cours Techniques de Programmation

01/10/2018
Techniques de
Programmation
Pr. : Mohamed El KAMILI
Contact : mohamed.elkamili@usmba.ac.ma
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
1
01/10/2018
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.
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.
2
01/10/2018
Programmation en C
 Le langage C est un langage compilé;
 Les compilateur assure 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.
Programmation en C
Fichier Compilateur C
Source C
Code
Assembleur
Assembleur
Code Objet
Code Linker
exécutable
3
01/10/2018
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
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
}
4
01/10/2018
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
Programmation en C
Type d’instructions en langage C
 Déclarations des variables
 Affectations
 Opérations
 Fonctions
 Contrôle
5
01/10/2018
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.
Programmation 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 :
Les entiers : int, 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;
6
01/10/2018
Programmation 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;
Programmation 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;
7
01/10/2018
Programmation 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.
Programmation en C
Le type Caractère
Caractère : Symboles alphanumériques (a,z,!,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
Table ASCII
ex : code ASCII du 'A' = 65
'A'<'B'<……..< 'Z'
'0'<'1'<'2'<…..<'9'
'a'<'b'<……….<'z'
8
01/10/2018
Programmation en C
Le type Caractère : Table ASCII
Programmation 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…
9
01/10/2018
Programmation 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)
Programmation 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)
10
01/10/2018
Programmation 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;
Programmation en C
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
11
01/10/2018
Programmation en C
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
Programmation 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
12
01/10/2018
Programmation en C
Le type réel : Représentation
Codage des réels : virgule flottante selon la norme IEEE

flottant stocké sous la forme M * BE
M : Mantisse ; B : Base = 2 ; E : Exposant
Exemple : 12.3 103 = 123 00
Représentation IEEE 754 (signe 1 bit, mantisse et exposant :

sur 32 ou 64 bits pour simple et double précision)
SM : signe de la mantisse : 1 bit
Eb : exposant biaisé : 8 ou 11 bits
M : Mantisse : 23 ou 52 bits
SM Eb M
Programmation 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
13
01/10/2018
Programmation 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
Programmation 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++;
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 */
14
01/10/2018
Programmation 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;
Programmation en C
Conversion de type : Le casting
Conversion explicite : ( type ) expression

Exemple :
int a; float x; char c;
a=2;
x=(float) 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'
15
01/10/2018
Programmation 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
Programmation 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');
16
01/10/2018
Programmation 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
Programmation 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);
}
17
01/10/2018
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 !
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
18
01/10/2018
Programmation en C
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)
Programmation en C
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é
19
01/10/2018
Programmation en C
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
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)
20
01/10/2018
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
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');
putchar('b');
Affichage sur écran

a
b
21
01/10/2018
Programmation en C
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
Programmation en C
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=32;
x = printf ("%d\n",a);
printf ("%d\n",x); => 3
22
01/10/2018
Programmation en C
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
….
Programmation en C
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
23
01/10/2018
Programmation en C
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
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()) {
…..
};
24
01/10/2018
Programmation en C
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
Programmation en C
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
25
01/10/2018
Programmation en C
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
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
26
01/10/2018
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
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) : &=, |=, ^=, ~=
27
01/10/2018
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)
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
28
01/10/2018
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)
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)
29
01/10/2018
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
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);
30
01/10/2018
Programmation en C
Structures de contrôle en C
A quoi servent-elles ?
Les structures de contrôle servent à automatiser un traitement

particulier sur des données. Le langage C définit des structures de
Traitement alternatif : la clause if else
Traitement sélectif : la clause switch case
Traitement itératif : les boucles for, while, do
Programmation en C
Clause conditionnelle if else
La structure de contrôle if sert à lier l’exécution d’un bloc de code

à l’état d’une condition
Syntaxe
if (expression){
Bloc1
}
else{
Bloc2
}
31
01/10/2018
Programmation en C
Clause sélective switch
La structure de contrôle switch sert à sélectionner le blocs de code

à exécuter selon la valeur d’une expression
T
Syntaxe
F
T
switch (expression){
F
case expression1 : Bloc1; break; .
case expression2 : Bloc2; break; ..
… … … … … T
default : BlocN; // optionnel
F
}
Programmation en C
Clause sélective switch : exemple
int i,j,k;
printf("entrez deux nombres entiers \n");
scanf("%d %d",&i,&j);
printf("entrez 0 pour avoir un quotient entier\n");
printf("ou 1 pour avoir le quotient fractionnaire\n");
scanf("%d",&k);
switch(k)
{ case 0 :
printf("%d\n",i/j);
break;
case 1 :
printf("%f\n",(float)i/j);
break;
default :
printf("il faut entrer 0 ou 1\n");
printf("relancez l'execution\n");
}
32
01/10/2018
Programmation en C
Boucle for
La structure de contrôle for permet de répéter l’exécution d’un

bloc d’instructions un certain nombre de fois.
Syntaxe
for (début; fin; mise à jour) {
…
…
…
Programmation en C
Boucle while
La structure de contrôle while permet de répéter l’exécution d’un

bloc d’instructions tant qu’une condition est vérifiée.
Syntaxe
while (condition) {
…
…
…
33
01/10/2018
Programmation en C
Boucle do while
La structure de contrôle do while permet de répéter l’exécution

d’un bloc d’instructions tant qu’une condition est vérifiée.
Syntaxe
do {
…
…
…
} while (condition)
Programmation en C
Les tableaux en C
Définition : Un tableau (unidimensionnel) A est une variable
structurée formée d'un nombre entier N de variables simples du
même type, qui sont appelées les composantes du tableau. Le
nombre de composantes N est alors la dimension du tableau.
En faisant le rapprochement avec les mathématiques, on dit encore

que "A est un vecteur de dimension N »
Exemple : La déclaration
int JOURS[12]={31,28,31,30,31,30,31,31,30,31,30,31};
définit un tableau du type int de dimension 12. Les 12 composantes

sont initialisées par les valeurs respectives 31, 28, 31, ... , 31.
34
01/10/2018
Programmation en C
Les tableaux en C
Utilisation
chaque élément du tableau est accessible par un indice qui doit
être de type entier, quelque soit le type des éléments du
tableau
exemples :
int i ;
tab[2] 3eme élément du tableau
tab[2+3] 6eme élément du tableau
tab[i] i+1eme élément du tableau
Exemples :
stocker les 100 premiers nombres pairs : 0,2,4,...,196,198
int i, t[100];
for (i=0; i < 100; i=i+1)
t[i]= 2*i;
Programmation en C
Les tableaux en C
Remarques
①chaque élément du tableau s'utilise comme une variable

tab[3] = 12;
②L’indice est un entier positif
①le nombre maximum d'éléments du tableau (dimension)

1/ doit être fixé à la compilation
2/ ne peut être modifié pendant l'exécution
②Pas d'opérations sur les tableaux en tant que tels
35
01/10/2018
Programmation en C
Les tableaux en C
Réservation de mémoire
Le programme doit disposer d’un espace mémoire où ranger

les éléments d’un tableau. Il se peut qu’on ne sache pas le
nombre d ’éléments à stocker dans un tableau avant
l’exécution du programme. On a alors deux solutions :
 On surdimensionne le tableau en question en évaluant

une taille maximale raisonnable de celui-ci
 On alloue dynamiquement la mémoire au moment où

on en a besoin (on peut aussi ensuite la restituer) : usage
de la fonction malloc
Programmation en C
Les tableaux en C
Réservation de mémoire
#include <stdlib.h>
void main(void) {
double * tab; //déclaration d’un tableau de taille variable (en réalité c’est un pointeur)
double tabfixe[50]; /* Tableau de taille fixe, 50 éléments */
int imax;
imax = 10; /* taille du tableau calculée à l ’exécution */

tab = (double *) malloc((imax+1)*sizeof(double));
Réserver (imax+1) espaces mémoire
tab[0] = 0.0; de la taille d ’un réel de type double
tab[10] = 5.0;
// tab[i] est le ième élément du tableau
On définit ainsi un tableau 1D nommé tab
tabfixe[5] = tab[0];
de variables réelles en double précision.
...
Les indices valides des éléments vont de 0 à imax.
}
36
01/10/2018
Programmation en C
Les tableaux en C
Les tableaux multidimensionnels
Il y a deux manières de déclarer les tableaux à plusieurs dimensions :
①On connaît a priori la taille du tableau :

ex : double tab[50][40];
définit un tableau nommé tab de 50 par 40 éléments.
Les indices vont de 0 à 49 pour la première dimension et de 0 à 39
pour la seconde
②On ne connaît pas la taille du tableau :

ex : double ** tab; /* Il faut ensuite allouer un espace
mémoire au tableau */
Programmation en C
Les tableaux en C
Il y a deux manières de déclarer les tableaux à plusieurs dimensions :
①On connaît a priori la taille du tableau : ex : double tab[50][40];

définit un tableau nommé tab de 50 par 40 éléments.
Les indices vont de 0 à 49 pour la première dimension et de 0 à 39
pour la seconde
②On ne connaît pas la taille du tableau : ex : double ** tab;

/* Il faut ensuite allouer un espace mémoire au tableau */
Il s’ensuit qu’un tableau 2D sera considéré comme un vecteur dont

chaque élément est un vecteur.
 Ce principe peut être étendu à des tableaux à n entrées.
37
01/10/2018
Programmation en C
Les tableaux en C
« Pointeurs » vers des vecteurs :
0 1 2 3 tableau 1D dont chaque élément
« pointe » vers un vecteur
0 0 0 0
1 1 1 1 tab[2][4],
2 2 2 2 tab[2] est l’adresse

du début du vecteur
4 4 4 4 d’indice 2, c’est un
pointeur vers tab[2][0]
5 5 5 5
Espace de stockage du tableau
Programmation en C
Les tableaux en C
/*Exemple de tableau avec allocation de mémoire dynamique */

double ** tab; /* déclaration d ’un tableau 2D de réels */
int imax, jmax;
imax = 50;
jmax = 40;
/* Allocation de mémoire pour la première dimension */

tab = (double**) malloc((imax+1)*sizeof(double*));
/* Allocation de mémoire pour la seconde dimension */

for(i = 0 ; i <= imax ; i++)
tab[i] = (double *) malloc((jmax+1)*sizeof(double));
38
01/10/2018
Programmation en C
Les tableaux en C
Les chaînes de caractères
Ce sont des tableaux de caractères
Convention propre à C : le dernier caractère de la chaîne est

suivi d’un octet de valeur 0
Les deux écritures suivantes sont identiques :

 char s[]= {’H’,’e’,’l’,’l’,’o’,0} ;
 char s[]= "Hello" ;
La notation " suite de caractères " crée une constante de type
tableau de caractères.
Programmation en C
Les tableaux en C
Opérations sur les chaînes de caractères
Le sous-programme suivant calcule la longueur d’une chaîne de

caractères, en utilisant le fait que les chaînes se terminent par un
octet nul
int taille(char chaine[]){

int i ;
for (i=0 ; ; i=i+1) {
if (chaine[i] == 0) //chaine[i] est le code ASCII du caractère
return i ;
}
}
39
01/10/2018
Programmation en C
Les tableaux en C
Affichage de chaînes de caractères

printf() avec le spécificateur de format %s
puts() écrit la chaîne de caractères désignée en argument sur stdout
et provoque un retour à la ligne.
Lecture de chaînes de caractères

scanf() avec le spécificateur de format %s (sans référence)
gets() lit une ligne de de caractères de stdin et la copie à l'adresse
indiquée en argument. Le retour à la ligne final est remplacé par le
symbole de fin de chaîne '\0'.
Programmation en C
Les tableaux en C
Ces fonctions de la bibliothèque <ctype.h> retournent une valeur

différente de zéro si le test est vérifié.
oisupper(<c>) : si <c> est une majuscule ('A'...'Z')

oislower(<c>) : si <c> est une minuscule ('a'...'z')
oisdigit(<c>) : si <c> est un chiffre décimal ('0'...'9')
oisalpha(<c>) : si islower(<c>) ou isupper(<c>)
oisalnum(<c>) : si isalpha(<c>) ou isdigit(<c>)
oisxdigit(<c>) : si <c> est un chiffre hexadécimal
('0'...'9' ou 'A'...'F' ou 'a'...'f')
oisspace(<c>) : si <c> est un signe d'espacement
(' ', '\t', '\n', '\r', '\f')
otolower(<c>) : retourne <c> converti en minuscule si <c> est majuscule
otoupper(<c>) : retourne <c> converti en majuscule si <c> est minuscule
40
01/10/2018
Programmation en C
Les tableaux en C
ochar * strcat(char * d, const char * s) Concaténation de la chaîne s

au bout de la chaîne d
ochar * strncat(char * d, const char * s, int n) Concaténation de la
chaîne s au bout de la chaîne d, recopie de n caractères au plus
ochar * strcpy(char * d, const char * s) Copie de la chaîne s dans la
chaîne d
ochar * strncpy(char * d, const char * s, int n) Copie d’une chaîne de
caractères, recopie de n caractères au plus
oint strcmp(const char * d, const char * s) Comparaison de deux
chaînes de caractères
oint strncmp(const char * d, const char * s, int n) Comparaison de
deux chaînes de caractères
oint strlen(const char * s) Longueur d’une chaîne de caractères
Les fonctions en C
Programmation
Les fonctions
Une fonction permet de :
 Remplacer une partie qui se répète
 Découper un programme en parties isolées -> débogage, lisibilité, etc..
Exemples : fonctions d'E/S (scanf, printf, …), mathématiques (sin, cos, …)
Organisation d'un programme :
type fonction1 (arguments) {
Déclarations de variables et de types locaux à la fonction
Instructions
}
type fonction2 (arguments) {
Instructions
}
...
void main (arguments) {
Instructions
}
41
01/10/2018
Exemple
Programmation en C
Les fonctions : Exemple
char minus_majus (char c1) {
char c2; /* déclarations locales */ Argument
Type de if (c1 >= 'a' && c1 <= 'z')
la valeur
de retour c2 = c1+'A'-'a';
else c2=c1;
Instructions
return (c2);
}
void main() { Valeur renvoyée
char c,majuscule;
printf("Donner un caractere\n");
c = getchar(); getchar();
Appel de la fonction
majuscule = minus_majus(c);
printf ("La majuscule de %c est %c\n",c,majuscule);
}
Définition de fonction
Programmation en C : syntaxe
Les fonctions : Définition et syntaxe
type_fonction nom_fonction(type_arg1 arg1, …, type_argn argn){

…
return (valeur retournée);
}
Dans l'exemple précédent :

type_fonction : char, c'est le type de la valeur renvoyée par return
nom_fonction : minus_majus
Le nombre d'arguments est quelconque, éventuellement aucun, les parenthèses

doivent toujours figurer (ex: main () )
42
01/10/2018
Type de la fonction
Programmation en C
Les fonctions : Type de la fonction
 Une fonction peut ne pas renvoyer de valeur.
Exemple
void print_majus (char c1) {
char c2;
if (c1 >= 'a' && c1 <= 'z')
c2 = c1+'A'-'a';
else c2=c1;
printf("la majuscule de % est %c, c1, c2);
return; /* ou bien return (); */
}
 Dans ce cas, le type de la fonction est : void
 Le type de la fonction ne peut être que :
• int, float, char, ou adresse de
• ni tableau, ni autre type complexe
Instruction return
Programmation en C
Les fonctions : Instruction return
1. Indique la valeur de retour de la fonction.
2. Arrête l'exécution de la fonction
char minus_majus (char c1) {
if (c1 >= 'a' && c1 <= 'z')
return (c1+'A'-'a');
else return (c1);
}
Pour les fonction de type void, return est optionnel

void print_majus (char c1) {
char c2;
if (c1 >= 'a' && c1 <= 'z')
c2 = c1+'A'-'a';
else c2=c1;
printf("la majuscule de % est %c, c1, c2);
}
43
01/10/2018
Appel des fonctions

Programmation en C
Les fonctions : Appel d’une fonction
L'appel d'une fonction se fait en donnant son nom, suivi de la liste des paramètres
entre parenthèses. L'ordre des paramètres correspond à celui des arguments.
Exemple
float puiss(float x, int n) {
float y=1.0;
if (n>0) for (i=1;i<=n;i++) y = y*x;
else for (i=1;i<=n;i++) y = y/x;
return (y);
}
void main() {
float z,t;
z = puiss(10.7,2);
t = puiss (z, -6);
...
}
Appel des fonctions

Programmation en C
Les fonctions : Appel d’une fonction
Un appel de fonction peut se faire comme opérande d'une expression, soit comme
paramètre d'un autre appel de fonction.
Exemple
int maximum (int x, int y) {
return((x>y)?x:y));
}
void main () {
int v1,v2,v3,m1;
scanf("%d %d %d", &v1,&v2,&v3);
m1 = maximum(v1,v2);
m1 = maximum(m1,v3);
printf("valeur maximale %d\n", m1);
}
ou bien
m1 =maximum(v1,v2);
printf("valeur maximale %d\n", maximum(m1,v3));
ou bien
printf("valeur maximale %d\n", maximum(maximum(v1,v2),v3));
44
01/10/2018
Règles de déclaration
Programmation en C et d'appel
Les fonctions : Déclaration et appel
Toute fonction ne peut appeler que des fonctions déclarées avant elle ou elle-même.
... f1 (..) {
...
}
... f2 (...) {
...
}
... f3 (...) {
...
}
void main (...) {
...
}
la fonction main peut appeler f1,f2,f3
la fonction f3 peut appeler f1,f2,f3
la fonction f2 peut appeler f1, f2
la fonction f1 peut appeler f1
Lorsqu'une fonction s'appelle elle-même, on dit qu'elle est "récursive".
Déclarations enen"avance"
Programmation C
Les fonctions : Déclaration et appel
 Règle précédente contraignante
 Solution : Prototype
En début de programme on donne le type de chaque fonction , son nom, le
nombre et les types des arguments
 Information suffisante pour le compilateur.
float puiss(float,int);
/*Prototype de la fonction puiss*/
void main(){ /*Appel avant déclaration*/
puiss (10.2, 5);
...} /*Déclaration de la fonction */
float puiss(float x, int n){
float y=1.0;
if (n>0) for (i=1;i<=n;i++) y = y*x;
else for (i=1;i<=n;i++) y = y/x;
return (y);
}
45
01/10/2018
Fichier "header"
Programmation en C
Les fonctions : Fichier "header"
Conseil de programmation :
Dans un fichier ".h" déclarer les prototypes de toutes les
fonctions, par exemple "mylib.h"
Dans le ou les fichiers ".c", insérer la directive

#include "mylib.h"
Passage des paramètres

Programmation en C
Les fonctions : Passage des paramètres
 Rappel : les paramètres sont associés aux arguments suivant l'ordre de
déclaration.
 En c, cette association se fait par COPIE de la valeur du paramètre dans
l'argument. Chaque argument est en fait une variable locale de la fonction. La
fonction travaille sur l'argument.
 Conséquence : Une fonction ne modifie pas les paramètres d'appels
void f(int a){
a=a+1;
}
void main(){
int b;
b=0;
f(b);
printf("%d\n",b); ->0
}
46
01/10/2018
Détail
Programmation en C
Les fonctions : Passage des paramètres
void f (int a){
a=a+1; /*3*/
}
void main(){
int b;
b=0; /*1*/
f(b); /*2*/
printf("%d\n",b); /*4*/
}
b 0 b 0 b 0 b 0 Inchangé
Copie
a 0 a 1
Modification des
Programmation enparamètres
C
Les fonctions : Modification des paramètres
 Si l'on veut qu'une fonction modifie un paramètre, on ne passe pas la
variable mais l'adresse de la variable. Il y a copie de l'adresse de la
variable. Dans la fonction on va chercher la variable par son adresse.
 Rappels :
opérateur & : &variable -> adresse de la variable
opérateur * : * adresse -> valeur qui se trouve à cette adresse
int i;
int * adresse_i; /* déclaration d'une adresse d'entier */
i=0;
adresse_i=&i;
printf("%d\n",i); -> 0;
...
47
01/10/2018
Programmation en C
Les fonctions : Modification des paramètres
void f2(int *a){ // a est l'adresse, *a est l'entier
*a=*a+1; /*t3 on incrémente le mot d'adresse a*/
}
void main(){
int b;
b=0; /*t1*/
f2(&b); /*t2 &b est l'adresse de b */
printf("%d\n",b); /*t4*/ -> 1
}
b 0 728 b 0 b 1 *a b 1
&b 728 &b 728

Copie
a 728 a 728
/*t1*/ /*t2*/ /*t3*/ /*t4*/
Autre exemple : scanf ("%d",&v);
Fichier "header"
Programmation en C
Relation entre tableau et pointeur
 En C, le nom d’un tableau représente l’adresse de sa composante 0,
donc a == &a[0]
 C'est pour cela que les tableaux passés comme paramètres dans une
fonction sont modifiables
 Pour le compilateur, un tableau comme argument de fonction, c’est un
pointeur vers sa composante 0 (à la réservation mémoire près).
 La fonction peut donc modifier n’importe quel élément du tableau
(passage par référence)
 Le paramètre peut soit être déclaré comme tableau, soit comme
pointeur
int function(int a[], int size) int funtion(int *p, int size)
{ {
48
01/10/2018
Fichier "header"
Programmation en C
Relation entre tableau et pointeur
Notations
A[0] est équivalent à *A
A[i] est équivalent à *(A + i)
&A[0] est équivalent à A
Exemple
Short T[8] = { 10, 20, 30, 40, 50, 60, 70, 80};
p 1000
short *p = T;
printf("%d\n", T[3]);
printf("%d\n", *(T + 3)); 40
printf("%d\n", *(p + 3)); 40 T
10 20 30 40 50 60 70 80
printf("%d\n", p[3]); 40
1000 1004 1008 1012
40 1002 1006 1010 1014
Programmation en C
Les structures de données
 Une structure est une collection de plusieurs variables (champs)
groupées ensemble pour un traitement commode
 Les variables d’une structure sont appelées membres et peuvent

être de n’importe quel type, par exemple des tableaux, des
pointeurs ou d’autres structures
Exemple struct Membre

{
char nom[80];
char adresse[200];
int *numero;
float amende[10];
};
49
01/10/2018
Programmation en C
Les structures de données : Déclaration
Les structures sont définies en utilisant le mot-clé struct
struct Membre
struct Date {
{ char nom[80];
int jour; char adresse[200];
int mois; int numero;
! int an; float amende[10];
}; struct Date emprunt;
struct Date creation;
};
struct Livre
{ struct Pret
char titre[80]; {
char auteur[80]; struct Livre b;
float prix; struct Date due;
}; struct Membre *who;
};
Programmation en C
Les structures de données : Instanciation
 Une fois la structure définie, les instances peuvent être déclarées
 Par abus de langage, on appellera structure une instance de
structure
struct Date
{
int jour;
int mois;
int an; Déclaration avant ‘;’
} hier, demain;
struct Date paques;

struct Date semaine[7]; Initialisation
struct Date nouvel_an = {1,1,2001};

50
01/10/2018
Programmation en C
Les structures de données : Accès aux membres
Les membres sont accédés par le nom de l’instance, suivi de . ,

suivi du nom du membre
struct Membre m;
printf("nom = %s\n", m.nom);

printf(”numéro de membre = %d\n", m.numero);
printf(”amendes: ");
for(i = 0; (i < 10) && (m.amende[i] > 0.0); i++)
printf("%.2f Euros", m.amende[i]);
printf("\nDate d’emprunt %d/%d/%d\n", m.emprunt.jour,

m.emprunt.mois, m.emprunt.an);
Programmation en C
Les structures de données : Affectation
 L’opération d’affectation = peut se faire avec des structures
 Tous les membres de la structure sont copiés (aussi les

tableaux et les sous-structures)
struct Membre m = {"Arthur Dupont",

.....
};
struct Membre temp;
temp = m;
51
01/10/2018
Programmation en C
Les structures de données : Passage comme paramètres
 Une structure peut être passée, comme une autre variable,
par valeur ou par adresse
 Passer par valeur n’est pas toujours efficace (recopiage à
l’entrée)
 Passer par adresse ne nécessite pas de recopiage
void Par_valeur(struct Membre m);

void Par_reference(struct Membre *m);
Par_valeur(m);
Par_reference(&m);
Programmation en C
Les structures de données : Pointeur sur structure
 Syntaxe pour accéder aux membres : p->name
 L’écriture p->name est synonyme de (*p)->name, où p est un
pointeur vers une structure
void affiche_membre (struct Membre *p)

{
printf("nom = %s\n", p->nom);
printf("adresse = %s\n", p->adresse);
printf(”numéro de membre = %d\n", p->numero);
printf("\nDate d’affiliation %d/%d/%d\n",

p->creation.jour, p->creation.mois, p->creation.an);
}
52
01/10/2018
Références
 Bernard Cassagne, « INTRODUCTION AU LANGAGE C ». Norme

ISO/ANSI
 Auteur inconu ! Rappel et compléments de la programmation en

langage C.
 http://www.wikipedia.org/
53

Cours Techniques de Programmation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Techniques de Programmation

Transféré par

Droits d'auteur :

Formats disponibles

01/10/2018

Techniques de Programmation 1/102

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

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

 la norme ANSI (American National Standards Institute).

Techniques de Programmation 3/102

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

 Langage universel : Permet de développer tout type

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

 Langage puissant et efficace;

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

Techniques de Programmation 4/102

 Le langage C est un langage compilé;

 Les compilateur assure les opérations suivantes:

Techniques de Programmation 5/102

Techniques de Programmation 6/102

fonction a() instructions

fonction b() instructions

Techniques de Programmation 7/102

Techniques de Programmation 8/102

 Déclarations des variables

Techniques de Programmation 10/102

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

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

Le langage C est sensible à la casse.

Techniques de Programmation 11/102

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

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

Les entiers : int, short int, long int

Techniques de Programmation 12/102

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

 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

Techniques de Programmation 13/102

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

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

Techniques de Programmation 14/102

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

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

Techniques de Programmation 15/102

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

Techniques de Programmation 17/102

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

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

Techniques de Programmation 18/102

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

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

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

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

Implantation sur 2 ou 4 octets suivant le compilateur

Si xn-1 = 0 : nombre positif,

Exemple sur 16 bits

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

Techniques de Programmation 22/102

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

Implantation sur 4 octets

Techniques de Programmation 24/102

Codage des réels : virgule flottante selon la norme IEEE

Représentation IEEE 754 (signe 1 bit, mantisse et exposant :

Techniques de Programmation 25/102

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

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