Université

Cadi Ayyad
Ecole Nationale des Sciences Appliquées
-Safi-

Algorithmique
&
langage C
AH ME D BE NTAJ ER
A . B E N T A J E R @ G M A I L .C O M

1 ER A NNÉ E CY CL E I NG É NI EUR
G. INF.
GTR
2 0 1 3 / 2 01 4
Plan du cours
Introduction

Chapitre 1 : Env. & Bibl. de fonctions

Chapitre 2: Notions de base

Chapitre 3: Type de base, Opérateurs & expr.

Chapitre 4 : Lire & écrire des données

Chapitre 5 : La structure alternative

Chapitre 6 : La structure répétitive

Plan du cours
Chapitre 7 : Les tableaux

Chapitre 8 : Les chaînes de caractères

Chapitre 9 : Les pointeurs

Chapitre 10 : Les fonctions

Chapitre 11 : Les fichiers séquentiels

Chapitre 12 : La programmation modulaire

Chapitre 13 : Les préprocesseur

Introduction
Programmer c’est quoi ! ?

Réaliser des programmes informatiques

Introduction
Programmer c’est quoi ! ?
Introduction
Programmer c’est quoi ! ?
Problème 1 : Comment écrire des programmes en binaire ?

Solution 1 : Inventer de nouveaux langages qui vont

être traduits en binaire pour l’ordinateur

Problème 2 : Comment réaliser le programme qui fait la

traduction ?
Solution 2 : Existe déjà J !!

Compilation Assemblage
Ch1 : Env. et les Bibl. Les bibl. de fonctions
Bibl. de fonctions disponibles dans leur form
précompilé (.LIB)

Inclure des fichiers en-tête (Header files - .H) qui contiennent des prototypes
des fonctions définies dans les bibliothèques & créent un lien entre les fcts
précompilées et les programmes

à .C fichiers source

à .OBJ fichiers compilés (versions objet)

à .EXE fichiers compilés et liés (versions exécutables)

à .LIB bibliothèques de fonctions précompilées

à .H fichiers en-tête (header files)

Ch1 : Env. et les Bibl. Les bibl. de fonctions
Fichiers d’entête
#include <stdio.h>
Stdio.h #include <math.h>
#include …
Math.h
void main()
… {
…
}

Stdio.lib Compiler

Code compilé de la fct Main

Math.lib
Linker

Code compilé de la fct Main

….lib
.Exe
Ch2 : Notions de bases Hello World

HELLO_WORLD en langage algorithmique

programme HELLO_WORLD
(* Notre premier programme en C *)
écrire "hello, world"
finprogramme

HELLO_WORLD en C

#include <stdio.h> Directive de préprocesseur

#include <…>

Int main()
/* Notre premier programme en C */ Commentaire
{
printf("hello, world\n"); Instructions
return 0;
}

Fonction
Ch2 : Notions de bases Les fonctions

<TypeRés> <NomFonct> (<TypePar1> <NomPar1>, <TypePar2> <NomPar2>, ...

)
{
<déclarations locales>
<instructions>
}

TypeRés : le type du résultat de la fonction

NomFonct : le nom de la fonction

<TypePar1> <NomPar1>, <TypePar2> <NomPar2>, ...

Les types et les noms des paramètres de la fonction

Un block d’instruction délimité par { } qui contient :

Déclaration locales : les déclarations des données locales
Instructions : la liste des instructions qui définit l'action qui doit être
exécutée
Ch2 : Notions de bases Les identificateurs
Les identificateurs servent à désigner les différents "objets" manipulés par le
programme: variables, fonctions, etc
Les noms des fonctions et variables en C, sont composés d’une suite de lettre
et chiffre
L’ensemble des caractères utilisables est donc :
{a-z, A-Z, 0-9, _ }
Le 1er caractère doit être un CARACTERE ou le _
Nom_de_variable # nom_de_variable
La longueur des identificateurs n'est pas limitée, mais C distingue
seulement les 31 premiers caractères
Identificateur correcte Identificateur incorrecte
Var1 1var
Var_2 Var.2
_var_3 -var-3
Nom_de_var Nom de var (espace)
Deuxieme_choix Deuxième_choix
 Ch2 : Notions de bases Les mots clés
Certains "mots clés" sont réservés par le langage à un usage bien défini et ne
peuvent pas être utilisés comme identificateurs.

Auto | default | float | register | struct

| volatile | break | do | for | return |
switch | while |case | double | goto |
short | typedef |char | else | if | signed
| union |const | enum | int | sizeof |
unsigned | continue | extern | long |
static | void
Ch2 : Notions de bases Les Commentaires

