Cours ASIMI SD 2020 - 2021

10/05/2021
Contenu de cours
Programme et Langage de Programmation
Cours Un programme est la traduction directe d'un algorithme, dans

un langage de programmation compréhensible par la machine.
Langage C et Structures de données En C
 Un programme est une suite finie d'instructions, écrites dans un
Ecole Supérieure de Technologie – Guelmim langage de programmation et exécutées par un ordinateur, permettant
Université Ibn Zohr –Agadir- de traiter un problème et de renvoyer des résultats.
 Un langage de programmation est un langage qui, après avoir écrit les
DUT-Informatique –S1 et S2 instructions d’un programme, permet de les rendre compréhensibles et
exécutable (compilation) par l'ordinateur.
Prof. ASIMI Younes  Qu’est-ce qu’on peux dire sur la programmation?

 Séquences d’instructions qui permettent de donner des ordres à un
asimi.younes@gmail.com ordinateur;
2018/2019/2020/2021
09/05/2021 Prof. ASIMI Younes 2
Contenu de cours Contenu de cours
Programme et Langage de Programmation Programme et Langage de Programmation
 A quoi cela sert-elle? Le langage machine (ordinateur) ou encore le langage de la

 Développer des applications;
première génération est un ensemble des suites binaires (instructions)
 Automatiser des tâches récursives ou bien répétitives…;
comprises par le microprocesseur (processeur). Ce langage est difficile
à maîtriser puisque chaque instruction est codée par une séquence
 Effectuer des calculs complexes;
propre de bits.
 ….;
 Compilation : Une fois le programme écrit, on ne peut pas l’exécuter
 Exemple de langage de programmation : directement. Pour que l’ordinateur comprenne ce que l’on veut lui faire, il
 C, C++, Maple, MatLab, Pascal, VB, JAVA …. faut traduire le programme en langage machine. Cette traduction
s’appelle la compilation.
 La compilation est donc la traduction du code source en langage
Machine.
09/05/2021 Prof. ASIMI Younes 3 09/05/2021 Prof. ASIMI Younes 4
1
10/05/2021
Structure d’un Programme Les directives (includes) de pré-compilation ou encore les

Un programme en langage C se caractérise par : directives du préprocesseur qui sont des lignes commençant
 Un fichier source dont l'extension est par convention (.c); toujours par #.
 Une ou plusieurs fonctions dont l’une s’appelle obligatoirement main(),
celle-ci constitue le programme principal ;
 La déclaration de toutes les variables et fonctions utilisées;
 Les instructions;
 On distingue deux types de commentaires :
Commentaire ligne caractérisé par //.
Commentaire sur un ensemble des lignes délimitées par /* et */.
Parmi ces directives, une seule est obligatoire pour le bon Exemples de programme en langage C
fonctionnement d’un programme : #include<stdio.h>. #include<stdio.h>
main(){
int i; /*déclaration des variables */
instruction_1;
instruction_2;
...
}
# include <stdio.h>
main (){
//Mon 1er programme en C
printf ("Bonjour tout le monde, c’est mon premier programme en langage C") ;
}
2
10/05/2021

Déclaration des constantes et des variables Déclaration des constantes
Les constantes symboliques définies par la commande #define avec
Le langage C fait la différence entre les MAJUSCULES et les la syntaxe :
minuscules. Donc, on dit qu’il est sensible à la casse;
 #define NOM valeur_constante
 En général, on a deux classes de variables :
 Constantes entières 1, 2,3,...: #define N 1
 Une variable locale.
 Constantes caractères 'a', ‘A',... : #define C 'a'
 Une variable globale.
La commande const signifiant constante, avec la syntaxe :
 Définition 1 : Toute variable définie à l'extérieur des fonctions est
 const type identificateur=valeur ;
une variable globale.
 Exemple :
 Définition 2 : Les variables définies à l'intérieur des fonctions sont
 Const int n=30 ; /*on déclare la constante n de type entier et de valeur
des variables locales. égale à 30 */.
 Const char c=50 ; /*on déclare la constante c de type entier [0,255] et
de valeur égale à 50 */.

Déclarations des variables (rappel)
Identifications et Déclarations des variables
Une variable est caractérisée par : Un nom, Un type, Une valeur et Une
adresse.
Identificateurs: Ils servent à donner un nom aux entités du
 Une adresse est définie une fois pour toute et ne varie pas au cours programme (variables, fonctions, ...). Ils sont formés d’une suite de lettres,
du programme. chiffres et du signe souligné, le premier caractère étant impérativement une
 Le contenu de la variable peut être modifié autant de fois que l’on lettre.
veut, mais son adresse reste inchangeable.  Le seul caractère spécial admis est le soulignement (_).
 Exemple :
 Pour déclarer donc une variable, on fait précéder son nom par son
type avec la syntaxe suivante :  int x1,y,_tf ; est une déclaration vraie des variables x1,y et_tf .
 Type NomVariable ;  Mais la déclaration suivante : int 2x ; est fausse.
 Type NomVariable1, NomVariable2, NomVariable3, … ;
3
10/05/2021

Types des données élémentaires
Certains mots sont réservés pour le langage et ne peuvent donc pas être utilisés
comme identificateurs. Un programme C manipule deux structures de données de base :
 Les entiers qui sont des constantes sans virgule qui se distinguent par la
place qu’ils occupent en mémoire (en fonction de sa taille binaire
prédéfinie : le nombre de bits associé). On distingue deux classes des entiers
: les entiers signés et les entiers non signés.
 Les nombres flottants qui sont des constants réels arrondis. En général,
ils sont de type float et leurs extensions.

Types des données élémentaires Types des données élémentaires
Type flottant ou pseudo réel:
Type entier:
 Les nombres à virgule flottante servent à coder de manière
Un nombre de type entier est représenté en C par le type int.
approchée les nombres réels. Un nombre à virgule flottante est
composé d'un Signe, d'une Mantisse et d'un Exposant:
N = (-1)s × 2E × 1,M
En fonction des compilateurs, il peut être codé sur 2 ou 4 octets.
4
10/05/2021

Types des données élémentaires Types des données élémentaires
Type caractère:  Remarques :
 En langage C, un caractère est représenté par le type char (un cas particulier  Les constantes de type caractère se note entre apostrophes: ‘A’, ‘a’, ‘2’ .
de int).  Les chaînes de caractères se note entre guillemets: "ma chaine de caractère".
 Les constantes de type char s’écrivent en mettant le caractère correspondant  Une chaîne de caractères doit être écrite sur une seule ligne.
entre apostrophes.
 Lorsqu'il est trop long pour tenir une même ligne, on découpe celle-ci en
 Exemple : deux et l'on masque le retour à la ligne par le caractère \. Les deux
char C,F ; C=’A’ ; F=65 ; instructions suivantes sont équivalentes :
 x="abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUV";
 x="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUV ";

Opérateurs Opérateurs arithmétiques
 Opérateurs d'affectation Pour les opérations dites naturelles, on utilise les opérateurs:
 Le premier opérateur à connaître est l’opérateur d’affectation noté

"=".
 On affecte une constante et /ou une variable à une variable mais
jamais une constante et une variable à une constante.
 Exemple : Le résultat d’une opération entre types différents se fait dans le
 x=5; Il sert à mettre dans la variable x la valeur 5. type le plus haut. Les types sont classés ainsi :
 Mais 5=x ; pas de sens. char --> short --> int --> float --> double;
 Par ailleurs, l’opération ’a’+1 a un sens, elle a pour résultat le
caractère suivant à a dans le code ASCII.
5
10/05/2021

Opérateurs de comparaison Opérateurs logiques
Priorité et Associativité des opérateurs Programme et Langage de Programmation

Opérateurs d'incrémentation et de décrémentation
En C, il existe un certain nombre d’opérateurs spécifiques, qu’il faut
utiliser prudemment sous peine d’erreurs.
 ++ Incrémente la variable d’une unité.
 -- décrémente la variable d’une unité.
Rq : Ces 2 opérateurs ne s’utilisent pas avec des réels (type float).
Exemples d’utilisation :
int i;
i++; /* effectue i=i+1 */
i--; /* effectue i=i-1 */
Autres propriétés de ++:
 Leur utilisation devient délicate quand on les utilise avec d’autres
opérateurs.
6
10/05/2021

 Quand l’opérateur ++ est placé avant une variable, l’incrémentation est
 Quels seront les résultats fournis par l’exécution du programme suivant :
effectuée en premier.
# include <stdio.h>
 L’incrémentation est faite en dernier quand ++ est placé après la variable.
main ( )
 Exemple : { int N = 1, P =2, Q=1,R ;
int i=1, j ; R=N= = (P=Q) ;
printf ("A : N = %d P = %d Q = %d R = %d \n",N ,P,Q,R ) ;
j=i++; /*effectue d’abord j=i et ensuite i=i+1 */ // N = 1 P = 1 Q = 1 R = 1
/*on a alors j=1 et i=2 */ Q = N++ + P++ ;R = P > Q ;
printf ("B : N = %d P = %d Q = %d R = %d \n",N ,P,Q,R ) ;
j=++i ; /*effectue d’abord i=i+1 et ensuite j=i */ //N = 2 P = 2 Q = 2 R = 0
/*on a alors j=3 et i=3 */ Q = N++ + ++P ; R= P= =Q ;
printf ("C : N = %d P = %d Q = %d R = %d \n",N ,P,Q,R ) ;
int i=4, j ;
//N = 3 P = 3 Q = 5 R = 0
j=i--; /*effectue d’abord j=i et ensuite i=i-1 */ Q = N++ + P-- ;
/*on a alors j=4 et i=3 */ R = P || Q ;
printf ("D : N = %d P = %d Q = %d R = %d \n",N ,P,Q,R ) ;
j=--i ; /*effectue d’abord i=i-1 et ensuite j=i */ //N = 4 P = 2 Q = 6 R = 1
/*on a alors i=2 et j=2*/

 Autres opérateurs :
P=2 ; N=3 ;
Q = N++ - --P ; i+=5 ; /*i=i+5 */
R= P & Q ; i-=3 ; /*i=i-3 */
printf ("E : N = %d P = %d Q = %d R = %d \n",N ,P,Q,P&&R ) ;
i*=4 ; /*i=i*4 */
//N = 4 P = 1 Q = 2 R = 0
Q = (--N) - (--P); R= P && Q ; i/=2 ; /*i=i/2 */
printf ("F : N = %d P = %d Q = %d || R = %d \n",N ,P,Q,Q&&R ) ; i%=3 ; /*i=i%3 */
//N = 3 P = 0 Q = 3 || R = 0
Q = --N + P++ ; Que retourne le programme suivant:
R= N >P ? --Q+N++ : --P - Q++ ; #include<stdio.h>
printf ("G : N = %d P = %d Q = %d && R = %d \n",N ,P,Q,P||R ) ; main()
//N = 3 P = 1 Q = 1 && R = 1 {int i=9, k=3,A,B ;
R= N < P ? –P + N++ : P++ - ++Q ;  A=--i + ++k ; B=i++ - --k ;}
printf ("H : N = %d P = %d Q = %d R = %d \n",N ,P,Q,R ) ;
 A=12, B=5, i=9 et k=3.
//N = 3 P = 2 Q = 2 R = -1
}  A=12, B=6, i=8 et k=3.
 A=13, B=5, i=9 et k=4.
 A=12, B=5, i=8 et k=4.
7
10/05/2021

Opérateurs de manipulation de bits  La valeur de 12|5 est :
 5.
 12.
 13.
 La valeur de 12^5 est :
 9.
 12.
 13.
 Autre chose.

Fonction printf Exemples
La fonction printf permet d’afficher à l’écran les arguments qu’on lui
fournit. printf(‘‘ la somme de %d et %d vaut %d \n’’,2,4,2+4) ;
Syntaxe : printf(‘‘format’’,arg1,arg2,…..,argN); Dans cet exemple la fonction printf affichera à l’écran la phrase
suivante :
la somme de 2 et 4 vaut 6.
#include<stdio.h>
main(){
int n=30,m=40;
printf("%d",n); /*affiche la valeur de n au format entier*/
printf("n=%d",n); /*affiche n=30*/
• Remarque: pour déclarer une variable de type booléen (en C++), on printf("n=%d,m=%d",n,m); /* affiche n=30,m=40*/
utilise la clause bool de la bibliothèque <stdbool.h>. printf("n=%5d",n); /* affiche la valeur de n sur 5 caractères: n=30*/
• Exemple: bool A=1,B=0; }
8
10/05/2021

Fonction scanf  Exemple 2 : Donner un programme de permutation des valeurs de deux
variables.
La fonction scanf permet de lire des données au clavier:
#include<stdio.h>
scanf(‘‘format’’,&arg1,&arg2,…..,&argN) ;
main()
– Exemple 1: Calcul de la somme 1+2+3…n avec n un entier à saisir
{int x, y,z;
au clavier.
printf("enter deux entiers\n") ;
#include<stdio.h>
scanf("%d, %d ",&x, &y);
main(){int n, S;
z=x;
printf("enter un entier") ;
x=y ;
scanf("%d",&n);
y=z ;
S=n*(n+1)/2 ;
printf("la valeur de %d et la valeur de %d après permutation est
printf("la somme de %d premiers nombres est S=%d",n,S); ",x,y);
} }
Exemple 3 : trouver les résultats d’exécution de ce Structures de contrôle

programme: En langage C, les instructions sont exécutées séquentiellement c'est-à-
dire dans l’ordre où elles apparaissent. Il dispose des instructions
#include<stdio.h> nommées « instructions de contrôle », permettant de réaliser des:
main(){ choix ;
char x=267, y=512,z=65, w=256; boucles ;
printf(" x=%d, y= %d, z=%d, w=%d ", x,y,z,w); Elles servent à contrôler le déroulement de l'enchaînement des
instructions à l'intérieur d'un programme.
}
En générale, on a deux classes des instructions de contrôle :
 Structures conditionnelles (ou alternatives).
Résultat:
 Structures itératives (ou répétitives).
x=11, y=0, z=65, w=0
9
10/05/2021

Structures de contrôle Structures conditionnelles
Les structures conditionnelles sont :
Une instruction simple est une expression suivie d’un point
Structure if;

virgule.
Exemple d’instruction : Structure if …else;

 Structure switch.
 n=i-4 ;
Syntaxes :
Un bloc d’instructions est composé de plusieurs instructions
délimité par deux accolades :
Accolade ouvrante ‘‘{’’
et
Accolade fermante ‘‘ }’’.

Structures conditionnelles Exemple :
#include <studio.h>
 Dans le cas d’une seule instruction : Si expression est vraie,
l’instruction1 est exécutée. Sinon il sort de la boucle. main( )
{ float Moy ;
 Dans le cas de deux instructions : Si l’expression est vraie,
printf( ‘‘ entrer votre moyenne\n’’) ;
l’instruction1 est exécutée. Sinon c’est l’instruction2 qui sera
exécutée. scanf (‘‘ %f ’’,&Moy) ;
if(Moy>=16 && Moy <=20) {
 Dans le cas de deux blocs d’instructions : Si l’expression est
printf(‘‘ mention très bien avec félicitations du jury\n’’) ;
vraie, le bloc d’instruction1 est exécutée. Sinon c’est le bloc
d’instruction2 qui sera exécutée. } else {
printf(‘‘votre mention est insuffisante pour accéder à l’école ST \n’’) ;
}
}
10
10/05/2021

Opérateur conditionnel
Que retourne l’affichage suivant :
main(){
int a = -3, b = -2, c = -1 ;
if(a<b<c)
printf (“Bonjour”) ;  e ?x :y ; Signifie que si la condition e (expression Boolienne) est
else vraie alors cette expression vaut x sinon elle vaut y .
printf(“Bonsoir”);
 Exemples:
}
 Bonsoir.
 a = (v = = 3) ? 1 : 2;
 Bonjour.  a=1 si v vaut 3 (l’expression boolienne v==3 est vraie) sinon a=2.
 Erreur.  a= x>y ? 5 :10 ;
 Autre chose.
 a=5 si x>y sinon a=10.

Structure switch
Que retourne l’affichage suivant : Cette instruction permet de faire plusieurs tests de valeurs sur le
void main(void) contenu d'une même variable (sélecteur).
{ int A=10,B=33;  Sa syntaxe est la suivante avec default:
unsigned char C,V;
switch (Variable) {
C= (V = !255) ? A+B : A*B;
case Valeur1 : Liste d'instructions; break;
printf("Valeur de C est : %d", V);
} case Valeur2 : Liste d'instructions; break;
……
case ValeursN: Liste d'instruction; break;
 Valeur de C est : 74 default:
Liste d'instructions;
}
11
10/05/2021

Exemple :
 Les parenthèses qui suivent le mot clé switch indiquent une expression
dont la valeur est testée successivement par chacun des cases.
 Le mot clé break indique la sortie de la structure conditionnelle.
 Le mot clé default précède la liste d'instructions qui sera exécutée si
l'expression n'est jamais égale à une des valeurs.
 Sa syntaxe sans default est la suivante :
switch (Variable) {
case Valeurs... : Liste d'instructions; break;
}

 Dans l’Exemple 1 : Nous pouvons exécuter les mêmes instructions pour différentes valeurs
 Si i=1, on exécute uniquement l’instruction 1.
 Si i=2, on exécute les instructions 2 et 3.
consécutives et on peut mettre plusieurs cases avant le bloc.
 Si i=10, on exécute uniquement instruction 3.  Sa syntaxe est la suivante :
 Pour toutes les autres valeurs de i, on n’exécute que l’instruction 4.
switch (variable){
 Dans l’Exemple 2 :
case 1:case 2:
{Instructions exécutées pour variable = 1 ou pour variable = 2 } break;
 Si i=2, on exécute l’instruction 2.
 Si i=10, on exécute les instructions 3 et 4. case 3:case 4:case 5: {Instructions exécutées pour variable = 3 ou = 4
 Pour toutes les autres valeurs de i, on n’exécute que l’instruction 4. ou =5 } break;
 Dans l’Exemple 3 : case 6: {Instructions exécutées pour variable = 6 uniquement} break;
 Si i=1, on exécute les instructions 1, 2, 3 et 4. default:
 Si i=2, on exécute les instructions 2, 3 et 4. {Instructions exécutées pour toute autre valeur de variable} }
 Pour toutes les autres valeurs de i, on n’exécute que l’instruction 4.
12
10/05/2021
Exemples
Trouver le résultat retourné par le programme suivant : Trouver le résultat retourné par le programme suivant :
void main(void) void main(void)
{ char A=129; { char A=-129;
printf(" %d", A); printf(" %d", A);
} }
2 ;  On a 129=128+1;
 Sa représentation binaire est:10000001; donc,
127 ;
129 ; -127 ;
c’est un nombre négatif;
-127 ;  CA2(0000001)2=(1111111)2 129 ;
Autre chose ;  Après calcul, on trouve :(1111111)2=(127)10 Autre chose ;
 Donc, la valeur exacte est: (10000001)2 =(-127)10
 Remarque Importante: On a 256= 28 =(100000000)2; char sur 8bits, donc, on a
fuite d’information (perte des bits).
Exemples Exemples
Trouver le résultat retourné par le programme suivant : Trouver le résultat retourné par le programme suivant :
void main(void) void main(void)
{ char A=256; { char A=-260;
printf(" %d", A); printf(" %c", A);
} }
 On a 260=256+4;
256 ; 4 ;
 Sa représentation binaire est:100000100;
0 ; 252 ;  Char sur un octet, donc, on va prendre la valeur
-128 ; 131 ; binaire: 00000100, fuite d’information;
127 ; 260 ;  -260=CA2(260)10=(11111100)2
 Après calcul, on trouve que le code ascci égale à:
(252)10
13
10/05/2021
Exemples Exemples
Trouver le résultat retourné par le programme suivant : Trouver le code ASCII du caractère retourné par le programme
void main(void) suivant :
{ char A=-260; void main(void)
printf(" %d", A); { char A=-20;
} printf(" %c", A);
-260 ; }  Sa représentation binaire de 20 est:00010100;
-4 ; 20 ;  Char sur un octet, donc, on va prendre la valeur
binaire: 00010100, sans fuite d’information;
4 ; 4 ;
 -20=CA2(20)10=(11101100)2
260 ; 235 ;  Après calcul, on trouve que le code ascci égale à:
236 ; (236)10

Exemples
 Une entreprise nommée GuelmimEnirg vend deux types de
produits. Un produit de type A qui donne lieu à une TVA à 3%,
et un produit de type B qui donne lieu à une TVA à 4.5%.
 Ecrire un programme qui lit au clavier le prix hors taxe d’un produit et
le type de produit, puis, affiche le prix totale TCC du produit;
 Ecrire un programme qui lit deux nombres entiers a et b et

donne le choix (de 1 à 4) à l’utilisateur de savoir:
 Si la somme a+b est paire;
 le signe de la somme;
 Si le produit a*b est paire;
 Le signe du produit.
14
10/05/2021

Structures répétitives Structures répétitives
 Exemple:
Structures répétitives permettent d’exécuter une même séquence #include<stdio.h>
d’instructions un certain nombre de fois. On a trois classes :
void main ( )
 La boucle while.
 La boucle do…while. { int i=1;
 La boucle for. while (i<=3){
 La boucle While: printf ("bonjour %d fois\n",i);
La structure de contrôle while permet de répéter l’instruction ou bloc i++ ;
d’instructions tant que la condition reste vraie. }}
– Syntaxe :  La boucle do…while:
La boucle do…while, répète les instructions qu’elle contient tant que

la condition mentionnée (condition) est vraie.
Rq: Une itération est toujours exécutée.
15
10/05/2021
 Syntaxe : Structures répétitives Structures répétitives

 La boucle for:
Le rôle de l’instruction for est de répéter le bloc (délimité par les
accolades ‘‘{‘’et ‘‘}’’).
 Syntaxe :
– Exemple 2 : for (instruction 1;condition de poursuite ;instruction 2)
#include<stdio.h> {
void main ( ) instruction 3; ou bloc d’instructions ;
{ int n; }
do Exemple :
{ printf ("donner un nombre positif\n"); void main ( )
scanf ("%d",&n); { int i ;
} for (i=1 ;i<=3 ;i++)
while (n<=0); printf ("bonjour %d fois\n",i);
} }
 Ecrire un programme en langage C qui permet d’afficher les  Ecrire un programme qui calcule la somme, le produit et la
dix premiers nombres impairs. moyenne de N nombres entiers positifs saisis au clavier.
 En utilisant l’instruction itérative for;

 En utilisant l’instruction itérative do…while;
16
10/05/2021

 En utilisant l’instruction itérative for:  En utilisant l’instruction itérative do…while:
Ecrire un programme en langage C qui lit deux entiers Ecrire un programme en langage C qui permet de calculer et
entrés au clavier n et p (avec n<p) et permet d’afficher les d’afficher les sommes suivantes :
nombres de n à p, sauf les multiples de 3 et les multiples de 5.
 S=1+3+5+7……+N. (Avec N est un nombre entier impair)
 S=2+4+6………+N. (Avec N est un nombre entier pair)
 S=1+22+32+…+N2.
 S=1+1/2+1/3+……+1/N. (Avec N est un entier strictement
positif)
17
10/05/2021
Programme et Langage de Programmation Tableaux
 Ecrire un programme qui calcule la moyenne de En C, un tableau est une structure de données composée d’un