Les commentaires sont tr`es important dans n’importe quel langage de

programmation car ils permettent de documenter les fichiers de sources

// ceci est un commentaire qui ne peut s’étaler que sur une ligne

/* ceci est un commentaire qui peut

s’étaler sur plusieurs lignes */

Contradiction de Shryer
Si le code et les commentaires se contredisent, les deux sont probablement faux.
Ch2 : Notions de bases Conventions d’écritures
d’un programme en C

Avant d’aller plus loin, il convient d’établir un certain nombre de règles de

présentation que devra suivre tout bon programmeur qui souhaite écrire des
programmes C lisibles

Ne jamais placer plusieurs instructions sur une même ligne ;

utiliser des identificateurs significatifs

grâce à l’indentation des lignes, faire ressortir la structure syntaxique du

programme
laisser une ligne blanche entre la dernière ligne des déclarations et la
première ligne des instructions ;

aérer les lignes de programme en entourant par exemple les opérateurs avec
des espaces
bien commenter les listings
Ch2 : Notions de bases Discussion du
programme Hello World
Ch2 : Notions de bases Exercice
Les identificateurs

Fonction-1 _Moy_du_mois 2e_jour

Limite_sup. Lim_supérieur __A_
_ A 3

Hello World
Modifiez le programme 'hello world' de façon à obtenir le résultat suivant :
 Ch2 : Notions de bases Exercice
Ci-dessous, un simple programme en C. Distinguer et de classifier les
éléments qui composent ce programme (commentaires, variables,
déclarations, instructions, etc.)
while (COMPTEUR < 4) {
/* Lire la valeur du nombre suivant */
#include <stdio.h>
/* printf("Entrez un nombre entier :");
Ce programme calcule la somme de 4 scanf("%i", &NOMBRE);
nombres entiers
introduits au clavier. /* Ajouter le nombre au résultat */
*/ SOMME += NOMBRE;
main()
{ /* Incrémenter le compteur */
int NOMBRE, SOMME, COMPTEUR; COMPTEUR++;

/* Initialisation des variables */ }

SOMME = 0; /* Impression du résultat */
COMPTEUR = 0;
/* Lecture des données */ printf("La somme est: %i \n", SOMME);
return 0;
}
Ch3 : Type de base, Opérateurs & expr. Introduction

b1 …………………………. bn

1 Octet = 8 bits
Les types de base du langage C se répartissent en trois grandes catégories en
fonction de la nature des informations qu'ils permettent de représenter:

Nombres entiers (int NomVar) Exemple : int nombre = 12;

Nombres flottant (float NomVar) Exemple : float pi = 3.14;

Caractères (char NomVar) Exemple : char _unChar;

En langage C, une variable est constitué de deux choses :

Nom : qui permet de reconnaitre la variable

Valeur : La valeur qu’elle stocke

Ch3 : Type de base, Opérateurs & expr. Le type entier

Le mot clé int correspond à la représentation des nombres entiers relatifs

Short Description : Entier court
Nb Octet : 2
int
Description : Entier Standard
long Nb Octet : 2 | 4

Description : Entier long

Nb Octet : 4

En toute rigueur, chacun des trois types (short, int et long) peut être nuancé par
l’utilisation du qualificatif unsigned (non signé). Dans ce cas, il n’y a plus de
bit réservé au signe et on ne représente plus que des nombres positifs.

Exemple : unsigned int nombre = 12;

Ch3 : Type de base, Opérateurs & expr. Le type flottant

Les types flottants permettent de représenter une partie des nombres réels

5 / 2 = 2

float Nb Octet : 4

double
Nb Octet : 8
Long double

Nb Octet : 10

La logique du programme c’est : combien de 2 y’a-t-il dans 5 !!?

Ch3 : Type de base, Opérateurs & expr. Déclaration des
variables
Langage algorithmique

<Type> <NomVar1>,<NomVar2>,...,<NomVarN> entier COMPTEUR,X,Y

réel HAUTEUR,LARGEUR
En C
int COMPTEUR,X,Y
<Type> <NomVar1>,<NomVar2>,...,<NomVarN>
float HAUTEUR,LARGEUR

Affection des variables

Langage algorithmique En C

En <NomVariable> ranger <Expression> <NomVariable> = <Expression>

En Pi ranger 3.14 Pi = 3.14

En moyenne ranger A+B/2 Moyenne = A+B/2

Ch3 : Type de base, Opérateurs & expr. Les opérateurs

Arithmétique Logique
+ Addition && ET logique (AND)
- Soustraction || OU logique (OR)
/ Division ! Négation logique (NOT)
* Multiplication
% Reste de la division
Résultat du type int :
1 : correspond à la valeur
booléan TRUE.
Comparaison
== Égal à ( a == b) 0 : correspond à la valeur
booléan FALSE
!= Différent de (a != b)
<, <=, >, >= Strict inférieur, inférieur ou égal,…
Ch3 : Type de base, Opérateurs & expr. Les opérateurs
affection
+= a+=3 (a = a + 3) Comparaison

-= b-=5 (b = b – 5) X++ ou ++X Pour l’incrémentation

/= c/=2 (c = c / 2) X– ou –X Pour la décrémentation
*= d*=56 (d = d * 56)
%= e%=4 (e = e % 4)

X = I++ : passe d'abord la valeur de I à X et incrémente après

X = I-- : passe d'abord la valeur de I à X et décrémente après

X = ++I : incrémente d'abord et passe la valeur incrémentée à X

X = --I : décrémente d'abord et passe la valeur décrémentée à X

Soit N = 5 X = 5 et N = 6
X = N++
X= ++N X = 6 et N = 6
 Ch3 : Type de base, Opérateurs & expr. La bibliothèque
math.h
#include <math.h>
COMMANDE
EXPLICATION
C

exp(X) fonction exponentielle

log(X) logarithme naturel

log10(X) logarithme à base 10

sin(X) cos(X) sinus, cosinus, tangente

pow(X,Y) X exposant Y
tan(X) de X
sqrt(X) racine carrée de X
asin(X) acos(X) arcsin(X), arccos(X),
atan(X) arctan(X) fabs(X) valeur absolue de X

floor(X) arrondir en moins

sinh(X) cosh(X)
sinus, cosinus, tangente
tanh(X) ceil(X) arrondir en plus
hyperboliques de X
reste rationnel de X/Y (même
fmod(X,Y)
signe que X)
Ch3 : Type de base, Opérateurs & expr. Les conversions
Si un opérateur a des opérandes de différents types, les valeurs des
opérandes sont converties automatiquement dans un type commun.

Lors d'une affectation, la donnée à droite du signe d'égalité est convertie

dans le type à gauche du signe d'égalité. Dans ce cas, il peut y avoir
perte de précision si le type de la destination est plus faible que celui de
la source.

Pour pouvoir être multiplié avec X, la

valeur de I est convertie en float (le
Exemple : type le plus large des deux). Le
int I = 8; float X = 12.5; double Y; résultat de la multiplication est du
Y = I * X; type float, mais avant d'être affecté a
Y, il est converti en double. Nous
obtenons comme résultat: Y = 100.00
Ch3 : Type de base, Opérateurs & expr. Les constants caractères

Pour designer un caractère imprimable, il suffit de le mettre entre

apostrophes
Exemple : ‘A’ ou ‘@’

Les seuls caractères qu’on peut pas représenter sont l’antislash et

l’apostrophe qui sont désignés par \\ et \’

Les caractères non imprimables peuvent être désignés par ’\code-octal’ ou

code-octal est le code en octal du caractère. On peut aussi écrire ’\xcode-
hexa’ ou code-hexa est le code en hexadecimal du caractere . Par exemple,
’\33’ et ’\x1b’ désignent le caractère escape.
Ch3 : Type de base, Opérateurs & expr. Operateur ternaire

L’operateur conditionnel ? est un operateur ternaire. Sa syntaxe est la

suivante :

Condition ? Exp1 : Exp2

Operateur de conversation

L’opérateur de conversion de type, appelé cast, permet de modifier

explicitement le type d’un objet. On écrit

(type) objet

int i = 3, j = 2;
printf("%f \n",(float)i/j);
Ch3 : Type de base, Opérateurs & expr. Operateur adresse

L’operateur d’adresse & applique a une variable retourne l’adresse-memoire

de cette variable. La syntaxe est

& objet

Operateur de conversation

L’opérateur de conversion de type, appelé cast, permet de modifier

explicitement le type d’un objet. On écrit

(type) objet

int i = 3, j = 2;
printf("%f \n",(float)i/j);
Ch4 : Lire et écrire des données Intro

La bibliothèque standard <stdio> contient un ensemble de fonctions qui

assurent la communication de la machine avec l’utilisateur

printf() Écriture formatée des données

scanf() Lecture formatée des données

getchar() Lecture d’un caractère

putchar() Ecriture d’un caractère

Ch4 : Lire et écrire des données Printf()

des codes de format repérés par %

des caractères à afficher tels quels
%d ou %i Entier relatif

%u Entier naturel (unsigned)

%o Entier exprimé en octet

%x Entier exprimé en hexadécimal

%c Caractère

%f Double (en notation décimal)

%e Double (en notation scientifique)

%s Chaine de caractère
Ch4 : Lire et écrire des données Putchar()

… …
char x; char x;
x = ‘a’; x = ‘a’;
putchar(x); printf(‘’%c’’, x);
… …
 Ch4 : Lire et écrire des données scanf()
La fonction scanf() est la fonction symétrique de printf()

Langage algorithmique
lire <NomVariable1>,<NomVariable2>, ...
En C
scanf("<format>",<AdrVar1>,<AdrVar2>, ...)
L’@ ou va être stocké la valeur

Exemple :
int jour, mois, annee;
Détermine comment les données Printf(‘’Saisir votre jour de naissance : \n’’);
Seront interprétées scanf(‘’ %d’’, &jour);
Exemple :
int jour, mois, annee; Printf(‘’Saisir votre mois de naissance : \n’’);
Printf(‘’Saisir votre datede scanf(‘’ %d’’, &mois);
naissance : \n’’);
scanf(‘’ %d %d %d’’, &jour, Printf(‘’Saisir votre anneede naissance : \n’’);
&mois, $annee); scanf(‘’ %d’’, &annee);
Ch4 : Lire et écrire des données scanf()
SYMBOLE LECTURE D'UN(E)

%d ou %i entier relatif

%u entier naturel (unsigned)

%o entier exprimé en octal

%b entier exprimé en hexadécimal

%c caractère

%s chaîne de caractères

rationnel en notation décimale ou exponentielle

%f ou %e (scientifique)
Ch4 : Lire et écrire des données Putchar()

… …
char x; char x;
x = getchar(); x = scanf(‘’%c’’, &x);
putchar(x); putchar(‘’%c’’, x);
… …
Ch4 : Lire et écrire des données Exercice

1. écrivez un programme qui lit la date du clavier et écrit les données

ainsi que le nombre de données correctement reçues sur l'écran.
Exemple:
Introduisez la date (jour mois année): 18 09 2013
• données reçues : 3
• jour : 11
• mois : 11
• année : 1991
2. Testez les réactions du programme à vos entrées. Essayez
d'introduire des nombres de différents formats et différentes
grandeurs
3. Changez la partie format du programme de façon à séparer les
différentes données par le symbole '-'
Ch4 : Lire et écrire des données Exercice

Quelles seront les valeurs lues dans les variables net p(de type int), par
l’instruction suivante ?
scanf ("%4d %2d", &n, &p) ;
lorsqu’on lui fournit les données suivantes (le symbole ^ représente un espace
et le symbole @ représente une fin de ligne, c’est-à-dire une validation) ?
a) 12^45@
b) 123456@
c) 123456^7@
d) 1^458@
e) ^^^4567^^8912@

4-3 ) Ecrire un programme qui lit un caractère au clavier et affiche le caractère

ainsi que son code numérique:
Ch4 : Lire et écrire des données Exercice

4.4 - Ecrire un programme qui permute et affiche les valeurs de trois variables
A, B, C de type entier qui sont entrées au clavier :
A ==> B , B ==> C , C ==> A

4.5 - Ecrire un programme qui affiche le quotient et le reste de la division

entière de deux nombres entiers entrés au clavier

4.6 - Ecrire un programme qui affiche la résistance équivalente à trois

résistances R1, R2, R3 (type double),
- si les résistances sont branchées en série: R = R1+R2+R3
- si les résistances sont branchées en parallèle: R =
(R1.R2.R3)/(R1.R2+R1.R3+R2.R3)
Ch5 : La structure alternative Introduction

Tous les langages disposent d’instructions, nommées

instructions de contrôle, permettant de réaliser des choix
Ch5 : La structure alternative If … else

Si la variable vaut ça if (Condition logique) {

Alors faire ceci faire ceci si la
condition est vraie
}
if (age >= 18) {
printf(‘’Vous etes majeur’’);
}
if (Condition logique) {
faire ceci si la condition
Si la variable vaut ça est vraie
Alors faire ceci
}
Si non faire cela Else {
faire cela si la condition est fausse
if (age >= 18) { }
printf(‘’Vous etes majeur’’);
}
Else {
printf(‘’Vous etes mineur’’);
}
 Ch5 : La structure alternative If … else

Le dernier else est toujours lié au if

qui ne possède pas de partie else

#include <stdio.h>

main() {
int A,B;
Char sexe = ‘m’
printf("Entrez deux nombres entiers :");
if (sexe == ‘m’) { scanf("%i %i", &A, &B);
printf(‘vous êtes un homme’’);
} if (A > B)
printf("%i est plus grand que %i\n", A, B);
If (sexe != ‘m’)
{ else if (A < B)
printf(‘vous êtes une femme’’); printf("%i est plus petit que %i\n", A, B);
}
else printf(‘’%i est egal a %i’’,A,B);
Else {
printf(‘euuuuh, J!!’’); return 0; }
}
Ch5 : La structure alternative Exercice

5.3 - Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier
et qui affiche la plus grande des trois valeurs, en utilisant:
a) if - else et une variable d'aide MAX
b) if - else if - ... - else sans variable d'aide

Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui

affiche le signe du produit de A et B sans faire la multiplication.

Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui

affiche le signe de la somme de A et B sans faire l'addition. Utilisez la
fonction fabs de la bibliothèque <math>
Ch5 : La structure altérnative L’instruction switch

SWITCH

Cas 1 Cas 2 Cas 3 Cas n default

Ch5 : La structure altérnative L’instruction switch
Ch5 : La structure alternative Résumé

Les conditions sont un moyens de prise de décision pour l’ordinateur

On peut écrire autant de if … else qu’on veut

Le résultat d’un test avec if est un booléan

Un booléan est une variable peut avoir deux état 1 (TRUE) ou 0 (FALSE)

Le switch est une alternative de if … else

Ch5 : La structure répétitive Introduction

C’est quoi une boucle ?

while Do … while for

Instruction
Instruction
Instruction
Instruction
Instruction
Ch5 : La structure répétitive While

tant que (<expression logique>) faire

<bloc d'instructions>
ftant

Tan que la valeur logique <expression logique> fournit un

résultat TRUE, exécuter <bloc d’instruction>

Int nombre = 0;
While (nombre != 12) {
printf(‘’veuillez saisir 12 pour sortir de la boucle’’);
nombre = scanf(‘’%d’’,&nombre);
}
Ch5 : La structure répétitive Exemple

fflush(stdin);
Ch5 : La structure répétitive do .. while

do {
<bloc d'instructions>
}
while (<expression logique>)

#include <stdio.h>
#include <math.h>
main()
{
float N;
do {
printf("Entrer un nombre (>= 0) : ");
scanf("%f", &N);
}
while (N < 0);
printf("La racine carrée de %.2f est %.2f\n", N, sqrt(N));
return 0;
} Tester le même exemple avec int compteur = 0
Ch5 : La structure répétitive For
For ( <expr1> ; <expr2>; <expr3> )
{
<instruction>
}
<expr1> : est évaluée une fois avant le passage de la boucle. Elle est utilisée pour
initialiser les données de la boucle.
<expr2> : est évaluée avant chaque passage de la boucle. Elle est utilisée pour
décider si la condition de sortie de la boucle a été atteinte
<expr3> : st évaluée à la fin de chaque passage de la boucle. Elle est utilisée pour
réinitialiser les données de la boucle.
for (int i = 0; i<10; i++) { Int i ;
printf(‘’valeur de i : %d’’, i); i = 0;
} for ( ; i<10; i++) {
printf(‘’valeur de i : %d’’, i);
Int i ; }
i = 0;
for ( ; i<10; ) {
printf(‘’valeur de i : %d’’, i);
i++;
}
Ch5 : La structure répétitive Choix de la structure !!?

Si le bloc d'instructions ne doit pas être exécuté si la

condition est fausse, alors utilisez while ou for.

Si le bloc d'instructions doit être exécuté au moins une fois, alors utilisez do -
while

Si le nombre d'exécutions du bloc d'instructions dépend d'une ou de plusieurs

variables qui sont modifiées à la fin de chaque répétition, alors utilisez for.

Si le bloc d'instructions doit être exécuté aussi longtemps qu'une condition

extérieure est vraie (p.ex aussi longtemps qu'il y a des données dans le fichier
d'entrée), alors utilisez while.
 Ch6 : Les Tableaux Introduction
Un tableau est un ensemble d’élément du même type, désigné par un
identificateur unique, sur un espace mémoire contigu
Un tableau est donc une suite de cases (espace mémoire) de même taille.
La taille de chacune des cases est conditionnée par le type de donnée que
le tableau contient

Les tableaux permettent une manipulation plus flexible des chaine de

caractère

@ Valeur

1000 2

Un tableau prend un espace 1001 5

contigu dans la mémoire
1002 12
Toutes les cases du tableau sont du
même type
1003 9
Ch5 : Les Tableaux Les tableaux
unidimensionnels
Un tableau (unidimensionnel) 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.

N
data data …. data data data

Déclaration : 2 * 12 = 24 Octet
Type Nom_Tableau [ TAILLE ] Utilisation de l’opérande sizeof()

Exemple :

int mois[12]={1,2,3,4,5,6,7,8,9,10,11,12}; // Déclaration et initialisation d’un

tableau de type entier d’une taille de 12

mois[2] = 3 // ON AJOUTE LE MOIS 3 dans le 3ième élément du tableau

Ch5 : Les Tableaux Les tableaux
unidimensionnels
Accès aux éléments Pour accéder à un élément du tableau, le nom que
l'on a donné à celui-ci ne suffit pas car il comporte
Int t[5] = {1,2,3,4,5}; plusieurs éléments. Ainsi, on définit un nombre
Printf (‘’%d’’, t); ?? appelé indice (en anglais index) qui, combiné avec le
nom du tableau, permet de décrire exactement
chaque élément.
1. L'indice du premier élément du tableau est 0
2. Un indice est toujours positif
3. L'indice du dernier élément du tableau est égal au
nombre d'éléments - 1

Pour lire une entrée dans le tableau i suffit de mettre

Printf(‘’%d’’,t[i]); 0<= i < N //N = taille du tableau
Ex : printf(‘’%d’’, t[1]) à 2

61
3
56
70

i=0 i=1 i=n-3 i=n-2 i=n-1

1 6 …. 70 56 3
Ch5 : Les Tableaux Les tableaux à deux
dimensions
Un tableau à deux dimensions est interprété comme un tableau
unidemensionnel de dimension L dont chaque composante est un tableau
(uni-dimensionnel) de dimension C.

L : Nombre de ligne
L*C composantes
C : Nombre de colonne

C
Ch5 : Les Tableaux Les tableaux à deux
dimensions
Considérons un tableau NOTES à une dimension pour mémoriser les
notes de 10 étudiants dans un devoir

12 15 10 9 19 17 5 8 9 14

Si on veut mémoriser les notes de 10 étudiants dans 3 modules ??

12 15 10 9 19 17 5 8 9 14
10 5 9 12 7 8 15 16 9 14
18 20 16 18 15 10 8 8 9 15
 Ch5 : Les Tableaux Les tableaux à deux
dimensions
<Type> <NomTabl>[<DimLigne>][<DimCol>];

int A[10][10];

float B[2][20];

int C[3][3];

char D[15][40];

Mémorisation
Comme pour les tableaux à une dimension, le nom d'un tableau est le
représentant de l'adresse du premier élément du tableau (c.-à-d. l'adresse de la
première ligne du tableau).
short A[3][2] = {{1, 2 }, {10, 20 }, {100, 200}};
Ch5 : Les Tableaux Les tableaux à deux
dimensions
Initialisation et réservation automatique

int T[4][4] = { {1,0,0,0}, {1,1,0,0}, {1,1,1,0}, {1,1,1,1} } ;

1 0 0 0
1 1 0 0
1 1 1 0
1 1 1 1

Accéder aux compostantes

Ch5 : Les Tableaux Les tableaux à deux
dimensions

for (i = 0; i<L; i++) {

for (j=0; j<C; j++) {
printf(‘’%d’’, T[i][j]);
}
printf(‘’\n’’);
}
Ch5 : Les Tableaux Exemples
main() {
int A[5][10]; main() {
int I,J; int A[5][10];
for (I=0; I<5; I++) { int I,J;
for (J=0; J<10; J++) for (I=0; I<5; I++)
printf("%d", A[I][J]); for (J=0; J<10; J++)
printf("\n"); scanf("%d", &A[I][J]);
} return 0;
return 0; }
}

Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux

dimensions du type int . Remplir le tableau par des valeurs entrées au clavier
et afficher le tableau.

Ecrire un programme qui transfère un tableau M à deux dimensions L et C

dans un tableau V à une dimension.
Ch8 : Les chaînes de caractères Introduction
Contrairement à d’autre langage de programmation (JAVA,…), C ne dispose
pas d’un type spécial pour traiter les chaînes de caractères

Un tableau est un ensemble d’élément

C permet de stocker UN du même type, désigné par un
CARACTERE à l’aide du char identificateur unique, sur un espace
mémoire contigu
char nom[10];

char chaine[DIM]; char prenom[20];

char email[20];
Lors de la déclaration , on doit indiquer l’espace a réserver en mémoire pour le
stockage de la chaîne
Une chaine de char ne contient pas que des lettres, une chaine de char doit
impérativement contenir un char spécial \0 qui marque la fin de la chaine

Malheureusement le compilateur C ne contrôle pas si on a réservé un octet pour

le symbole de fin de chaine, l ’erreur sera remarqué lors de l’exécution du
programme
 Ch8 : Les chaînes de caractères Manipulation
Ex. :
Pour stocker le mot bonjour il faut déclarer un tableau d’une taille au
minimum 8
char chaine[8] = ‘’bonjour’’;

b o n j o u r \0

Lire/Ecrire une chaine de char

Pour afficher une chaine de char on utilise le symbole %s de la fonction printf
Pour afficher le contenue de chaine on écrira : printf (‘’%s’’, chaine);

Ça va de même pour la lecture scanf(‘’%s’’, &chaine);

Soit en utilisant gets et puts

Gets(chaine);
Puts(chaine);
Ch8 : Les chaînes de caractères Travailler sur les char
La bibl. string fournit une multitude de fonctions pratiques pour le
traitement des chaînes de char.

La fonction strlen
La fonction strlen fournit en résultat la longueur de la chaine (nombre de char
trouvé depuis le début de la chaine jusqu’au premier char de fin de chaine le \0)

Ex :
int taille = strlen(‘’bonjour’’); //taille vaudra 7
Ou bien
Char txt[] = ‘’bonjour’’;
int taille = strlen(txt);
Ch8 : Les chaînes de caractères Travailler sur les char
Fonction de concaténation
#include <stdio.h>
strcat
#include <string.h>
main() Strcat, prend deux arguments arg1 et
{ arg2, et concatène la valeur de arg2
char ch1[50] = "bonjour" ; avec arg1
char ch2[50] = " monsieur" ;
printf ("avant : %s\n", ch1) ;
strcat (ch1, ch2) ;
printf ("après : %s", ch1) ;
}

#include <stdio.h>
strncat
#include <string.h>
main() Strncat(arg1,arg2,lgmax), prend 3
{ arguments arg1 et arg2 et lgmax offrant
char ch1[50] = "bonjour" ; en outre un contrôle sur le nombre de
char ch2[50] = " monsieur" ; caractères qui seront concaténés à la
printf ("avant : %s\n", ch1) ; chaîne d’arrivée (arg1)
strncat (ch1, ch2, 6) ;
printf ("après : %s", ch1) ;
}
Ch8 : Les chaînes de caractères Travailler sur les char
Fonction de comparaison
#include <stdio.h>
strcmp
#include <string.h> Strcmp, compare tous les caractères
main() s’ils sont identiques, elle renvoie 0. Si
{ les caractères de la ch1 sont supérieurs
char ch1[50] = "bonjour" ; à ceux de la ch2, la fonction renvoie
char ch2[50] = " monsieur" ; un nombre positif. Si c'est l'inverse, la
Int n = strcmp (ch1, ch2) ; fonction renvoie un nombre négatif.
}

#include <stdio.h>
strncmp stricmp ( chaîne1, chaîne2 )
#include <string.h>
strnicmp ( chaîne1, chaîne2, longeur )
main()
{
char ch1[50] = "bonjour" ;
char ch2[50] = " bon" ;
strncat (ch1, ch2, 2) ;

}
Ch8 : Les chaînes de caractères Travailler sur les char
Fonction de copie
#include <stdio.h>
strcpy
#include <string.h> Strcpy, copy le contenu de le chaine
main() ch2 dans ch1, ATTENTION à la
{ dimension de ch1
char ch1[50] = "bonjour" ;
char ch2[50] = " monsieur" ;
strcpy (ch1, ch2) ;
Printf(‘’%s’’,ch1);
}

#include <stdio.h>
strncpy limite la recopie au nombre de
#include <string.h>
caractères précisés par l’expression
main()
entière longeur (dans notre cas c’est 2)
{
char ch1[50] = "bonjour" ;
char ch2[50] = " monsieur" ;
strncat (ch1, ch2, 2) ;

}
Ch8 : Les chaînes de caractères Travailler sur les char
Fonction de recherche dans un chaine
strchr ( chaîne, caractère )

Recherche dans chaîne la

première position où apparaît
le caractère mentionné

strstr ( chaîne, sous-chaîne )

strrchr ( chaîne, caractère ) recherche, dans chaîne, la

première occurrence complète
de la sous-chaîne mentionnée
réalise le même traitement
que strchr, mais en explorant
la chaîne concernée à partir
de la
fin. Elle fournit donc la
dernière occurrence du
caractère mentionné.
Ch8 : Les chaînes de caractères Travailler sur les char
Conversion d’une chaîne en valeur numérique
Il existe trois fonctions permettant de convertir une chaîne de char, en valeur
numérique de type int, long et double
atoi( chaîne) fournit un résultat de type int
atol ( chaîne) fournit un résultat de type long

atof ( chaîne) fournit un résultat de type double

Les fonctions de <ctype>

Les fonctions de classification suivantes fournissent un résultat du

type int différent de zéro, si la condition respective est remplie, sinon
zéro
Ch8 : Les chaînes de caractères Travailler sur les char
Les fonctions de <ctype>
La fonction: retourne une valeur différente de zéro,

isupper(<c>) si <c> est une majuscule ('A'...'Z')

islower(<c>) si <c> est une minuscule ('a'...'z')

isdigit(<c>) si <c> est un chiffre décimal ('0'...'9')

isalpha(<c>) si islower(<c>) ou isupper(<c>)

isalnum(<c>) si isalpha(<c>) ou isdigit(<c>)

isxdigit(<c>) si <c> est un chiffre hexadécimal

('0'...'9' ou 'A'...'F' ou 'a'...'f')

isspace(<c>) si <c> est un signe d'espacement

(' ', '\t', '\n', '\r', '\f')

 Ch8 : Les chaînes de caractères Tableau de chaîne de
caractère
Pour mémoriser une suite de mots ou de phrases dans des variables. Il est
pratique de créer un tableau de chaînes de caractères, ce qui allégera les
déclarations des variables et simplifiera l'accès aux différents mots
Déclaration

Char jour[7][10]

7
Chaînes
de
caractères

10 caractères par chaînes

char JOUR[7][9]= {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi",

"dimanche"};
Ch8 : Les chaînes de caractères Tableau de chaîne de
caractère

int I = 2;
printf("Aujourd'hui, c'est %s !\n", JOUR[I]);

JOUR[I] : représentent l'adresse du premier élément d'une chaîne de

caractères. N'essayez donc pas de 'modifier' une telle adresse par une
affectation directe !

Sol :
Utilisez la fonction strcpy à strcpy(JOUR[I], ‘’votre chaine’’);
 Ch9 : Les pointeurs Introduction
Le nom d’une variable, permet d’accéder directement à la valeur de cette
variable

Le nom de la variable nous permet d’accéder à la valeur de la variable à

Adressage directe
10E3

Int N; 5 ……………………
N=5

Si nous ne voulons ou ne pouvons pas utiliser le nom d'une variable N, nous

pouvons copier l'adresse de cette variable dans une variable spéciale P, appelée
pointeur. Ensuite, nous pouvons retrouver l'information de la variable N en
passant par le pointeur P à Adressage indirecte

Soit N une variable contenant la valeur 5 et P un pointeur qui contient l'adresse

de N. En mémoire, N et P peuvent se présenter comme suit:

10E3 40A5

40A5 ….. 5

P N
Ch9 : Les pointeurs Les pointeurs
Un pointeur est une variable spéciale qui peut contenir l'adresse d'une autre
variable.
Lors du travail avec les pointeurs on aura besoin de :
• D’un opérateur ‘’adresse de : &’’; pour obtenir l’@ d’une variable
• D’un opérateur ‘’ contenu de * ‘’; pour accéder au contenue de l’@
• D’une syntaxe de déclaration pour pouvoir déclarer le pointeur
Exmple 1 : Exmple 2 :
Int n = 5; Int n = 5;
Printf (‘’ N vaut : %d’’, n) Printf (‘’ L’@ de N vaut : %d’’, &n)

P @
P @ P = &A;
B = *P;
P = &A A 20
5 *P = 20;

• P pointe sur A,
A 5
• le contenu de A (référencé par *P)
B 50
5
est affecté à B
• le contenu de A (référencé par *P)
est mis à 20.
Ch9 : Les pointeurs Les opérations élémentaires sur
pointeurs
Si un pointeur P pointe vers une variable A, alors *P désigne le contenue de la
case vers laquelle le pointeur P pointe (càd le contenue de A)

Si on a P = &X
Ch9 : Les pointeurs Excercice
A
B C P1 P2

Init. 1 2 3 / /
main() { A B C P1 P2
int A = 1; int B = 2; int C = 3; Init. 1 2 3 / /
P1=&A 1 2 3 &A /
int *P1, *P2;
P1=&A 1 2 3 &A /
P1=&A; P2=&C 1 2 3 &A &C
P2=&C; P2=&C

*P1=(*P2)++; *P1=(*P2)++ 3 2 4 &A &C

*P1=(*P2)++
P1=P2;
P2=&B; P1=P2
P1=P2 3 2 4 &C &C
*P1-=*P2; P2=&B
++*P2; P2=&B 3 2 4 &C &B
*P1*=*P2; *P1-=*P2

A=++*P2**P1; ++*P2
*P1-=*P2 3 2 2 &C &B
P1=&A;
*P2=*P1/=*P2; *P1*=*P2++*P2 3 3 2 &C &B
return 0; } A=++*P2**P1
*P1*=*P2 3 3 6 &C &B
P1=&A

A=++*P2**P1 24 4 6 &C &B

*P2=*P1/=*P2

P1=&A 24 4 6 &A &B

*P2=*P1/=*P2 6 6 6 &A &B

 Ch10 : Les fonctions introduction

La structuration de programmes en sous-programmes se fait en C à l'aide

de fonctions

Nous avons déjà utilisé des fonctions prédéfinies dans des bibliothèques
standard (printf de <stdio>, strlen de <string>, pow de <math>, etc.)

Une fonction exécute des actions et renvoie un résultat. C'est un morceau de

code qui sert à faire quelque chose de précis. On dit qu'une fonction possède
des I/O
1. L’entrée : on fait rentrée des informations (généralement des variables) pour
le traitement
2. Traitement : Grâce aux Entrée la fonction fait le traitement
3. Résultat : Une fois le traitement terminée la fonction retourne un résultat ou
pas
 Ch10 : Les fonctions Modularisation de
programmes

Pourquoi ?
Meilleurs lisibilité – Diminution des risques d’erreurs - possibilité de tests
sélectifs – Réutilisation – Simplicité d’entretien - …

Exemple :
Supposant qu’on veut réaliser un
programme qui affiche un rectangle
d’étoile de longueur L et hauteur H.
 Ch10 : Les fonctions Les fonctions

Variable globale
Les variables déclarées au début de la fonction principale main
ne sont pas des variables globales, mais elles sont locales à main !

Déclaration d’une fonction

TypeRetour NomFonction(parametres)
{
INSTRUCTIONS
return type_retour //généralement une variable ou un résultat de
calcule
}
Ch10 : Les fonctions Modularisation de
programmes
 Ch10 : Les fonctions Paramètre d’une
fonction
Les arguments d'une fonction sont des données de l'extérieur et déterminent
les actions et le résultat de la fonction. Techniquement, nous pouvons
résumer le rôle des paramètres en C de la façon suivante:
Les paramètres d'une fonction sont simplement des variables locales qui sont
initialisées par les valeurs obtenues lors de l'appel.

Lors d'un appel, le nombre et l'ordre des paramètres doivent nécessairement

correspondre aux indications de la déclaration de la fonction. Les
paramètres sont automatiquement convertis dans les types de la déclaration
avant d'être passés à la fonction.

Void tracerRec(int L, double H);

En C, le passage des paramètres se fait toujours par la valeur,

c.-à-d. les fonctions n'obtiennent que les valeurs de leurs paramètres et n'ont pas
d'accès aux variables elles-mêmes.
Ch10 : Les fonctions Passage de l’adresse
d’une variable
Pour changer la valeur de la variable il faut procéder comme suit :
• la fonction appelante doit fournir l'adresse de la variable et
• la fonction appelée doit déclarer le paramètre comme pointeur.
Void permuter (int A, int B) Int maint()
{ {
int tmp; int X = 10;
tmp = A; Int Y = 20;
A=B; permuter(X,Y);
B=tmp; Printf (‘’X = %d, Y = %d’’,X,Y)
} }
Ch10 : Les fonctions Passage de l’adresse
d’une variable
Pour pouvoir modifier le contenue de X et Y on doit procéder comme suit :

Void permuter (int *A, int *B) Int maint()

{ {
int tmp; int X = 10;
tmp = *A; Int Y = 20;
*A=*B; permuter(&X,&Y);
*B=tmp; Printf (‘’X = %d, Y = %d’’,X,Y)
} }
 Ch10 : Les fonctions Passage de l’adresse d’un
tableau à une dimension
Comme il est impossible de passer 'la valeur' de tout un tableau à une
fonction, on fournit l'adresse d'un élément du tableau

Déclaration : int strlen(char *S) {

Type nom[] Ou bien Type *nom int N;
Ex : for (N=0; *S != '\0'; S++)
Int calcSommeTab(int *note) N++;
return N;
}

La fonction LIRETAB lit N données pour un tableau (unidimensionnel) du

type int et les mémorise à partir de l'adresse indiquée par le pointeur PTAB.
PTAB et N sont fournis comme paramètres
void LIRE_TAB(int N, int *PTAB)
{
printf("Entrez %d valeurs : \n", N);
while(N) {
scanf("%d", PTAB++);
N-- }
}
Ch10 : Les fonctions Exercice

Ecrire un programme se servant d'une fonction MOYENNE du

type float pour afficher la moyenne arithmétique de deux nombres réels
entrés au clavier

Ecrire une fonction MIN et une fonction MAX qui déterminent le minimum
et le maximum de deux nombres réels.
Ecrire un programme se servant des fonctions MIN et MAX pour déterminer
le minimum et le maximum de quatre nombres réels entrés au clavier.
 introduction
Ch11 : Les fichiers
Un fichier est un ensemble structuré de données stocké en général sur un
support externe
Fichier Séquentiel
Dans des fichiers séquentiels, les enregistrements sont mémorisés
consécutivement dans l'ordre de leur entrée et peuvent seulement être lus
dans cet ordre

Comment pouvons-nous relier le nom d'un fichier sur un support externe avec les
1 - On appelleinstructions
la fonction d'ouverture
qui donnent de fichier
accès fopen qui
au contenu nous renvoie
du fichier ? un
pointeur sur le fichier.

2 - On vérifie si l'ouverture a réussi (c'est-à-dire si le fichier existait) en

testant la valeur du pointeur qu'on a reçu. Si le pointeur vaut NULL, c'est que
l'ouverture du fichier n'a pas fonctionné, dans ce cas on ne peut pas
continuer.

3 - Si l'ouverture a fonctionné (pointeur différent de NULL ), alors on peut lire

et écrire dans le fichier à travers des fonctions.

4 -Une fois qu'on a terminé de travailler sur le fichier, il faut le fermer avec la
fonction fclose.
 Le Type FILE*
Ch11 : Les fichiers
Pour pouvoir travailler avec un fichier, un programme a besoin d'un certain
nombre d'informations :
- adresse de la mémoire tampon,
- position actuelle de la tête de lecture/écriture,
- type d'accès au fichier: écriture, lecture, ...
- ….
Ces informations sont regroupées dans FILE

Créer et afficher un fichier séquentiel

FILE* fopen( const char* nomDuFichier, const char* modeOuverture);

Le nom du fichier à ouvrir Mode d’ouverture (Lecture ou Ecriture)

 Le Type FILE*
Ch11 : Les fichiers
 Le Type FILE*
Ch11 : Les fichiers
 Le Type FILE*
Ch11 : Les fichiers
Ouverture d’un fichier

File_pointer = fopen(‘’test.txt’’, ‘’r’’) || File_pointer = fopen(‘’test.txt’’, ‘’w’’)

" r" : lecture seule.

"w" : écriture seule.

"a" : mode d'ajout. Vous écrirez dans le fichier. Si le fichier n'existe pas, il sera
créé.

"r+" : lecture et écriture. Vous pourrez lire et écrire dans le fichier.

"w+" : lecture et écriture, avec suppression du contenu au préalable.. Si le

fichier n'existe pas, il sera créé.

"a+" : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de
la fin du fichier. Si le fichier n'existe pas, il sera créé.

Si un fichier existant est ouvert en écriture, alors son contenu est perdu.
 Le Type FILE*
Ch11 : Les fichiers
Tester l’ouverture d’un fichier

Le pointeur File_pointer devrait contenir l'adresse de la structure de

type FILE qui sert de descripteur de fichier. Celui-ci a été chargé en mémoire
par la fonction fopen().

FILE* fichier = NULL;

fichier = fopen("test.txt", "r+");

if (fichier != NULL)
{
// On peut lire et écrire dans le fichier
}
else
{
// On affiche un message d'erreur
printf("Impossible d'ouvrir le fichier test.txt");
}
 Le Type FILE*
Ch11 : Les fichiers
Tester l’ouverture d’un fichier
Le pointeur File_pointer devrait contenir l'adresse de la structure de
type FILE qui sert de descripteur de fichier. Celui-ci a été chargé en mémoire
par la fonction fopen().
FILE* fichier = NULL;

fichier = fopen("test.txt", "r+");

if (fichier != NULL)
{
}
else
{
// On affiche un message d'erreur
printf("Impossible d'ouvrir le fichier test.txt");
}
Tester la fermeture d’un fichier
0 : Si la fermeture a marché
int fclose(FILE* pointeurSurFichier);
EOF : Si la fermeture a échoué
 Lire & Ecrire dans les
Ch11 : Les fichiers fichiers séquentiels
Ecrire dans un fichier

Il existe plusieurs fonctions capables d'écrire dans un fichier. Ce sera à vous

de choisir celle qui est la plus adaptée à votre cas.
Voici les trois fonctions que nous allons étudier :
• fputc : écrit un caractère dans le fichier (UN SEUL caractère à la fois) ;
• fputs : écrit une chaîne dans le fichier ;
• fprintf : écrit une chaîne « formatée » dans le fichier,

char* fputs(const char* chaine, FILE* pointeurSurFichier);

 Lire & Ecrire dans les
Ch11 : Les fichiers fichiers séquentiels
Lire depuis un fichier

Nous pouvons utiliser quasiment les mêmes fonctions que pour l'écriture, le
nom change juste un petit peu :
• fgetc : lit un caractère ;
• fgets : lit une chaîne ;
• fscanf : lit une chaîne formatée.

char* fgets(char* chaine, int nbreDeCaracteresALire, FILE* pointeurSurFichier);

 Se déplacer dans un
Ch11 : Les fichiers fichier

Chaque fois que vous ouvrez un fichier, il existe en effet un curseur qui
indique votre position dans le fichier

Il existe trois fonctions :

• ftell : indique à quelle position vous êtes actuellement dans le fichier ;

• fseek : positionne le curseur à un endroit précis ;

• rewind : remet le curseur au début du fichier.

ftell :

long ftell(FILE* pointeurSurFichier);

Cette fonction est très simple à utiliser. Elle renvoie la position actuelle du
curseur sous la forme d'un long, le nombre renvoyé indique donc la
position du curseur dans le fichier.
 Se déplacer dans un
Ch11 : Les fichiers fichier
fseek :

int fseek(FILE* pointeurSurFichier, long deplacement, int origine);

La fonction fseek permet de déplacer le curseur d'un certain nombre de

caractères (indiqué par deplacement) à partir de la position indiquée
par origine
SEEK_SET : indique le début du fichier ;

SEEK_CUR : indique la position actuelle du curseur ;

SEEK_END : indique la fin du fichier.

Le code suivant place le curseur deux caractères après le début :

fseek(fichier, 2, SEEK_SET);

Le code suivant place le curseur quatre caractères avant la position courante :

fseek(fichier, -4, SEEK_CUR);

Le code suivant place le curseur à la fin du fichier :

fseek(fichier, 0, SEEK_END);
 Renommer/Supprimer
Ch11 : Les fichiers un fichier
fseek :

int fseek(FILE* pointeurSurFichier, long deplacement, int origine);

La fonction fseek permet de déplacer le curseur d'un certain nombre de

caractères (indiqué par deplacement) à partir de la position indiquée
par origine
SEEK_SET : indique le début du fichier ;

SEEK_CUR : indique la position actuelle du curseur ;

SEEK_END : indique la fin du fichier.

Le code suivant place le curseur deux caractères après le début :

fseek(fichier, 2, SEEK_SET);

Le code suivant place le curseur quatre caractères avant la position courante :

fseek(fichier, -4, SEEK_CUR);

Le code suivant place le curseur à la fin du fichier :

fseek(fichier, 0, SEEK_END);
 Récapitulatif
Ch11 : Les fichiers
FILE *FP;
FP = fopen("C:\\main.c", "r");
if (!FP)// CE IF PERMET DE TESTER SI LE FICHIER A ÉTÉ BIEN OUVERT

while (!feof(FP)) // PERMET DE PARCOURIR LE FICHIER JUSQU’À SA FIN

char* fputs(const char* chaine, FILE* pointeurSurFichier);

Ch12 : Les types avancées Structure

Le langage C nous permet de créer nos propres types de variables

Créer et utiliser une structure

Une structure est en fait un regroupement de variables, de n'importe quels

types, ainsi une structure peut contenir des variables de type int, char, double,
...
Contrairement aux tableaux qui eux obligent aux éléments de ce tableau d'être
tous du même type

Tout d'abord il faut savoir qu'il est préférable de créer une structure en dehors
d'une fonction car l'avantage des structures c'est qu'elles permettent un accès à
leurs attributs (= sous-variables qu'elles contiennent) qui s'étend sur toutes les
fonctions du programme.
Ainsi si vous créez une structure dans une fonction, seule celle-ci y'aura accès.
Ch12 : Les types avancées Structure

struct MaStructure { struct MaStructure {

int var1; int var1 = 10;
long var2; long var2 = 40000;
double varN; double varN = 12.5;
}; };

struct personne
{
char nom[20];
char prenom[20]; struct personne p = {« Bentajer", « Ahmed", 1234};
int no_employe;
} p1,p2;
Ch12 : Les types avancées Structure

Accès aux membres des structures

Pour designer un membre d'une structure, il faut utiliser l'operateur de

sélection de membre qui se note . (point)

struct personne P1.nom

{
char nom[20]; P1.nom[2]
char prenom[20];
int no_employe; For(i=0;i<10;i++)
} p1,p2; Printf(‘%c’, p1.nom[i]);
Ch12 : Les types avancées Structure

Accès aux membres des structures

Pour designer un membre d'une structure, il faut utiliser l'operateur de

sélection de membre qui se note . (point)

struct personne P1.nom

{
char nom[20]; P1.nom[2]
char prenom[20];
int no_employe; For(i=0;i<10;i++)
} p1,p2; Printf(‘%c’, p1.nom[i]);

Aucune comparaison n'est possible sur les structures, même pas les
operateurs == et !=.
Ch12 : Les types avancées Structure

Tableaux de structures

Une déclaration de tableau de structures se fait selon le même modèle que la

déclaration d'un tableau don t les éléments son t de type simple.

struct personne t[100];

Pour référencer le nom de la personne qui a l'index i dans t on écrira

T[i].nom
Ch12 : Les types avancées Structure

Pointeurs & structures

struct personne *p;

P = &p1

*p désigne la structure pointée. Pour afficher le nom de la personne on aurait

recours a *p.nom

Mais il faut savoir que les operateurs d’indirection (*) et de sélection (.) ont
eux aussi un ordre de priorité. (l’indirection a une priorité inferieur a celle
de la sélection)

*p.nom sera interprété comme * (p.nom) Cela aurait un sens si p

était une structure dont un des membres s'appelait nom et était un
pointeur.

Dans ce cas il faut ecrire *(p).nom ou p->nom

Ch12 : Les types avancées Structure

Passage d’une structure en paramètre

struct date
{
int jour,mois,annee;
};

Pour ecrire une fonction qui compare deux dates

int cmp_date( struct date d1, struct date d2)

{
….
}
Ch13 : Les Piles et Files Piles

Le principe des piles en programmation est de stocker des données au fur et à

mesure les unes au-dessus des autres pour pouvoir les récupérer plus tard.

algorithme LIFO,

EMPILER DEPILER

1
Ch13 : Les Piles et Files Piles

Implémentation :

L’implémentation des Piles se base sur un tableau P de n éléments.

Le tableau possède un élément sommet qui indique le dernier élément inséré.

La pile se constitue des éléments P[1..sommet] où P[1] est l'élément de base

de la pile (le plus ancien) et P[sommet] est l'élément situé au sommet (le plus
récent).
Ch13 : Les Piles et Files Piles

Traitement

Quand P[sommet] = 0 à La pile est vide

Fonction PileVide(P){
if P[sommet] = 0;
return true;
else
return false;
}

Si P[sommet] > n à Pile déborde. Dépiler une PILE vide provoque

une erreur
Ch13 : Les Piles et Files Piles
Ch13 : Les Piles et Files Files

Le principe des files en programmation est de stocker des données au fur et à

mesure les unes au-dessus des autres pour pouvoir les récupérer plus tard.

algorithme FIFO,

EMFILER DEFILER

1
Ch13 : Les Piles et Files Files

Implémentation :

La FILE représente une liste linéaire ou :

• Toutes les insertions se font par une extrémité (queue arrière)

• Toutes les extractions se font par l’autre extrémité (avant-tete)

Les FILEs correspondent aux Files d’attente : 1er arrive 1er servi
Ch13 : Les Piles et Files Piles

Opération sur les FILES

Les FILEs possèdent un ensemble d’opération qui permettent de les

manipuler

• Création d’une FILE,

• Déterminer si la FILE est vide,
• Déterminer si la FILE est pleine,
• Enfiler
• Défiler
Ch13 : Les Piles et Files Files