quatre notes saisies au clavier; nombre fixe d’éléments de même type (élément homogène);
 Les éléments d’un tableau sont indexés (Numérotés);
 Evoluer cet exercice afin de réponde à la question de N
Un tableau est désigné par un identificateur unique ;
notes, avec N est le nombre des notes saisi au clavier; 
Ce nombre devrait être déterminer lors de l’exécutions  Chaque élément est repéré par un "indice" précisant sa position au sein
( N<=50) de l'ensemble;
 Les éléments d’un tableau occupent dans la mémoire des zones
contiguës de même taille;
 Le nombre des indices correspond à la dimension du tableau:
 Pour un tableau simple on utilise un seul indice;
Tableaux Tableaux
 Déclaration d’un tableau simple:

 Pour un tableau de deux dimension, on utilise deux indices;
Type NomTableau[tailleTableau];
 Et ainsi de suite………..
 Exemple :
 Pour accéder aux éléments d’un tableau, il fallait donner le nom  int tab[10]; /*un tableau nommé tab qui contient 10 éléments de type
du tableau, suivi de l’indice de l’élément entre Crochets; entier(int) */
 Remarque Importante :  char tableau[10]; /* tableau contient 10 éléments de type entier(char) */
 Comme nous l’avons déjà vu, un tableau est repéré par son nom et
 L’indice du premier élément du tableau est 0. son indice. Alors on peut manipuler tous les éléments du tableau
 Un indice est toujours un entier positif qui est inférieur comme étant une simple variable.
strictement au nombre de ses éléments.  Exemple :
 Soit le tableau de 3 éléments nommé tab :
 int tab[3] ; /* déclaration du tableau tab */
18
10/05/2021
Tableaux Tableaux
 Donc, pour affecter la valeur de 12 au huitième élément du
 Remplir tous les éléments par la boucle for :
tableau, on écrit :
 tab[2]=12 ;
int tab[3]; int i ;
for(i=0 ;i<=2 ;i++){
 tab[2] est le troisième élément du tab .
tab[i]=i+1 ;
 Il existe plusieurs façons de remplir un tableau : }
 Affecter des valeurs aux éléments du tableau un par un:  Remarques importantes :
 tab[0]=10 ; tab[1]=40 ; tab[2]=0;  int tab[3]={1,2,3,4} ;
 Remplir tous les éléments du tableau au moment de la  Retourne une erreur car le nombre des valeurs de remplissage
déclaration: est strictement supérieur à la taille du tableau (=3).
 Un tableau tab de trois éléments :  int tab[3]={1,2,3} ; ou int tab[3]={3,4} ;
 int tab[3]={1,0,5};  Opération d’affectation correcte.
 Opération d’affectation correcte.
Tableaux Nom et adresse d’un Tableau
 int tab[]={1,2,3,4,20, 5} ;
 Déclaration et remplissage du tableau tab de taille 6.
 La taille du tableau dépend du nombre d’éléments affectés au
tableau;
 Remplir tous les éléments grâce à la boucle for et l’instruction Scanf :
int tab[3]; int i ;
for(i=0 ;i<=2 ;i++){
scanf ("%d", &tab[i]) ;
}
19
10/05/2021
Tableaux Tableaux
#include <stdio.h>
 Ecrire un programme en C qui calcule la moyenne des notes et le #define NbNot 10
nombre des notes supérieures à la moyenne calculée. main() { int i, nb =0;
float note [NbNot ], som, moy ;
 Ce programme devrait être structuré comme suite: printf ("donnez vos %d notes : ", NbNot ) ;
 Déclare une constante nommée NbNot qui détermine la taille du for ( i = 0 ; i< NbNot ; i++)
tableau; scanf ("%f", &note[i]) ;
som = 0. ;
 Déclare des variables ; for (i = 0 ; i< NbNot; i++)
 Saisir les notes (10 par exemple); som = som + note[i] ;
moy = som / NbNot ;
 Calculer la somme et la moyenne des notes; for (i = 0 ; i< NbNot; i++)
 Calculer le nombre des notes supérieures à la moyenne; if (note[i] > moy)
 Afficher la moyenne et le nombre des notes supérieures à la nb++ ;
printf ("moyenne = %f\n", moy) ;
moyenne;
printf ("il y a %d notes supérieures à cette moyenne", nb) ;
}
Mémoire: Bit, Octet et adresse Nom et adresse d’un Tableau

L’unité atomique d’information dans un ordinateur est le bit : En C, chaque case mémoire correspond à un octet et identifiée
 Bit : Il s’agit de la plus petite subdivision de la mémoire, qui a que deux par une adresse:
états : soit la valeur 0, soit la valeur 1.
 Octet : Séquence de 8 bits adjacents de la mémoire désignée par une  La déclaration d’une variable réserve un espace mémoire
adresse unique. identifié par une adresse;
 Adresse : Numéro entier unique indiquant la position d’un octet dans  Le type des variables précise le nombre de cases mémoire
la séquence d’octets constituant la mémoire de l’ordinateur. Elle sert à : nécessaire pour stocker une valeur d’une variable de type
• Localiser l’octet;
• Lire son contenu;
donné;
• Modifier son contenu;  Pour un tableau de type Char, chaque élément a besoin
Le schéma suivant illustre les notions de bit, octet et adresse : d’un octet pour stocker la valeur d’un tél élément;
 Ici, chaque élément est identifié par l’adresse d’une
case.
20
10/05/2021
Nom et adresse d’un Tableau Nom et adresse d’un Tableau

 La notation &tab[i] désigne l'adresse de cet élément tab[i] de même
Pour un tableau de type Int, chaque élément a besoin de 4 octet pour que &n désignait l'adresse de n.
stocker la valeur d’un tel élément:  Incrémentation et décrémentation d’un tableau:
 On a besoin de quatre cases pour créer un tél élément;  Tab++; //incorrecte
 Chaque élément est identifié par l’adresse de la première case  Tab+1; // équivalent de &(Tab[0] + sizeof(type) )// &Tab [1]
(octet) de chaque élément (élément = 4 octet);  Tab[0]++; //équivalent de Tab[0]+1
 Pour connaitre le nombre d’octets réservés pour un type donné  Tab[2]- -; //équivalent de Tab[2]-1
on utilise la fonction sizeof(type);  Remarque: attention au post/prè incrémentation/décrémentation
 Pour un tableau nommé Tab:  Exemple de déclaration des tableaux :
 Tab+1; donne la valeur de Tab[1], équivalent de Tab +
sizeof(type)
 Pour trouver l’adresse de nème élément, on utilise le symbole
suivant: &;
Tableaux Caractères
 Exécuter le programme suivant: 1ère adresse est:2293464 En langage C, char apparaît comme un cas particulier de int. Ce type
char permet de stocker des nombres signés compris entre -128 et 127, mais,
il est prévu pour stocker des lettres. Bien entendu, la mémoire ne peut
stocker que les nombres, d’où, il fallait faire une conversion entre les
nombres et les lettres.
 Pour cet intérêt, on doit utiliser un traducteur des lettres en nombres.
Effectivement, c’est le rôle de la table de code ASCII étendu. Ainsi, pour
obtenir cette conversion, il suffit d'écrire cette lettre entre apostrophes.
 char ch = 'A';=> stocke la valeur 65 dans la variable ch.
 Pour afficher le caractère, on doit utiliser le symbole %c :
printf("%c\n", ch);//affiche le caractère c;

 Pour afficher le nombre (code ASCII d’un caractère), on doit utiliser le
symbole %d :
printf("%d\n", ch); //affiche la valeur 65;
21
10/05/2021
Chaines de caractères Tableau de caractères
Une chaîne de caractères n'est rien d'autre qu'un tableau de type Un tableau de caractères est en fait une chaîne de caractères. Son
char. Ce tableau devrait contenir un caractère spécial à la fin ‘\0’. remplissage peut se faire de plusieurs façons :
 Chaine constante/ tableaux de caractères. :  char p1[10]={’B’,’o’,’n’,’j’,’o’,’u’,’r’} ;
 En C, une chaîne de n caractères occupe en mémoire un emplacement de  char p2[10]="Bonjour" ; /* Remplissage par une chaîne
n+1 octets. Ainsi, pour stocker un mot de dix lettres, il fallait déclarer un littérale */
tableau de type char et de taille onze tab[11].  char p3[ ]="Bonjour" ; /* p3 aura alors 8 éléments */
 Déclaration et initialisation:
 Affichage à l'écran d’une chaîne de caractères:
char ch[20] = { 'b','o','n','j','o','u','r','\0' } ;
 On peut utiliser la fonction printf et le format %s. Ici, il faut
donner l’adresse de la variable:

 char texte[10] = "Bonjour";
 printf("voici le texte: %s\n",texte);
 On utilisera si possible la fonction puts non formatée:
 puts(texte); est équivalent à printf("%s\n",texte);

Tableau de caractères Tableau de caractères

 Exemple :  Exécuter le programme suivant, puis, interpréter les résultats
#include <stdio.h> obtenus. On suppose que l’adresse du Tableau égale à 2293472:
int main()
{ char adrr[] = "bonjour" ;
printf ("%s \n", adrr) ;
printf ("%d\n", adrr) ;
puts(adrr);
return 0 ;}
 Saisie d’une chaîne de caractères:
 On peut utiliser la fonction scanf et le format %s pour des chaînes ne
comportant pas des espaces et sans écriture du symbole &.
 Syntaxe :
 char texte[10];
 printf("entrer un texte sans espace: ");  L’adresse du Tableau de type Char est, effectivement, l’adresse
 scanf("%s",texte); du premier élément de ce Tableau.
22
10/05/2021
Tableau de caractères Tableau de caractères

 Exécuter le programme suivant, puis, interpréter les résultats Pour manipuler les chaines de caractères, on peut utiliser de
obtenus. On suppose que l’adresse du Tableau égale à 2293456 préférence les fonctions non formatées gets et puts, pour la
: saisie et l’affichage d’un texte (ensemble des mots).
 Syntaxe :
 char texte[100];
 printf("entrer un texte: ");

 gets(texte);
 Remarque:
 A l'issue de la saisie d'une chaîne de caractères, le
compilateur ajoute toujours le caractère NULL ('\0') en

mémoire après le dernier caractère.
Tableau de caractères Pointeurs

 Ecrire un programme qui permet la saisie et l’affichage d’un texte Un pointeur est une variable spéciale qui peut contenir l'adresse d'une
(suite des mots ) (tableau à une dimension, gets et puts): autre variable;
 Saisir ce texte;
 Un pointeur est une variable qui a pour valeur l’adresse d’une autre
 Afficher ces mots;
variable.
 Un pointeur est une variable qui peut 'pointer' sur différentes adresses;
 Le nom d'une variable reste toujours lié à la même adresse;
Adresse
Valeur fixe Valeur dynamique
23
10/05/2021
Pointeurs Pointeurs
Pointeurs Pointeurs
La déclaration d’un pointeur permet la réservation uniquement d’un
emplacement pour que ce pointeur pointe sur une variable de type
donné. Elle ne réserve pas en plus un emplacement pour stoker les
valeurs d’une variable.
 Elle permet effectivement de réserver un emplacement
d’une adresse de type entier.
 En générale, on distingue deux types d’adressage:
 Adressage direct: Accès au contenu d'une variable par le nom
de la variable:
 Exp : int A=12 ;
 Adressage indirect: Accès au contenu d'une variable, en passant
par un pointeur qui contient l'adresse de la variable:
 Déclaration : Int *P ;
 Redimensionnement : p=&A ; // On dit : 'P pointe sur A'.
24
10/05/2021
Pointeurs Pointeurs
Opérateurs de base
Il existe deux opérateurs de base permettant de manipuler les
 Un tableau statique est un tableau dont toutes les lignes ont même
nombre de colonnes (même taille). pointeurs:
 opérateur d’adressage & : obtient l'adresse d'une variable.
 Un tableau dynamique est un tableau dont les lignes n’ont pas
 opérateur de contenu * : accède au contenu d'une adresse.
nécessairement même nombre de colonnes.
 Pour une variable int nombre:
 Un pointeur est une variable qui a pour valeur l’adresse d’une
autre variable.  nombre permet d'accéder à la valeur de la variable ;
 &nombre permet d'accéder à l'adresse de la variable.
 Un pointeur est une variable qui fournit l'adresse d'une
information quelconque.  Sur un pointeur int *pointeur:
 pointeur permet d'accéder à la valeur du pointeur, c'est-à-dire à l'adresse
 La taille d’un pointeur ne peut être connue que au moment
de la variable pointée ;
d’exécution;  *pointeur permet d'accéder à la valeur de la variable pointée.
 Les opérations ++ et -- s’appliquent aux pointeurs.  &pointeur donne l’adresse du pointeur lui même;
Pointeurs Pointeurs
Opérateur d’indirection *
Avant de manipuler un pointeur, et notamment de lui appliquer l’opérateur Exemples des pointeurs
d’indirection *, il faut l’initialiser. Sinon, par défaut et en général, la valeur du  char *pc;  pc est un pointeur pointant sur un objet de type char.
pointeur est égale à une constante qui vaut 0.
 int *pi;  pi est un pointeur pointant sur un objet de type int.
 L’opérateur *, mis en préfixe d’un nom de pointeur signifie : valeur de
la variable pointée ou, plus simplement, valeur pointée.  float *pr;  pr est un pointeur pointant sur un objet de type float.
 L'opérateur * désigne en fait le contenu de l'adresse.
 Remarques:
 Exmple 1:
 char *pc,i=34;  Pour un pointeur pointant sur un objet de type char, la valeur de ce
 pc = &i ;
pointeur donne l’adresse de l’octet où cet objet est stocké.
 printf("la valeur de la variable pointée est : %d\n",*pc);
 printf("le contenu du pointeur pc est : %d\n",pc);  Par contre, pour un pointeur pointant sur un objet de type int, la
 printf("l’adresse du pointeur pc est : %d\n",&pc);
valeur de ce pointeur donne l’adresse du premier octet des 4 octets
 printf("l’adresse de la variable i est : %d\n",&i);
où l’objet est stocké.
25
10/05/2021
Pointeurs Pointeurs
Exemple
 int a=1 ;
 int *pt ;  déclaration d’un pointeur sur un entier;
 pt=&a ;  pt pointe sur a ;
 *pt=12 ;  la variable pointée par pt reçoit 12;
 printf("a=%d \n",a) ;  affiche "a=12" .
 Remarque importante :
 Les deux variables *pt et a ont même valeur ainsi que la valeur de pt est
égale à l’adresse de &a.
 Type *p ,*q ; p=q est équivalente à *p=*q et les variables p et q pointent
sur la même adresse.
 Dans ces cas, on a initialisé un pointeur par l’affection d’une adresse
d’une autre variable.
Pointeurs Pointeurs
Opération sur les pointeurs
Supposant que j’ai déclaré un pointeur nommé P:
 La valeur de P est celle de &P[0].
 *P est équivalent à P[0].
 P++ est équivalent à &P[1] . Elle donne l’adresse de l’élément suivant;
 *P++ est équivalent à P[1]. Elle donne la valeur de l’élément suivant;
 (*P)++ est équivalent à *P +1=P[0]+1.
 P+i est équivalent à &P[i]. Elle donne l’adresse de l’élément d’indice i;
 *(P+i) est équivalent à P[i] . Elle donne la valeur de l’élément d’indice i;
 *P+i est équivalent à P[0]+i. Elle incrémente l’élément d’indice 0 par la
valeur i;
26
10/05/2021
Pointeurs Pointeurs
Opération sur les pointeurs Opération sur les pointeurs
 On suppose que l’adresse du Tableau égale à 2293508 , trouvez les résultats
d’exécution du programme suivant:
 Remarques:
 ad1++ : représente l'adresse de ad1
augmentée de un sizeof(int),
effectivement, il pointe sur l’élément
suivant;
 *(ad1++) : donne la valeur d’objet  Remarques:
suivant;  A++ ou bien *A++ expression invalide;
 Dans ce cas, le pointeur devient un tableau
et vice-versa;
Pointeurs Pointeurs
27
10/05/2021
Pointeurs Pointeurs
 Ecrire un programme qui :
 déclare un tableau de type Int initialisé avec quatre valeurs:
 Déclare un pointeur de type Int;
 Initialise ce pointeur par l’adresse du 1 er élément de ce tableau.
 Change le 2ème et le 3ème élément de ce tableau en utilisant le
pointeur;
 Affiche les éléments du tableau en utilisant le pointeur.
Pointeur et Tableaux à deux dimensions Pointeur et Tableaux à deux dimensions
Un tableau à deux dimensions est, par définition, un tableau des

tableaux. Effectivement, Il s'agit donc d'un pointeur vers des pointeurs :
int Tab[2][5];
 Tab donne l’adresse du tableau;
 Tab a une valeur constante égale à l'adresse du premier élément du
tableau, &tab[0][0].
 La 1ère dimension détermine le nombre des adresses;
 La 2ème dimension détermine le nombre des éléments propres à chaque
ligne;
 Tab est un pointeur, qui pointe vers un objet lui-même de type pointeur
d'entier (type int).
28
10/05/2021

 Également Tab[i], pour i entre 0 et 1, est un pointeur constant vers un objet Opération sur les Tableaux
de type entier, qui est le premier élément de la ligne d'indice i.  On suppose que l’adresse du Tableau égale à 6356676, trouvez les résultats
d’exécution du programme suivant:
 Tab[i] donne une valeur constante qui est égale à &tab[i][0].
 Exemple:
 Int Tab[2][5]={{1,1,2,3,34}, {1,12,2,3,34}};
 Tab; // donne l’adresse du tableau;
 Tab[0]; // donne l’adresse du 1er élément du tableau;
 &Tab[0][0]; donne l’adresse du 1er élément du tableau;
 Tab[0][0]; donne la valeur stockée dans le 1er élément du tableau;
 Tab[1]; // donne l’adresse du 6ème élément du tableau;
 &Tab[1][0]; donne l’adresse du 6ème élément du tableau;
 Tab[1][0]; donne la valeur stockée dans le 6ème élément du tableau;
La mémorisation des tableaux à deux dimensions s’effectue ligne par  Exemple:

ligne. D’où, nous pouvons traiter le tableau à deux dimensions Tab  int main() {int *Pr;
comme un pointeur Pr d’une dimension:
int Tab[2][5]={{1,1,2,3,34}, {44,12,2,3,34}};
Int *Pr=Tab;
Pr= Tab;}
 A condition que la dimension de pointeur se calcule comme suit:
 Pr; // donne l’adresse du tableau;
TaillePointeur= NombreLigne*NombreColonnes;  &Pr; // donne l’adresse du pointeur;
 int *Pr;  Pr+1; //donne l’adresse du 2ème élément du tableau;
 Pr+5; //donne l’adresse du 6ème élément du tableau;
int Tab[2][3]={{1, 1, 2}, {3, 4, 5}};
 Pr[5]; //donne la valeur stockée dans le 6ème élément du tableau;
 Pr= Tab; cette instruction donne un pointeur de 6 éléments
 *(Pr+5); //donne la valeur stockée dans le 6ème élément du tableau;
numérotés de 0 jusqu’à 5;
29
10/05/2021

Opération sur les pointeurs Opération sur les pointeurs
 On suppose que l’adresse du Tableau égale à 2293500 et l’adresse du pointeur égale à
2293512 , trouvez les résultats d’exécution du programme suivant:
Tableaux, Pointeurs et Chaines de caractères Tableaux, Pointeurs et Chaines de caractères

Différence entre un Pointeur et un Tableau
La différence entre un tableau de caractères et un pointeur vers une chaîne
Effectivement, il existe une grande différence entre un tableau et un constante:
pointeur, malgré, ils semblent identiques du point du vie utilisation. Ainsi, char Tab[]= "Bonjour";
nous traitons les deux déclarations suivantes: char *Ptr= "Bonjour";
 char chTab[] = "bonjour" ; Tab:
 char * chPoit = "bonjour" ;
 Ainsi, la variable chTab est tableau qui a exactement une taille pour stoker Ptr:
une chaine de caractère et le caractère indiquant la fin de la chaine \0; Adresse vers
 Ce tableau pointe toujours sur la même adresse en mémoire: on dit que
chTab est un pointeur constant; Affectation: char machaine[10];
 Par contre, chPoit est un pointeur qui pointe sur une chaine de caractère Tableau machaine = "Bonjour"; machaine est un pointeur constant;
stockée quelque part dans la mémoire(tas). D’où, nous pouvons changer la
valeur (adresse ) sur laquelle il pointe: Pointeur char p or *p; p = "Bonjour"; malgré, il s’agit d’une variable
 Char * chPoitt= " Bonsoir" ; chPoit = chPoitt; simple, mais, il se comporte comme un pointeur;
30
10/05/2021
Tableau de Pointeurs Processus

Les pointeurs permettent une allocation dynamique de la mémoire. C-à-d
que l’utilisateur a le possibilité de choisir la taille d’un tableau au moment Un processus est un programme en cours d'exécution qui est exécuté par un
d’exécution. microprocesseur. Aussi, plusieurs processus peuvent-ils être associés à un
 On dit Tableau dynamique ou bien Tableau des Pointeurs; programme. Chaque processus possède:
 Un tableau dynamique est un tableau dont les lignes n’ont pas nécessairement de même  Un espace de travail en mémoire;
nombre de colonnes (même taille).  Un compteur ordinal;
Six lignes, est chaque ligne
Nous avons six  Des registres….
se compose d’un nombre
adresses vers six
des casés mémoires
lignes,
Rq: deux adresses
différentes, qui contiennent Ainsi, un processus est un programme qui
des caractères. Egalement, s'exécute et qui possède son propre espace
ne pointent pas sur
nous avons une ligne vide. mémoire, ses registres, ses piles, ses variables
la mêmes ligne.
et son propre processeur virtuel.
 La question qui se pose, en C, comment réalisons-nous cette
réservation dynamique de la mémoire pour manipuler les pointeurs?
Processus Processus
Programme Mémoire Classes de mémorisation
Nous pouvons classer la mémoire allouée à un programme C en 3 parties :

 Segment de données : variables globales ;
 Pile : variables locales ;
 Tas : allocation dynamique.
 La Pile : elle garde la trace d’exécution de fonctions (fonctions appelantes ou
bien appelées), les variables échangées et les variables locales;
 Le Tas (Malloc) : c’est une Zone de mémoire dynamique (créer des variables
durant l’exécution, allocation dynamique de mémoire).
 La partie données: elle est réservée pour le stockage des variables globales et les
données statiques (Constantes);
 Le code: il contient le texte exécutable (instructions) de votre programme.
31
10/05/2021
Processus Allocation dynamique de la mémoire

Exemple d’un programme en ASM
La déclare d’une variable se traduit par un demande d’allocation de
Donnees segment ; déclaration d'un segment de données où on va déclarer les variables
x dw 175; 1 word (16 bits) (Declare Word) la mémoire:
y dw 150 int monNombre = 0;
z dw ?
Donnees ends ; fin de la déclaration  Le programme arrive à une ligne comme celle-ci, il se passe en fait
Code segment ; déclaration du segment de code qui va contenir le code du programme les étapes suivantes:
Assume cs:Code, ds:Donnees, rendre visible toutes les variables contenues dans un
 Votre programme demande au système d'exploitation (Windows, Linux, Mac
segment.
OS…) la permission d'utiliser un peu de mémoire ;
Entree: ; entrée de code
mov ax, x ; on utilise ax parce que x = word = 16 bits  Le SE lui donne l'adresse qu'il lui a réservée;
add ax, y
mov z, ax  Lorsque le programme est terminée, la variable est automatiquement
Code ends; Fin de code supprimée de la mémoire.
End Entree; Fin d'entrée
Allocation dynamique de la mémoire Allocation dynamique de la mémoire

L’Allocation dynamique est une opération qui consiste à réserver un espace
mémoire pour stocker l’objet pointé. Cette opération d’allouer et désallouer la  La Pile est un espace mémoire réservé au stockage des variables désallouées
mémoire sur le Tas se fait: automatiquement.
 En C, grâce aux fonctions malloc(), calloc() et free().  Le Tas est un segment de mémoire utilisé lors de l’allocation dynamique de
 En C++ , grâce aux fonctions new() et delete(); mémoire durant l’exécution d’un programme informatique.
Les En C/C++, la mémoire stocke les variables en deux segments de mémoire  Rq: La taille du Tas est souvent considère illimitée, plutôt, elle est en réalité
différentes selon le type d’allocation: limitée.
 La Pile (stack): allocation automatiques, créées en pile et détruites au fur et à
mesure de l'exécution des fonctions;  Lors de l'exécution d'un programme:
 Le Tas (Heap): allocation dynamique de mémoire durant l'exécution d'un  Le Tas alloue dynamiquement de l'espace mémoire à la demande du programme
programme informatique; (malloc);
Lors de l'exécution d'un programme, le Tas est utilisé pour allouer dynamiquement  Par opposition, dans la Pile qui fait automatiquement lors d'un appel de fonction. .
de l'espace mémoire à la demande du programme, plutôt, l'allocation dynamique sur
la pile qui se fait automatiquement lors d'un appel d’une fonction (échange des valeurs).
32
10/05/2021

Remarques importantes Fonction malloc()
La déclaration d’un pointeur devrait toujours être suivi par une initialisation par
La fonction malloc() renvoie l’adresse d’un bloc de mémoire de N
la valeur NULL, également, lors de la désallocation afin de vérifier si l’allocation
a marché ou bien échoué: octets libres (ou la valeur 0 s’il n’y a pas assez de mémoire).
 int* Ptr= NULL; Ptr= malloc(N*sizeof(*Ptr)); p= malloc(Taille* sizeof(**…Ptr)) ;
 if (Ptr== NULL) { exit(0); // On arrête immédiatement le programme  p= malloc(N) : Renvoie l’adresse d’un bloc de mémoire de N
 }// Sinon continuer (entier positif) octets libres (ou la valeur 0 s’il n’y a pas assez de
 L’allocation d’une nouvelle zone mémoire se fait dans le Tas; mémoire);
La mémoire allouée dans le tas doit être désallouée explicitement par la fonction

free().
 Elle retourne un pointeur p de type char (par défaut) pointant
 Si vous voulez redimensionner un espace mémoire alloué dynamiquement, il faut
vers un objet de taille N octets.
utiliser la fonction realloc().  Exemple :
 Pour utiliser les fonctions malloc(), sizeof(), calloc() et free(), il faut inclure la  int *p;
bibliothèque <stdlib.h> en début de programme.  p = malloc(800);

Fonction sizeof() Fonction free()
La fonction sizeof attend comme argument un type et il renvoie le nombre
Cette fonction indique au SE que l'on n'a plus besoin de la mémoire qu'on
d'octets nécessaire pour le coder dans la mémoire, c'est-à-dire la taille d'un
avait demandée. La place en mémoire est libérée, un autre programme peut
réceptacle de ce type.
maintenant s'en servir au besoin.
 Syntaxe:  Syntaxe:
sizeof (type);
void free(adresse du pointeur);
 Elle fournit la taille pour un objet du type (type);
printf("char : %d octets\n", sizeof(char));  La fonction free a juste besoin de l'adresse mémoire à libérer
printf("int : %d octets\n", sizeof(int));  Pour utiliser cette fonction, il faut inclure la bibliothèque <stdlib.h> en début
printf("double : %d octets\n", sizeof(double));
printf("Pointeur vers entier: %d octets\n ",sizeof(int *));
de programme.
printf("Pointeur vers reel: %d octets\n ",sizeof(double *));  Exemple :
 int *p ;
Rq: la taille d'une donnée de type « pointeur
 p=malloc(10*sizeof(*p)) ;
vers » est identique (4 octets) quel que soit le
 free(p); on libère l’espace réservé pour le pointeur p .
type simple pointé.
33
10/05/2021
Tableau de Pointeurs Tableau de Pointeurs

Lignes de même taille Lignes de taille variable
Un Tableau des Pointeurs est un tableau dont les lignes n’ont pas  Pour N un entier fixe et M variable:
nécessairement de même nombre de colonnes (même taille).  N : le nombre des lignes;
 Déclaration d’un tableau des pointeurs:  M : le Nombre de colonnes:

Type *Nom_pointeur[taille_tableau] ;  for (i=0 ; i<N; i++)
 Nom_pointeur est un tableau de taille_tableau pointeurs;
{
 taille_tableau est le nombre des adresses générées pour pointer sur les lignes
du tableau; printf(“entrer la valeur de M”);
 Initialisation d’un tableau de pointeurs : scanf("%d",& M) ;
 Pour M et N deux entiers fixés :
Nom_pointeur [i] = malloc(M*sizeof(** Nom_pointeur)) ;
 Nom_pointeur = malloc(N*sizeof(*Nom_pointeur)) ; }
 for (i=0 ; i<N ; i++) {
 La valeur de M, pour chaque itération, est le nombre de colonnes de
 Nom_pointeur [i] = malloc(M*sizeof(** Nom_pointeur )) ;
chaque ligne nom_pointeur[i].
 }

Exemple  Remplissage d’un tableau de pointeurs :
Trouver les résultats d’exécution de ce programme:  Pour chaque nom_pointeur [i][j], on l’affecte une valeur.
 Ecrire un programme qui remplit les éléments d’un tableau de 4 pointeurs par
10*i+j, avec i et j indice de la ligne et de colonne respectivement;
34
10/05/2021
35
10/05/2021
Tableau de Pointeurs Allocation dynamique de la mémoire

Fonction calloc()
La fonction calloc() a le même rôle que la fonction malloc() mais elle
initialise en plus l’objet pointé à zéros.
 Syntaxes :
p= calloc(Nombre d’objets, taille d’objet) ;
 Exemple :
 int *p, *q ;
 p= calloc(100, sizeof(*p)) ;
 Elle fournit, s’il est possible, l’adresse d’un bloc de 100*sizeof(*p)
octets libres (initialisé à 0) ou 0 octets s’il n’y a pas assez de mémoire .
 q= malloc(100*sizeof(*q)) ;
 Elle fournit, s’il est possible, l’adresse d’un bloc de 100*sizeof(*q)
octets libres ou 0 octets s’il n’y a pas assez de mémoire .
36
10/05/2021

Initialisation d’un pointeur Initialisation d’un pointeur
Pour un tableau à une dimension, on veut réserver des espaces mémoires
Pour initialiser des pointeurs vers des objets qui ne sont pas de pour un tableau de N entiers, où N est lu au clavier :
type char, il faut convertir le type de la sortie de la fonction  int N ;int *tab ;
malloc() ou de la fonction calloc() à l’aide d’un cast.  printf(« Choisir la taille du tableau :\n") ;
 Syntaxes :  scanf("%d", &N) ;
 Type *p ;  tab = (int *)malloc(N*sizeof(int)) ;// tab=malloc(N*sizeof(*tab)) ;
 P=(type *)malloc(N*sizeof(type)) ; // P=malloc(N*sizeof(*NomP)) ;  tab = (int *)calloc(N,sizeof(int)) ; // tab=calloc(N, sizeof(*tab)) ;
 P=(type *)calloc(N, sizeof(type)) ; // P=calloc(N, sizeof(*NomP)) ;  La fonction malloc renvoie juste l’adresse de début d’un bloc de N fois
 Avec N un entier prédéfini (N est entier fixe). sizeof(int).
 La fonction calloc renvoie l’adresse de début d’un bloc de N fois
sizeof(int) et tab[i]=0 pour tout i=0 à N-1.

Initialisation d’un pointeur Initialisation d’un pointeur
 Opérations dans les pointeurs:
 tab contient alors l’adresse de début d’un bloc de N entiers: #include <stdio.h>
 Dans ce cas tab ≡ &tab[0] et *tab ≡ tab[0]. #include <stdlib.h>
 Le (int *) devant le malloc est un cast qui a pour objectif de int main(void){ int i,n,*P;
préciser le type de données sur lesquelles tab va pointer. printf("Veuillez entrer la taille de votre pointeur.\n");
 On accède à la ième valeur du tableau dynamique par tab[i]. scanf("%d",&n);
P= (int *)calloc(n, sizeof(int)); //P= calloc(n, sizeof(*P));
 Le nom d’un pointeur, dans ce cas, est un identificateur dynamique
printf("la valeur stocker dans p est %d.\n", P);
d’un tableau.
printf("la valeur sur laquel il pointe p est %d.\n", *P);
for(i=0; i<n; i++){
scanf("%d",&P[i]);}
printf("la valeur stocker dans p est %d.\n", P);
37
10/05/2021
Allocation dynamique de la mémoire Pointeurs des pointeurs

Initialisation d’un pointeur Dans le cas de l’allocation dynamique de mémoire, comme on ne connaît
pas les dimensions du tableau dont on aura besoin, on déclare donc un pointeur
printf("la valeur sur laquel il pointe p est %d.\n", *P); de pointeurs, puis on manipule les éléments de pointeur comme ceux d’un
printf("la valeur de P[0] est %d.\n", P[0]); tableau "normal".
printf("la valeur sur laquel il pointe p++ est %d.\n", *P++);  Déclaration d’un pointeur des pointeurs :
Type **nom_pointeur;
printf("la valeur de P[1] est %d.\n", P[1]);
 Redimensionnement d’un pointeur des pointeurs :
for(i=0; i<n; i++){
 Pour M et N deux entiers fixés :
printf("la valeur stocker dans p+i est %d.\n", P+i);
Int **Ptr;
printf("la valeur sur laquel il pointe p+i est %d.\n", *(P+i));
scanf("%d",&N) ;
printf("la valeur de P[%d] est %d.\n",i, P[i]);
Ptr = (Int **)malloc(N *sizeof(Int *)) ;
} for (i=0 ; i<N ; i++){
return 0; Ptr[i] = (Int *)malloc(M*sizeof(Int )) ;
} }
Pointeurs des pointeurs Pointeurs des pointeurs

 Exemple : Pour M et N deux entiers fixes;
 Pour N un entier fixé et M variable:
Int **Ptr;
scanf("%d",&N) ;
Ptr = (Int **)malloc(N*sizeof(Int *)) ;
for (i=0 ; i<taille ; i++){
printf(“Entrer le nombre de colonnes de la Ieme ligne M”);
scanf("%d",&M) ;
Ptr[i] = (Int *)malloc(M*sizeof(Int)) ;
}
 La valeur de M, pour chaque itération, est le nombre de colonnes de
chaque ligne Ptr[i].
 Remplissage des pointeurs de pointeurs :
 Pour chaque Ptr[i][j] on l’affecte une valeur.
38
10/05/2021
Pointeurs des pointeurs Pointeurs des pointeurs

 Exemple : Pour N un entier fixé et M variable;
 Ecrire un programme qui crée un pointeur des pointeurs de

type Int.
 Déterminer le nombre de lignes de pointeur;
 Déterminer le nombre de colonnes de chaque ligne de

pointeur;
 Remplir et afficher les éléments de ce pointeur;
 Libérer ce pointeur;
Pointeurs des pointeurs Tableaux, Pointeurs et Chaines de caractères
Une chaîne de caractères est un tableau de caractères se terminant par

le caractère spécial ’\0’ ;
 On peut déclarer une chaîne de caractères comme n’importe quel
tableau, mais en prévoyant une place pour le ’\0’ final :
 Version d’allocation statique :
char chaine[100];
 Version d’allocation dynamique :
 char *chaine; → déclaration d’un pointeur de type char;

 int n = 100; → variable n;
 chaine = (char*)calloc(n, sizeof(char)); → Redimensionnement
d’un pointeur;
39
10/05/2021
Tableau de pointeurs sur des chaines Tableau de pointeurs sur des chaines
 Déclaration d’un tableau des pointeurs: Tableau de Tableaux Dynamiques ≡ Tableaux de chaînes de caractères:
char * jour[10] ; → 10 est le nombre d’adresses.
 Déclaration et initialisation d’un tableau des pointeurs : L’adresse qui jour[0]
“Lundi”
char * jour[10] = { " Lundi", " ",… "", "" } ; 1ère ligne
pointe sur la jour[1] “Mardi”
 Exercice : 1ère ligne
 Écrire un programme qui affiche un jour de la semaine en se basant sur un jour[2]
“Mercredi”
numéro saisi au clavier entre 1 et 7.
#include <stdio.h>
int main()
{char * jour[7] = { "lundi", "mardi", "mercredi",
"jeudi","vendredi", "samedi", "dimanche" } ; 7 mots(jours) de longueur maximale
int i ; inconnue
printf ("donnez un entier entre 1 et 7 : ") ;
scanf ("%d", &i) ;
printf ("le jour numéro %d de la semaine est %s", i, jour[i-1] ) ;
jour[6] “Dimanche”
return 0;}
Tableau de chaines de caractères Fonctions sur les chaines

En réalité une chaine de caractères est un tableau de caractères. Nous Fonction sur les Chaînes
traitons de cette partie le cas d’un tableau de chaines de caractères. Plus
précisément, nous réservons cette partie pour la gestion dynamique des chaines Pour manipuler les fonctions sur les chaines de caractères, on doit inclure la
de caractères. bibliothèque <string.h> en début de programme:
 Le but est de réserver des espaces mémoires dynamiques pour la gestion de  strlen: donne la longueur d’une chaine;
N chaines de caractères qui ont pas nécessairement de même taille.  strcmp: compare deux chaines;
 Pour cet intérêt, nous devons déclarer des pointeurs sur des chaines de  strcpy: copie une chaine dans une ligne (buffer) des caractères;
caractères:  strcat: concaténation de deux chaines;
Char **ListChaine;  strchr: recherche d’un caractère dans une chaine;
 strstr: recherche d’une sous-chaine dans une chaine;
 Cette déclaration nous octroie un pointeur vers des
 strncpy, strncat: versions limitées à n caractères
pointeurs sur des chaines de caractères. Cette
situation est simulée comme suite:
40
10/05/2021
Fonctions sur les chaines Fonctions sur les chaines

Fonction sur les Chaînes Fonction sur les Chaînes
La fonction strcpy copie une chaîne dans une autre. C’est La fonction strcat concatène deux chaînes de caractères, c’est-à-dire qu’elle
l’équivalent d’une affectation pour les chaînes de caractères. Le les met bout à bout l’une à la suite de l’autre dans une même chaîne.
char* strcat(char* s1, char* s2);
prototype de la fonction strcpy est le suivant :
 Exemple :
char* strcpy(char* destin, char*source); #include <stdio.h>
 La fonction copie la chaîne source dans destin. La chaîne destin #include <string.h>
doit avoir été préalablement allouée. La fonction retourne destin. int main(void) { char chaine[100], mot1[50], mot2[51];
puts("Veuillez saisir un mot (au plus 49 lettres)");
 Exemple: scanf("%s", mot1);
 char s1[50], *s2; puts("Veuillez saisir un autre mot (au plus 50 lettres)");
 strcpy(s1, "Ceci est une chaîne"); scanf("%s", mot2);
 s2 = s1; → affectation d’adresse; strcpy(chaine, mot1); → on copie mot1 dans chaine ;
 Remarque: la chaine s1 n’est pas recopiée et les deux chaînes s1 et strcat(chaine, mot2); → on met mot2 à la suite de la chaine;
s2 pointent sur la même zone mémoire (affectation d’adresse). printf("Les deux mots saisis sont %s", chaine);
return 0;}
Fonctions sur les chaines Fonctions sur les chaines

Le fonction strcmp permet de comparer deux chaînes pour l’ordre
alphabétique. if (strcmp(mot1, mot2)==0)
int strcmp(char* s1, char *s2); puts("les deux mots sont égaux");
 Le résultat est < 0 si s1 < s2, égal à 0 si les caractères de s1 sont les if (strcmp(mot1, mot2) < 0)
mêmes que les caractères de s2, et il est > 0 si s1 > s2. printf("%s vient avant %s dans l’ordre alphabétique", mot1, mot2);
 Exemple : if (strcmp(mot1, mot2) > 0)
#include <stdio.h>
printf("%s vient après %s dans l’ordre alphabétique", mot1, mot2);
#include <string.h>
return 0;
int main(void) { char mot1[50], mot2[50];
}
puts("Veuillez saisir un mot (au plus 49 lettres)");
scanf("%s", mot1);
puts("Veuillez saisir autre mot (au plus 49 lettres)");
scanf("%s", mot2);
41
10/05/2021
Fonctions sur les chaines Tableau de chaines de caractères

La fonction strlen retourne la longueur d’une chaîne de caractères,
c’est-à-dire son nombre de caractères (sans compter le ’\0’). Cette
fonction prend en paramètre la chaîne de caractères.
 size_chaine strlen(char* s);
 strlen(″un message″ ) ; Ou bien
 La fonction strchr recherche, dans chaîne, la première position où

apparaît le caractère mentionné:
strchr ( chaîne, caractère );
 La fonction strstr recherche, dans chaîne, la première occurrence
complète de la sous-chaîne mentionnée:
strstr ( chaîne, sous-chaîne );
Fonctions Fonctions
Un programme en langage C est constitué d’un ensemble de fonctions toutes Déclaration d’une fonction avec arguments: Ou bien la définition de la
accessibles à partir d’une fonction principale appelée main(). signature d’une fonction:
 Syntaxe :
 Ces fonctions permettent d’exécuter, dans plusieurs parties du programme, Type nomFonction(type1, Type2,…,TypeN);
un ensemble d’instructions par un simple appel dans le corps du  Ou bien :
programme principal. Void nomFonction(type1, Type2,…,TypeN);
 La conception d’une fonction se fait en général par trois phases :  Exemple :
 Déclaration d’une fonction ou bien signature d’une fonction.  int somme(int, int, int) ;
 float racine(int ) ;
 Définition de cette fonction.  int prod(int *, char *) ;
 Appel à cette fonction.  void somme(int, int, int) ;
 void racine(int ) ;
 void prod(int *, char *) ;
42
10/05/2021
Fonctions Fonctions
Déclaration d’une fonction sans arguments:
 Définition d’une fonction sans retourne:
 Syntaxe :
Type nom_function(type1 arg1,...,typeN argN) {
Type nomFonction(); Ou bien Void nomFonction(); Déclaration des variables locales si nécessaire
 Exemple : Instructions;
int som() ; float raci() ; void som() ; void raci() ; return 0 }
 Définition d’une fonction avec retourne:
 Remarque :
Type nom_function(type1 arg1,...,typeN argN) {
 Le type void précise que la fonction ne renvoie (retourne) aucune valeur et Déclaration des variables locales si nécessaire
équivalent à return() ; ou return 0;. Autrement dit, il faut donc appeler la Les instructions;
fonction d’affichage « printf() » si on a besoin d’affichage. return (la sortie de cette fonction);
 C’est mieux de définir et de déclarer une fonction à l’extérieur de la fonction }
principale main().  Remarque : le type de l'expression figurant dans return peut être différent du
 L’appel d’une fonction se fait toujours à l’intérieur de la fonction principale type du résultat tel qu'il a été déclaré dans l'en-tête, ici, le compilateur se chargera
main(). automatiquement de l’opération de conversion.
Fonctions Fonctions
 Appel d’une fonction avec arguments

 Syntaxe :
 nom_function(arg1,...,argN);
 Exemple :
 Somme(a,b) ;
 Appel d’une fonction sans argument

 Syntaxe :
 nom_function();
 Exemple :
 produit() ;
43
10/05/2021
Fonctions Fonctions
En C, on a deux méthodes pour déclarer, définir et appeler une  Déclaration et définition de la fonction avant la fonction
fonction: principale main();
 Exemple:
 Déclaration et définition de la fonction avant la fonction
 #include <stdio.h>
principale main();
int add(int x, int y){//Déclaration et définition d’une fonction
 Déclaration au sein (ou avant) de la fonction principale, par int resultat = x + y;
contre, la définition de la fonction à ce moment doit être après la return resultat;
fonction principale main(); }
 int main(){
 L’appel d’une fonction est toujours à l’intérieur de la fonction
int a = 4;
principale main(); int b = 5;
int c = add(a,b); //appel d’une fonction
return 0;
}
Fonctions Fonctions
Déclaration au sein (ou avant) de la fonction principale, par contre, la Passage de paramètre par Valeur
définition de la fonction à ce moment doit être après la fonction principale main();
 Exemple: Dans cette situation, la fonction ne peut pas modifier le contenu de la
variable recopiée. Effectivement, elle travaille sur une copie de la variable.
D’où, la modification de la copie n’entraîne pas une modification de la variable
int add(int , int ); //signature d’une fonction (porté globale)
originale.
 int main(){
int add(int , int ); //signature d’une fonction (porté locale)  Exemple:
int a = 4, int b = 5;  #include <stdio.h> int main(){
int c = add(a,b); //appel d’une fonction int add(int x, int y){ int a = 4;
return 0;} int resultat = x + y;
int b = 5;
 int add(int x, int y){//Définition d’une fonction int c = add(a,b);
return resultat; return 0;
int resultat = x + y;
} }
return resultat;}
44
10/05/2021
Fonctions Fonctions
Fonctions Fonctions
#include <stdio.h>
int add(int x, int y){
int a = 3;
int b = 7;
int c = a + b;
int resultat = x + y; int main(){
return resultat; int a = 4;
} int b = 5;
int c = add(a,b);
return 0;
}
45
10/05/2021
Fonctions Fonctions
 Attention?? C n’autorise pas le non respect du type des arguments
lors d’un appel à une fonction: le compilateur n’opère pas alors une
conversion de type.
Fonctions Fonctions
Passage de paramètre par adresse
Pour modifier une variable par un appel de fonction, il faut passer en
paramètre une adresse (pointeur) qui pointe sur cette variable. Ainsi, on
travaille sur l’emplacement mémoire de la variable au lieu de son contenu.
 Exemple: La fonction suivante prend en paramètre un pointeur :
 void Modifie(int *p) {
*p = *p+1; →p pointe sur x, la copie de p aussi le x du main est modifie ;
}
 int main(void) {int *p, x=1; → la variable x n’est pas un pointeur ;
p = &x; → pointeur qui pointe sur x ;
Modifie(p);
printf("%d", x); → affiche 2 ;
return 0;}
 Le pointeur p et sa copie pointent tous les deux sur la variable x de la
fonction principale main.
46
10/05/2021
Fonctions Fonctions
Problème d'inversion
 Le passage par valeur n’a aucun influence sur arguments effectifs
ainsi:
 La fonction Inverser() reçoit deux valeurs correspondant à ses deux
arguments muets a et b.
 Elle effectue un échange de ces deux valeurs. Mais, lorsque l'on est
revenu dans le programme principal, aucune trace de cet échange ne
subsiste sur les arguments effectifs a et b.
 Exemple:
#include <stdio.h>
void Inverser(int a, int b){ int main(){
int tmp = a; int a = 1, b = 9;
a = b; Inverser(a,b);
b = tmp;} return 0;}
Fonctions Fonctions
Problème d'inversion Problème d'inversion
 La solution est :???
 Le passage par adresse qui s’influence sur arguments effectifs ainsi:
#include <stdio.h>
void inverser(int * a, int * b){
int tmp = * a;
* a = * b;
* b = tmp;
}
int main(){
int a = 1, int b = 9;
inverser(&a,&b);
return 0;
}
47
10/05/2021
Fonctions et Pointeurs Fonctions et Pointeurs
 Ecrire une fonction nommée Ecarte() qui prends en argument deux

pointeurs de type double. Cette fonction ajoute au premier
paramètre la valeur 1.5 et soustraite du deuxième paramètre la
valeur 1.5.
 Puis, on doit écrire une fonction main() structurée comme suite:
 Déclare deux variables a et b de type double initialisée avec la valeur 4;
 Déclare deux pointeurs Pa et Pb de type double;
 Pointer ces deux pointeurs sur les variables a et b;
 Appeler la fonction Ecarte();
 Afficher les valeurs de variables a et b, conclure ???

 Écrire une fonction qui calcule le quotient et le reste de la division  Écrire une fonction qui calcule la somme et le produit des éléments d’un
d’un entier p par un entier q. Écrire le programme principal qui tableau passé en paramètre. Écrire le programme principal qui initialise le
appelle cette fonction et affiche les résultats. tableau par saisie ; calcule et affiche la somme et le produit des éléments.
48
10/05/2021

Introduction sur les fonction et les pointeur comme arguments:
#include <stdio.h>
void ajouteTrois(int * a){
* a = * a + 3;
printf("dans ajouteTrois a: %d\n", * a);
}
int main(){
int a = 5;
ajouteTrois(&a);
printf("dans main a: %d\n",a);
return 0;
}
49
10/05/2021
Structures Structures
 Exemple1: un employé peut être décrit par:

Une structure est un type qui permet de stocker plusieurs données,
de même type ou de types différents, dans une même variable de type  Identifiant
structure.  Nom,
 Une structure est une collection d'une ou plusieurs variables,  Prénom.

généralement, ayant des types différents.
 Salaire.
 Les variables d'une structure sont groupées sous un seul nom.
 Le Nom peut être aussi décrit par une structure. Autrement dit,
 Les structures permettent d'organiser les données compliquées. Les
un champ d’un structure peut aussi être de type structure.
variables liées sont groupes en seule entité au lieu des entités
séparées.  Exemple 2: un point est une paire de coordonnées, un
rectangle est une paire de points, ...etc.
50
10/05/2021
Définition d’une structure Définition d’une structure
Le langage C permet au programmeur de construire ses propres  Exemple: un point d'un plan 2-D est caractérisé par ses
types de données. coordonnées x et y. Supposant que les coordonnées sont des
 Pour cela, le programmeur doit préciser: entiers, la structure décrivant un point est déclarée en C par:
 le nom donné au type; struct point{
 la composition du type, c'est-à-dire le nom et la nature des int x;
données qu'il contient. int y;
 La syntaxe de définition d'un type est: };
struct nom_structure{  Attention: le mot-clé struct fait partie intégrante du nom du
type1 var1; type.
type2 var2;
 Le mot-clé struct introduit la déclaration de la structure, qui
...
}; est une liste de déclarations placées entre { et }
Le mot-clé « struct » peut être suivi d'un nom qu'on souhaite attribuer Voyez tout d'abord cette déclaration :
à la structure. Dans ce cas, nous désignons ce modèle défini : point. struct Produit
{ int numero ;
 Ce nom sera utilisé par la suite pour se référer à la structure
int qte ;
(déclaration des variables de ce type). float prix ;
 Les variables nommées dans la structure sont appelées les membres };
ou champs de la structure. Une fois un tel modèle défini, nous pouvons déclarer des "variables
structurées " du type correspondant:
 La déclaration d'une structure définit un nouveau type.
struct Produit Pdt1 ;
 « struct point » constitue le nouveau type ou bien le modèle sur Cette déclaration réserve un emplacement nommé Pdt1 "de type Produit "
lequel on va baser pour créer les variables structurées (objets) . destiné à contenir deux entiers et un flottant.
De manière semblable :
struct Produit Pdt1 , Pdt2;
Elle réserverait deux emplacements Pdt1 et Pdt2 du type Produit.
51
10/05/2021
Il est recommandé de regrouper la définition du modèle de structure et la scanf ("%f", &Pdt2.prix) ; → lit, suivant le code format %d, une valeur qui sera
déclaration du type des variables dans une seule instruction comme dans cet affectée au champ prix de la structure Pdt2.
exemple : Pdt1.numero++; → incrémente de 1 la valeur du champ numero de la structure
struct Produit{ int numero ; Pdt1.
int qte ; Il est possible d'affecter à une structure le contenu d'une structure définie à partir du
float prix ; même modèle:
} Pdt1 , Pdt2; Pdt1=Pdt2;
La désignation d'un champ se note en faisant suivre le nom de la Notez bien qu'une affectation globale n'est possible que si les structures ont été
variable structure de l'opérateur "point" (.) suivi du nom de champ tel définies avec le même nom de modèle:
qu'il a été défini dans le modèle:  Pdt1.numero = Pdt2.numero ;
Pdt1.numero = 15 ; → affecte la valeur 15 au champ numero de la  Pdt1.qte = Pdt2.qte ;
structure Pdt1.  Pdt1.prix = Pdt2.prix ;
On peut initialiser notre structure Pdt1, au moment de sa déclaration :
printf ("%f", Pdt1.prix) ; → affiche, suivant le code format %d, la
 struct Produit Pdt1 = { 100, 285, 2000 } ;
valeur du champ prix de la structure pdt1.
Tableau des Structures Tableau des Structures
Tableaux de structures:
Lorsqu’on déclare un tableau des structures, effectivement, on crée un tableau
Voyez ces déclarations :
de N éléments structurés :
struct Produit Pdt[20]; struct point { char nom ;
Ici, nous avons créé 20 éléments structurés. Plus précisément, nous avons créer int x ;
20 adresses qui pointent sur 20 éléments structurés. int y ;
};
struct point courbe [50] ;
La structure point pourrait, par exemple, servir à représenter un point d'un
plan, point qui serait défini par son nom (caractère) et ses deux
coordonnées.
La notation : courbe[i].x
désigne la valeur du champ x de l'élément de rang i du tableau courbe.
Tableau des structures
52
10/05/2021
Structures imbriquées Allocation dynamique des Structures
Par ailleurs : L’allocation dynamique de variables structurées est utile pour optimiser leur
courbe[4] taille en fonction de besoins qui ne sont souvent connus qu’à l’exécution:
typedef struct
→ représente la structure de type point correspondant au cinquième { char nom[20];
(adresse) élément du tableau courbe. char Prenom[20];
float note;
} Etudiant ;
Voici un exemple d'initialisation:
void main(void)
struct point courbe[50]= { {'A', 10, 25}, {'M', 12, 28},{'P', 18,2} } { Etudiant * ListeEtudiant ; /* pointeur pour le TABLEAU de structures */
int i, nb_etud = 0 ;
printf("Tapez le nombre d'étudiants :");
scanf("%d", &nb_etud );
Allocation dynamique des Structures Déclarations
Allocation d'un tableau de structures : Différentes façons permettant de déclarer des variables d'une structure.
ListeEtudiant = (Etudiant *) malloc( nb_etud * sizeof(Etudiant ) );
struct point{
if (ListeEtudiant==NULL) int x;  p1, p2, p3, p4, p5 sont des variables
{ int y;
globales initialisées automatiquement à
printf("\n Allocation dynamique impossible !"); } p1, p2, p3 ;
0.
exit(1) ; // on quitte le programme struct point p4, p5;
main(){ p1, p2, p3 ont été déclarées avec la
} struct point p6;

Utilisation de la variable : via un pointeur uniquement */ printf("%d %d\n",p1.x, p1.y);

définition de la structure.
ListeEtudiant -> nom ="est" ; printf("%d %d\n",p4.x, p4.y);  p4, p5, p6 déclarées en utilisant le nom
Utilisation du tableau : comme tous les tableaux "normaux" */ printf("%d %d\n",p6.x, p6.y); du nouveau type.
}
for (i=0 ; i<nb_etud ; i++)  p6 est une variable locale initialisée
ListeEtudiant[i].note = 18 ; aléatoirement.
Liberation memoire :
free(ListeEtudiant);
} 09/05/2021 Prof. ASIMI Younes 211 09/05/2021 Prof. ASIMI Younes 212
53
10/05/2021
Déclarations Nouveaux types: typedef
struct {
int x;  Le nom du nouveau type non  Le langage C permet de créer de nouveaux types de données par
int y; spécifié. typedef.
} q1, q2; Chaque fois qu'on souhaite
main(){

 La déclaration:
déclarer une nouvelle variable on
struct {  typedef int nouveau_type;
int x; a besoin de réécrire le code de la
int y; structure.  Donc nouveau_type constitue un synonyme de int.
} q3, q4, q5; q1 et q2 sont des variables
printf("%d %d\n",q1.x, q1.y);
  Déclaration des variables du nouveau type (nouveau_type):
globales initialisées
printf("%d %d\n",q3.x, q3.y);  nouveau_type len, maxlen; → variables simples de type int;
} automatiquement a 0.
 q3, q4 et q5 sont des variables  nouveau_type * tab[10]; → tableau de 10 pointeurs qui pointe
locales initialisées aléatoirement. sur des int;
Nouveaux types: typedef Nouveaux types: typedef
La déclaration : typedef int entier ;  La structure point:
→signifie que entier est "synonyme" de int, de sorte que les déclarations typedef struct point POINT;
suivantes sont équivalentes :
. . .
int n, p ; entier n, p ;
POINT p1,p2; → déclaration de deux points;
De même :
typedef int * ptr ; POINT p3[10]; → tableau de 10 points;
→ signifie que ptr est synonyme de int *. Les déclarations suivantes sont POINT *p4; → pointeur sur un point;
équivalentes : p4 = malloc(10*sizeof(POINT)); → allocation de
int * p1, * p2 ; ptr p1, p2 ; l'espace mémoire pour 10 points;
La déclaration : typedef int vecteur [3] ;
→ les déclarations suivantes sont équivalentes :
int v[3], w[3] ; vecteur v, w ;
54
10/05/2021
Nouveaux types: typedef Nouveaux types: typedef
Différentes façons de définir les nouveaux types: Différentes façons de définir les nouveaux types:
struct point{  Définition de la structure struct typedef struct point{

int x; point . int x;  Une seule instruction pour
int y;  typedef fait appel a struct point int y; définir la structure struct point
}; pour créer le nouveau type point. } point; et le nouveau type point.
typedef struct point point; main(){
main(){
 Pas d’ambiguïté : le nouveau  Définition de la structure struct
type point peut prendre le même
point p, q = {3,-6};
point p, q = {3,-6}; point a l'intérieur de l'instruction
nom que celui de la structure point * r;
point * r; typedef.
point s[20]; (struct point). point s[20];
} }
Nouveaux types: typedef Initialisation et accès aux membres
Différentes façons de définir les nouveaux types:  Les membres peuvent être initialisées au moment de la
déclaration de la variable de type structure.
typedef struct{ struct point pt1 = {20,30};
int x;  Aucun nom n'a été attribue à struct point pt2={2,3}, pt3={-7,50};
int y; Les valeurs d'initialisation sont fournies entre { et }.
la structure. 
} point;
main(){  L'affectation des initialisations suit l'ordre d'apparition des
point p, q = {3,-6};
 Le type struct point n'existe champs dans la structure. La Nième valeur est affectée au
point * r; pas. champ introduit a la Nième position dans la définition de la
point s[20]; structure.
}
 Exemple: dans struct point pt1 = {20,30};
 x reçoit 20 et y reçoit 30.
55
10/05/2021
Initialisation et accès aux membres Initialisation et accès aux membres
#include<stdio.h>
 Accès aux champs s'effectue comme suit: struct point{
NomDeStructure.membre; int x;
int y;
 Le point (.) permet de connecter le champ (variable membre) à la
};
structure dont il fait partie. int main(int argc, char* argv[]){
 L'opérateur de sélection de membre qui se note peut être struct point a = {2,3}, b = {2};
une flèche -> si la variable structuré est un pointeur. struct point c = {}, d ;
printf("a = (%d,%d)\n", a.x, a.y);
NomDeStructure->membre; oub bien (*NomDeStructure).membre; printf("b = (%d,%d)\n", b.x, b.y);
 Modfier les valeurs des champs des structures: printf("c = (%d,%d)\n", c.x, c.y);
 pt1.x = -2; pt1.y = 0; printf("d = (%d,%d)\n", d.x, d.y);
return 0;
 pt2.x = pt1.y; pt2.y = 2*pt1.x; }
Structures imbriquées Structures imbriquées
Une structure peut être d'un type absolument quelconque : pointeur, La notation :
tableau, structure,... De même, un tableau peut être constitué d'éléments employe.heures[4]
qui sont eux-mêmes des structures. → désigne le cinquième élément du tableau heures de la structure
Structure comportant des tableaux: employe.
Soit la déclaration suivante : employe.nom[0]
struct personne { → représente le premier caractère du champ nom de la structure
char nom[30] ; employe.
char prenom [20] ; &courant.heures[4]
float heures [31] ; → représente l'adresse du cinquième élément du tableau heures de la
} employe, courant ; structure courant.
Elle réserve les emplacements pour deux structures nommées employe Voici un exemple d'initialisation d'une structure de type personne lors de
et courant. sa déclaration :
struct personne emp = { "Dupont", "Jules", { 8, 7, 8, 6, 8, 0, 0, 8} }
56
10/05/2021
Structures imbriquées Organisation des champs
Exemple:
#define MAX 20
struct id {
 Pas d’ambiguïté dans la
char firstname[MAX]; struct foo{
char lastname[MAX]; ligne struct id id; de la int a;  Sortie:
};
struct Personne{
structure Personne: char b;
 0xbfc98bb4
 id est une variable membre
float c;
struct id id;  0xbfc98bb8
};
int age;  le type de id est struct id; int main(int argc,char* argv[]){  0xbfc98bbc
};
int main(){ struct foo f;  0xbfc98bb4
struct Personne p; printf("%p\n",&(f.a));
strcpy(p.id.firstname,“ASIMI"); printf("%p\n",&(f.b));  L'adresse d'une structure =
strcpy(p.id.lastname,“Younes"); printf("%p\n",&(f.c)); l'adresse de premier octet de
p.age=943;
return 0;
printf("%p\n",&f); son premier champ.
return 0;
}
}
Exemple Complet Exemple Complet
Ecrire un programme en C qui déclare un modèle d’une structure void main(void)
nommée Etudiant contenant les champs suivants: { int n,m,i,j;
 Nom: tableau de 20 éléments de type char; float *moy ;
 Note : Pointeur sur N notes de type Float; printf("\n Choisir le nombre des etudiants : ");
 Age: de type int ; scanf("%d",&n) ;
La signature de ce modèle est: Allocation dynamique des variables structurées:
struct Etudiant Etd=(struct Etudiant *) calloc(n, sizeof(struct Etudiant));
{ printf("\n Déterminer le nombre des notes de chaque etudiants : ");
char nom[20] ; scanf("%d",&m) ;
float *note ; Allocation dynamique des notes:
int age ; for (i = 0; i < n; i++){
}; Etd[i].note=(float *)calloc(m,sizeof(float));
Déclaration d’une variable structuré de type pointeur: }
struct Etudiant *Etd;
57
10/05/2021
Exemple Complet Exemple Complet
Initialisation des champs: }
for (i = 0; i < n; i++){ moy[i]=SomNote/m;
printf("\n Nom et age de %d l'etudiant : ", i+1) ; }
scanf("%s%d", Etd[i].nom, &Etd[i].age ) ; Affichage du Nom, age et moyenne,:
printf("\n Donnez les %d notes de l'etudiant : ",m) ; for (i = 0; i < n; i++){
for (j = 0; j < m; j++){ printf("\n Nom de l'etudiant est %s : ",Etd[i].nom ) ;
scanf("%f", &Etd[i].note[j]) ; printf("\n Age de l'etudiant est %d: ", Etd[i].age) ;
}} printf("\n La moyenne de l'etudiant est %f: ",moy[i]) ;
Allocation dynamique de la moyenne }
moy=(float *)calloc(n,sizeof(float )) ; for (i = 0; i < n; i++){
Calcul de la moyenne free(Etd[i].note);
for (i =0; i < n; i++){ }
float SomNote=0; free(Etd);
for (j =0; j < m; j++){ free(moy);
SomNote+=Etd[i].note[j]; }
Structures Structures et fonctions

Passer les champs séparément
Pointeurs, Structures et fonctions
 Une fonction qui prend deux entiers et retourne une
structure point:
 Une structure peut être utilisée comme argument ou résultat
d'une fonction. struct point CreePoint(int x, int y)
{
 Trois possibilités pour le passage des structures aux fonctions: struct point temp;
 Passer les champs (membres) séparément; temp.x =x;
temp.y = y;
 Passer la structure entière; return temp;
}
 Passer un pointeur sur la structure.
 Attention: il ne faut pas confondre la variable x fournie en

argument avec celle qui est membre de la structure temp (de
même pour la variable y).
58
10/05/2021
Structures et Fonctions Structures et Fonctions

Passer les champs séparément Passer la structure entière
struct point{
int x;  Les arguments et la valeur de retour sont des structures :
int y ; Somme de deux points:
} pt1, pt2,middle;
struct point CreePoint(int x, int y){ /* ajouter deux points */
struct point temp; struct point addpoint(struct point p1, struct point p2)
temp.x =x; {
temp.y = y; p1.x += p2.x;
return temp; p1.y += p2.y;
} return p1;
main(){pt1 = CreePoint(0,0); }
pt2 = CreePoint(12,14); main(){
middle = CreePoint ((pt1.x+pt2.x)/2, (pt1.y+pt2.y)/2); struct point a,b,c;
printf("\n Axe X de middle est : %d ",middle.x ) ; a = CreePoint(2,3); b =CreePoint(0,-1);
printf("\n Axe Y de middle est : %d", middle.y) ; c = addpoint(a,b);
} }
Pointeurs, Structures et fonctions Pointeurs, Structures et fonctions

struct point{ int x; Passer un pointeur sur la structure
int y ;  Les arguments sont des pointeurs sur des structures:
} *pt1, *pt2, *middle;
struct point * CreePoint(int x, int y){  Déclaration d'un pointeur sur une structure:
struct point *temp;  struct point *Point;
temp=(struct point *)calloc(1,sizeof(struct point));  Point pointe sur la structure point, (*Point).x et
temp->x =x;
temp->y = y; (*Point).y sont les membres.
return temp; //temp est une adresse  Utilisation du pointeur point:
}
 struct point origin, *Point;
main(){
pt1 = CreePoint(0,0);  Point = &origin;
pt2 = CreePoint(12,14);  printf("origin is (%d,%d)nn",(*Point).x,(*Point).y);
middle = CreePoint((pt1->x+pt2->x)/2,(pt1->y+pt2->y)/2);
printf("\n Axe X de middle est : %d ",middle->x ) ;
printf("\n Axe Y de middle est : %d", middle->y) ;
}
59
10/05/2021
Pointeurs, Structures et fonctions Pointeurs, Structures et fonctions

Passer un pointeur sur la structure Champs de type structure elle-même
 Si p est un pointeur sur une structure, l'accès aux membre  On peut mettre n'importe quel type pour lequel la taille est
s'effectue par : p->membre; connue par le compilateur.
 printf("origin est (%d,%d) \n",p->x,p->y);
 On ne peut pas mettre la structure elle-même
Ajouter deux points:
struct point addpoint(struct point *p1,struct point *p2) struct liste{
{ int valeur;
p1->x += p2->x; struct liste suivant;
p1->y += p2->y; };
return *p1;  On peut mettre comme membre un pointeur sur la structure
}
...
elle-même puisque la taille d'un pointeur est connue.
struct liste{
struct point a,b,c; int valeur;
a = CreePoint(2,3); b = CreePoint(0,-1);
struct liste *suivant;
c = addpoint(&a,&b);  LISTE CHAÎNÉE ; };
Contenu de cours
LISTE CHAINÉE
Une liste chaînée est une structure de données à l’intérieure de laquelle les objets
sont ordonnés de façon linéaire. À la différence d’un tableau, où l’ordre linéaire
est déterminé par les indices du tableau, l’ordre dans une liste chaînée est
déterminé par un pointeur dans chacun des objets.
Elle est constituée :
 d'un champ de données ;
 d'un pointeur vers la structure elle-même.
données
pointeur
La liste chaînée est accessible uniquement par sa tête de liste c’est-à-dire son
premier élément.
10/05/2021 Prof. ASIMI Younes 239
60

Cours ASIMI SD 2020 - 2021

Transféré par

Informations du document

Titre original

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 ASIMI SD 2020 - 2021

Transféré par

Droits d'auteur :

Formats disponibles

10/05/2021

Programme et Langage de Programmation

Cours Un programme est la traduction directe d'un algorithme, dans

Prof. ASIMI Younes  Qu’est-ce qu’on peux dire sur la programmation?

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

 A quoi cela sert-elle? Le langage machine (ordinateur) ou encore le langage de la

09/05/2021 Prof. ASIMI Younes 3 09/05/2021 Prof. ASIMI Younes 4

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Structure d’un Programme Les directives (includes) de pré-compilation ou encore les

09/05/2021 Prof. ASIMI Younes 5 09/05/2021 Prof. ASIMI Younes 6

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 7 09/05/2021 Prof. ASIMI Younes 8

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 13 09/05/2021 Prof. ASIMI Younes 14

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

En fonction des compilateurs, il peut être codé sur 2 ou 4 octets.

09/05/2021 Prof. ASIMI Younes 15 09/05/2021 Prof. ASIMI Younes 16

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 17 09/05/2021 Prof. ASIMI Younes 18

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

 Le premier opérateur à connaître est l’opérateur d’affectation noté

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 21 09/05/2021 Prof. ASIMI Younes 22

Contenu de cours Contenu de cours

Priorité et Associativité des opérateurs Programme et Langage de Programmation

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 27 09/05/2021 Prof. ASIMI Younes 28

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 29 09/05/2021 Prof. ASIMI Younes 30

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 33 09/05/2021 Prof. ASIMI Younes 34

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Exemple 3 : trouver les résultats d’exécution de ce Structures de contrôle

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 37 09/05/2021 Prof. ASIMI Younes 38

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

09/05/2021 Prof. ASIMI Younes 39 09/05/2021 Prof. ASIMI Younes 40

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation

Contenu de cours Contenu de cours

Programme et Langage de Programmation Programme et Langage de Programmation