Chapitre 1 rappel

ALGORITHMIQUE ET STRUCTURES

DE DONNÉES (ASD)

Université Saad Dahlab de Blida

Faculté des Sciences

Département d’Informatique

Licence d’Informatique

Semestre 3 (2ème année)

Mme AROUSSI

2014-2015

Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/

https://sites.google.com/a/esi.dz/s-aroussi/



PRÉAMBULE

Pré-requis: Cours (Algo1, S1) + (Algo 2, S2).

Volume horaire hebdomadaire: 3H Cours + 3H TD/TP

Évaluation: 2 Interrogations (I1, I2) + Travail Pratique (TP)

+ Examen final.

Un TP test noté sur 17 points; 1,5 points assiduité et 1,5 points

présences

I1 noté sur 8,5 points; I2 noté sur 8,5 points; 1,5 points assiduité et

1,5 points présences

- 0,5 points sera retenue pour chaque absence pendant la séance

de TD ou TP

Moyenne = (Examen x 2 + TD + TP) / 4

Coefficient 5; Crédits 5

2

OBJECTIFS DU COURS

Comprendre les notions d algorithme, de structure de données

et de complexité :

Élaborer des algorithmes performants et efficaces

Comprendre la notion de complexité d’un algorithme

Acquérir la connaissance des structures de données séquentielles

et des algorithmes de base sur les tris, les arbres, et les graphes.

Maîtriser la récursivité (simple, multiple, mutuelle, imbriquée)

Savoir estimer la complexité d’un algorithme itératif ou récursif

3

CONTENU DU COURS

I. Rappels

II. Complexité des Algorithmes

III. Structures Séquentielles (Listes, Files, Piles)

IV. Récursivité

V. Structures Hiérarchiques (Arbres, ABR, Tas)

VI. Hachage

VII. Graphes 4

CHAPITRE I:

RAPPELS

Université Saad Dahlab de Blida

Faculté des Sciences

Département d’Informatique

Licence d’Informatique

Semestre 3 (2ème année)

Algorithmique et Structures de Données

Mme AROUSSI

2014-2015

Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/




PLAN DU CHAPITRE I

Généralités sur l’Algorithmique

Algorithmique et Programmation

Qualités d’un Bon Algorithme

Langage Algorithmique utilisé

Tableaux

Pointeurs

Langage C 6

7

Définition: Un algorithme est suite finie d’opérations

élémentaires constituant un schéma de calcul ou de résolution d’un

problème.

Historique : L’algorithmique est un terme d’origine arabe,

hommage à Al Khawarizmi (780-850) auteur d’un ouvrage décrivant

des méthodes de calculs algébriques.

GÉNÉRALITÉ SUR L’ALGORITHMIQUE

8

GÉNÉRALITÉ SUR L’ALGORITHMIQUE

ÉTAPES DE CONCEPTION D’UN ALGORITHME

Analyse

Conception

Programmation

Test

Définition du problème en terme

de séquences d’opérations de

calcul, de stockage de données

Définition précise des données,

des traitements et de leur

séquencement

Traduction et réalisation de

l’algorithme dans un langage

précis

Vérification du bon

fonctionnement de l’algorithme

9

Définition : Un programme est la traduction d’un algorithme

dans un langage de programmation.

ALGORITHMIQUE & PROGRAMMATION

Langage de bas niveau

Langage de haut niveau

Évolution

Binaire, Assembleur

Procédural (Pascal, C),

Logique (Prolog), ....

Orienté Objet (C++, C#, Java),

....

10

ALGORITHMIQUE & PROGRAMMATION DÉMARCHE DE PROGRAMMATION

Énoncé du problème

Analyse du problème

Algorithme Choisir un langage de

programmation

Programmation (traduction

l’algorithme en programme)

Programme (code source)

Compilation (traduction du code source en

code objet)

Traduction du code objet en code

machine exécutable, compréhensible par

l'ordinateur

Programme binaire

exécutable

Exécution du programme

Résultats

11

QUALITÉ D’UN BON ALGORITHME

Correct: Il faut que le programme exécute correctement ses

tâches pour lesquelles il a été conçu.

Complet: Il faut que le programme considère tous les cas

possibles et donne un résultat dans chaque cas.

Efficace: Il faut que le programme exécute sa tâche avec

efficacité de telle sorte qu’il se déroule en un temps minimal et

qu’il consomme un minimum de ressources.

12

ALGORITHME Nom_de_l’algorithme

DEBUT

manipulation des objets et modules déclarés

FIN

Entête

Environneme

nt

Corps

Déclarations des objets et Modules utilisés

dans l’algorithme

LANGAGE ALGORITHMIQUE UTILISÉ

13

SI expression logique ALORS

DSI

Bloc

FSI

SI expression logique ALORS

DSI

Bloc1

FSI

SINON

DSIN

Bloc2

FSIN

_


LA CONDITIONNELLE ET L’ALTERNATIVE

14

POUR var ALLANT DE vinit A vfinale FAIRE

DPOUR

bloc

FPOUR

TANT QUE condition FAIRE

DTQ

Bloc

FTQ

REPETER

Bloc

JUSQU'A condition


LES BOUCLES

Tout algorithme utilise des objets qui seront déclarés

dans son environnement.

A chaque objet il faudra faire correspondre :

Un NOM qui permettra de le désigner et de le distinguer des autres

éléments,

Un TYPE qui indique la nature de l'ensemble dans lequel l'objet

prend ses valeurs,

Une VALEUR affectée à cet objet à un moment donné.


LES OBJETS

15

ALGORITHME nom_algorithme

Déclarations des étiquettes

Déclarations des constantes

Déclarations des types

Déclarations des variables

Déclarations des sous-programmes

DEBUT

corps de l'algorithme

FIN 16

17

Un type définit l'ensemble des valeurs que peut prendre un objet

qui y est défini ainsi que les opérations autorisées sur cet objet


DÉCLARATION DE TYPES

Scalaire ( Entier, Booléen et

caractère)

Standard

Enuméré

Intervalle

Simple

TYPE

Structuré

Non Scalaire (Réel)

Non

Standard

Tableau

Enregistrement (structure)

Chaine de caractère

Ensemble

18

Exercice 1: Ecrire un algorithme qui

permet de résoudre une équation du second

degré ax2 +bx+c = 0


EXERCICE

19

L'algorithme de résolution de l'équation ax2 + bx + c = 0

(a 0) dans l'ensemble des réels est le suivant:

1. Calcul du discriminant, soit = b2 - 4 a.c

2. Si > 0 alors il y a deux solutions données par les

formules:

x1 = -b + / 4 a . c

x2 = -b - / 4 a. c

1. Si = 0, alors il y a une racine double donnée par

la formule:

2. x = - b / 2 a

3. Si < 0, alors il n y a pas de solution.


SOLUTION

20

ALGORITHME Equation

VAR a, b, c, Delta : REEL

DEBUT

LIRE(a, b, c)

Delta ← b*b – (4*a*c)

SI (Delta > 0) Alors

DSI

ECRIRE( "la première racine est ", - b +

Racine(Delta)/(4*a*c)

ECRIRE( "la deuxième racine est ", - b -

FSI Racine(Delta)/(4*a*c)

SINON

DSIN

SI (Delta = 0) alors

ECRIRE( " Une racine double ", - b / (2*a)

SINON

ECRIRE( " Pas de racine réelle " )


SOLUTION

C’est un objet décomposé en plusieurs éléments de même

type et dont chacun de ces éléments est repéré par un

indice (ou index).

Le nombre d'éléments du tableau constitue sa taille.

Le nombre d’indices qui permet de désigner un élément particulier

est appelée dimension du tableau.

Le type de l’indice est souvent intervalle [0 .. Taille-1].

TABLEAUX

NOTIONS DE BASE

21

7 5 6 3 2 1 1 4 éléments

0 1 2 3 4 5 6 7 Indices

La déclaration d’un tableau se fait en précisant le mot

TABLEAU, suivi du type de l’indice entre crochets et du type

des éléments.

Type Type_tableau = TABLEAU [0..taille-1] DE type_des_éléments, ou

Variable

Nom_du_tableau : Type_Tableau

Nom_du_tableau : TABLEAU [0..taille-1] DE type_des_éléments

L’accès à un élément du tableau s’effectue en précisant le nom du

tableau suivi de la valeur de l’indice entre crochets, e.g: Tab[1].

L'accès à un élément du Tableau peut être direct ou séquentiel.

TABLEAUX

NOTIONS DE BASE

22

On distingue généralement deux classes d’algorithmes:

Les algorithmes de parcours en vu de réaliser un traitement

donné

Les algorithmes de parcours en vu de rechercher une valeur

donnée.

Parmi les algorithmes traitant les tableaux à une

dimension:

Rechercher une valeur dans un tableau

si tableau ordonné alors recherche dichotomique

si tableau non ordonné alors recherche séquentielle

TABLEAUX

ALGORITHMES

23

Parmi les algorithmes traitant les tableaux à une

dimension:

La recherche d’une valeur

L’insertion d’une valeur

La suppression (logique ou physique) d’une valeur

Le remplacement d’une valeur par une autre (la modification)

L’interclassement de deux tableaux ordonnés.

L’union et intersection de deux tableaux.

Le tri d’un tableau: tri par sélection, tri par Bulles, tri par

insertion, tri par fusion, tri rapide, …..

TABLEAUX

ALGORITHMES

24

Un tableau multidimensionnel est considéré comme étant un

tableau dont les éléments sont eux mêmes des tableaux.

Il se définit de la manière suivante :

Nom_du_tableau: TABLEAU [0..N1-1, 0..N2-1, ....., 0..Nd-1] DE

type_des_éléments

d est la dimension du tableau et Ni désigne le nombre d’éléments

dans chaque dimension.

Le nombre de dimensions n'est pas limité .

L'accès à un élément du tableau se fera par l'expression

Nom_du_tableau[i1][i2] …[id] ou Nom_du_tableau[i1, i2,

…, id] .

TABLEAUX MULTIDIMENSIONNELS

25

Exemple: un tableau d'entiers positifs à deux dimensions

(3 lignes, 4 colonnes) se définira avec la syntaxe suivante :

Tab : tableau[0..2, 0..3] d’entier

Le rangement en mémoire centrale du tableau se fait ligne

par ligne.

TABLEAUX MULTIDIMENSIONNELS

26

Représentation du tableau

Tab[0,0] Tab[0,1] Tab[0,2] Tab[0,3]

Tab[1,0] Tab[1,1] Tab[1,2] Tab[1,3]

Tab[2,0] Tab[2,1] Tab[2,2] Tab[2,3]

Recherche séquentielle dans un tableau non ordonné

Recherche séquentielle dans un tableau ordonné

Recherche dichotomique dans un tableau ordonné

On parle d'un tableau ordonné quand l'ensemble des valeurs

possibles est muni d'une relation d'ordre. De plus, un

vecteur est dit ordonné ou trié en ordre croissant si quelque

soit i dans [0, n-1] : T[i] <= T[i+1].

TABLEAUX

EXERCICES

27

Tri par sélection. Rechercher la plus petite valeur et la

placer au début du tableau, puis la plus petite valeur dans

les valeurs restantes et la placer à la deuxième position et

ainsi de suite...

TABLEAUX

EXERCICES

28

7 3 18 13 7 7 3 18 13 7 3 7 18 13 7

3 7 18 13 7 3 7 7 13 18 3 7 7 13 18

3 7 7 13 18

Une variable est destinée à contenir une valeur du type

avec lequel elle est déclarée. Physiquement cette valeur se

situe en mémoire.

Exemple:

x: entier;

x 10;

POINTEURS

VERSUS VARIABLES

29

Un pointeur est aussi une variable destinée à contenir une

adresse mémoire, c.-à-d. une valeur identifiant un

emplacement en mémoire.

Pour différencier un pointeur d'une variable ordinaire, on fait

précéder son nom du signe '*' lors de sa déclaration.

Tout pointeur est associé à un type d’objet. Ce type est celui

des objets qui sont manipulable grâce au pointeur.

Les opérations les plus simples sur un pointeur sont les

suivantes :

affectation d’une adresse au pointeur ;

utilisation du pointeur pour accéder à l’objet dont il contient l’adresse.

POINTEURS

DÉFINITIONS ET OPÉRATIONS

30

Exemple:

x: entier; x 10; px: pointeur d’entier

px &x; // affectation d’une adresse au pointeur ;

*px 20

POINTEURS

DÉFINITIONS ET OPÉRATIONS

31 20

La déclaration de variables réserve de l'espace en

mémoire pour ces variables pour toute la durée de vie du

programme c’est ce qu’on appelle l’allocation statique.

Elle impose par ailleurs de connaître avant le début de

l'exécution l'espace nécessaire au stockage de ces

variables et en particulier la dimension des tableaux.

Or dans de nombreuses applications, le nombre

d'éléments d'un tableau peut varier d'une exécution du

programme à l'autre d’où l’allocation dynamique.

POINTEURS

ALLOCATION DYNAMIQUE DU MÉMOIRE

32

Pour ce faire, on utilise des pointeurs.

Quand on fait une allocation dynamique de mémoire, on

obtient en retour un pointeur sur la zone mémoire allouée.

(fonction allouer(): pointeur)

Exemple:

X: *entier;

X(entier*) Allouer();//réserver de la mémoire pour un entier

Libérer(X); // libérer la mémoire précédemment réservée.

POINTEURS

ALLOCATION DYNAMIQUE DU MÉMOIRE

33

Le tableau sont de grandeur statique, i.e. qu’il est

impossible de les changer de taille après la compilation.

Il est cependant possible de changer la taille après la

compilation. C’est ce qu’on appelle les tableaux

dynamiques.

Pour faire des tableaux dynamiques, il faut réserver un

espace mémoire d’une taille donnée puis d’assigner un

pointeur à cet espace mémoire.

POINTEURS

& LES TABLEAUX

34

Pour faire des tableaux dynamiques, il faut réserver un

espace mémoire d’une taille donnée puis d’assigner un

pointeur à cet espace mémoire.

Exemple:

Tab: *entier;

Tab (entier*)Allouer_Tableau(n);

X Tab[0];

Libérer(tab);

POINTEURS

& LES TABLEAUX

35

Un pointeur sur char peut pointer sur un caractère isolé ou sur

les éléments d'un tableau de caractères. Un pointeur sur char

peut en plus contenir l'adresse d'une chaîne de caractères

constants et il peut même être initialisé avec une telle adresse.

Exemple:

C: * caractère;

C "Ceci est une chaîne de caractères constante";

Pour une chaîne de caractères, on peut tester la présence du

caractère de fin de chaîne '\0‘.

POINTEURS

& CHAÎNES DE CARACTÈRES

36

Une autre utilité des pointeurs est de permettre à des

fonctions d'accéder aux données elles même et non à des

copies.

Exemple:

Procedure permuter(x, y: *entier)

Var

Tmp; entier;

Debut

Tmp *x;

*x *y;

*y tmp;

Fin

POINTEURS

COMME PARAMÈTRES DE FONCTIONS

37

Les objets de type structure (enregistrement) possèdent

une adresse, correspondant à l'adresse du premier élément

du premier membre de la structure.

Exemple:

Eleve : structure {

nom: tableau de caractère [20];

Date: entier;

};

eleve *p; // déclarer un pointeur vers structure

(*p).date // accéder à un élément de structure

POINTEURS

& STRUCTURES

38

On a souvent de modèles de structure dont un des

membres est un pointeur vers une structure de même

modèle. On parle de l’auto-référence

Cette représentation permet de construire des listes

chaînées et des arbres.

Exemple:

POINTEURS

& STRUCTURES

39

Listes chainées Arbres binaires

maillon: structure {

valeur: entier;

suivant: * maillon;

};

noeud: structure {

valeur: entier;

Fils_gauche: * noeud;

Fils_droit: * nœud;

};

Le langage C est né au début des années 1970 dans les

laboratoires AT&T aux Etats-Unis dans le but d’améliorer le

langage existant « B ».

C’est un langage de bas niveau dans le sens où il permet

l’accès aux données (bits, octets, adresses) que manipulent les

machines et qui ne sont pas souvent disponibles à partir de

langages évolués tels que Fortran, Pascal ou ADA

Il a été conçu pour l’écriture de systèmes d’exploitation et du

logiciel de base; Plus de 90% du noyau du système UNIX est

écrit en langage C.

LANGAGE C

PRÉSENTATION

40

Sa popularité : Il possède une communauté très importante

et de nombreux tutoriels et documentations. De plus, il existe

beaucoup de programmes et de bibliothèques développés en et

pour le C.

Sa rapidité : ce qui en fait un langage de choix pour tout

programme où la vitesse est cruciale.

Sa légèreté : ce qui le rend utile pour les programmes

embarqués où la mémoire disponible est faible.

Sa portabilité : i.e qu’un programme développé en C marche

théoriquement sur n’importe quelle plateforme (Windows,

Linus, Unix, Mac, …)

LANGAGE C

POURQUOI L’APPRENDRE?

41

C est un langage qui possède des règles. Ces règles ont été

définies par des informaticiens professionnels et sont toutes

regroupées dans ce que l’on appelle la norme du langage.

Cette norme sert de référence à tous les programmeurs.

Il existe plusieurs normes : l’ANSI en 1989 (C89 ), l’ISO en

1990 (C90), le C99 et le C11.

Dans ce cours, nous allons nous servir de la norme utilisé C89

(http://flash-gordon.me.uk/ansi.c.txt).

En effet, même si c’est la plus ancienne et qu’elle semble restrictive à

certains, elle permet néanmoins de développer avec n’importe quel

compilateur sans problèmes, contrairement aux normes C99 et C11.

De plus, il est très facile de passer aux normes plus récentes ensuite

LANGAGE C

NORME

42

http://flash-gordon.me.uk/ansi.c.txt













Le strict minimum pour programmer en C se résume en

trois points:

Un éditeur de texte: pour écrire le code source.

Un compilateur: pour transformer le code en un fichier

exécutable compréhensible par le processeur.

Un débogueur: fondamentalement, il n’est pas indispensable,

mais il est très utile pour chasser les bugs et vérifier le

comportement de son programme.

LANGAGE C

OUTILS

43

Il existe deux moyens de récupérer tous ces logiciels :

On les prend séparément, et dans ce cas il faut compiler par

soi-même via l’invite de commande,

On utilise un environnement ou logiciel qui intègre les trois

logiciels: un Environnement de Développement Intégré (EDI)

ou Integrated Development Environment (IDE).

De nombreux IDE sont disponibles pour Windows:

Code::Blocks, Dev-C++, Visual C++,.....

Dans les TPs, nous allons nous servir du Code::Blocks

(http://www.codeblocks.org/downloads/binaries)

LANGAGE C

OUTILS

44

Les “mots” du langage C peuvent être classés en 6

groupes élémentaires auxquels il convient d’ajouter les

commentaires au code source.

les mot-clés,

les constantes,

les identificateurs,

les chaines de caractères,

les opérateurs,

les signes de ponctuation,

LANGAGE C

CONCEPTS DE BASE: COMPOSANTS

45

Le langage C contient 32 mots-clés qui ne peuvent pas

être utilisés comme identificateurs :

les spécificateurs de stockage : auto, register, static,

typedef

les spécificateurs de type :char, double, float, int, long,

short, signed, unsigned, struct, enum, union, void

les qualificateurs de type :const, volatile

les instructions de contrôle :break, case, continue, default,

for, while, do, if, else, goto, switch

les autres : return, sizeof, extern

LANGAGE C


46

Le rôle des identificateurs est de donner un nom à une

entité du programme.

Un identificateur peut désigner le nom d’une variable, d’une

fonction, ou d’un type défini par typedef, struct, union ou

enum.

Quelques règles pour le choix des identificateurs :

Ils ne doivent pas être choisi parmi les mots clés

Un identificateur est une chaîne de caractères choisis parmi

les chiffres et les lettres NON ACCENTUEES, en tenant

compte de leur casse (Majuscule ou minuscules). On peut aussi

utiliser le tiret bas (_)

LANGAGE C


47

Quelques règles pour le choix des identificateurs :

Ils ne doivent pas être choisi parmi les mots clés

Un identificateur est une chaîne de caractères choisis parmi

les chiffres et les lettres NON ACCENTUEES, en tenant

compte de leur casse (Majuscule ou minuscules).

On peut aussi utiliser le tiret bas (_)

Le premier caractère de la chaîne ne doit cependant pas être un chiffre

et il vaut mieux que qu’il ne soit pas le tiret bas car il est souvent

employé pour les variables globales de l’environnement C.

Il se peut que le compilateur tronque les identificateurs au delà d’une

certaine longueur (supérieure en général à 31 caractères).

LANGAGE C


48

Un commentaire dans le code source débute par /* et se

termine par */ :

/* ceci est un petit commentaire dans un code source */

On peut également mettre des commentaires courts en

une seule ligne en utilisant // mais on préférera /* */ qui

permet d’écrire des commentaires sur plusieurs lignes.

Les commentaires, bien optionnels, sont fondamentaux.

En effet, ils permettent une compréhension plus facile

d’un code laissé de codé pendant des semaines et sont

utiles lors de la maintenance des programme

LANGAGE C


49

Une expression est une suite de composants

élémentaires qui est syntaxiquement correcte.

x=1 ou (i>=1)&&(i<11)&&(i%2 !=0)

Une instruction est une expression suivie par un point-

virgule (;).

Plusieurs instructions peuvent être réunies entre

accolades pour former une instruction composée ou

bloc, syntaxiquement équivalent à une instruction.

if(x!=0)

{z=y/x;

t=y%x;}

LANGAGE C


50

Une instruction composée d’un spécificateur de type et

d’une liste d’identifiant séparés par une virgule est une

déclaration.

int a, b;

double c;

char message[256];

float d=1.5, x ;

Toute variable utilisée en C doit faire l’objet d’une

déclaration avant d’être utilisée.

LANGAGE C


51

Tout programme C doit contenir au moins une fonction :

C’est la fonction main (fonction principale). L’exécution

du programme commence par l’appel `a cette fonction.

LANGAGE C

CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME

52

La fonction main retourne un objet du type type via une

instruction return resultat ; où resultat doit être

l’identificateur d’une variable de type type .

LANGAGE C

CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME

53

Un programme C est composé d’un ensemble de

fonctions, appelées fonctions secondaires ou auxiliaires

qui sont décrite de la manière suivante :

type FonctionAuxiliaire (arguments ) {

déclaration des variables internes

instructions

return resultat ;}

LANGAGE C

CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (FONCTIONS)

54

type FonctionAuxiliaire (arguments )

La première ligne donne le prototype de la fonction. Il

spécifie :

le nom de la fonction,

le type des paramètres qui doivent lui être fournies séparés par

des virgules

le type de la valeur qu’elle retourne.

Les prototype des fonctions secondaires doivent être

placés avant la fonction main. On parle de déclaration de

fonctions.

LANGAGE C


55

type FonctionAuxiliaire (arguments ) {

déclaration des variables internes

instructions

return resultat ;}

Le corps de la fonction (entre les accolades) est la suite

d’instructions qui doivent être accomplies lorsque la

fonction est appelée.

Les corps de fonctions peuvent quant à eux être placés

indifféremment avant ou après la fonction principale.

LANGAGE C


56

Les directives au préprocesseur indiquent quelles bibliothèques de

fonctions prédéfinies on souhaite pouvoir utiliser dans le programme.

Le plus souvent, la forme des directives au préprocesseur est sous la

forme :

#include<chemin/vers/la/bibliotheque.h>

#include<stdio.h> pour utiliser les fonctions qui permettent de lire et

d’écrire dans les entrées/sorties standard

#include<math.h> pour utiliser les fonctions qui permettent de lire et

d’écrire dans les entrées/sorties standard

#include<stdlib.h> pour utiliser des fonctions traitant de l’allocation

mémoire, de conversion des chaines de caractères en type numériques

ou de tirages à l´aléatoire.

LANGAGE C

CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (DIRECTIVES)

57

LANGAGE C

CONCEPTS DE BASE: STRUCTURE D’UN PROGRAMME (EXEMPLE)

58

Le langage C est un langage typé : toutes les variables et

les constantes, ainsi que les valeurs retournées par les

fonctions sont d’un type spécifié.

Les types de base en C concernent :

les caractères,

les nombres entiers,

les nombres flottants ou réels,

le void, qui représente le vide (on rien). Il n’est pas possible de

déclarer une variable de type void mais ce type est utile,

notamment pour spécifier qu’une fonction ne prend pas

d’argument ou qu’elle ne revoie pas de valeur.

LANGAGE C

CONCEPTS DE BASE: TYPES DE DONNÉES PRÉDÉFINIS

59

Le type caractère ou char (de l’anglais “character”)

permet de représenter les caractères de la machine

utilisée qui sont représentés sous forme d’entiers

conforme au jeu de caractères ISO-8859.

Ce jeu de caractère est codé sur 8 bits (un octet) dont les

128 premiers caractères correspondent au code ASCII, les

128 derniers étant utilisés pour coder les caractères

spécifiques (accentués, cyrilliques, de la langue arabe,

etc...)

LANGAGE C


60

Le mot-clé désignant une donnée de type entier est int

(de l’anglais integer).

On peut faire préceder le mot-clé int par un attribut de

précision (short ou long) et/ou d’un attribut de

représentation (signed ou unsigned).

LANGAGE C


61

Remarque à propos des booléens : Le langage C

(jusqu’à la norme C99) ne fournit pas de type booléen. La

valeur entière 0 prend la valeur de vérité FAUX et toutes

les autres valeurs entières prennent la valeur de vérité

VRAI. Autrement dit :

toute expression utilisant des opérateurs booléens, retourne 0

si l’expression est fausse, et retourne quelque chose de non

nul si l’expression est vraie

LANGAGE C


62

Les types float, double et long double sont utilisés

pour représenter des nombres à virgule flottante, qui

correspondent à des approximations de nombres réels à

des degrés de précision différents.

LANGAGE C


63

Une expression est une suite de symboles formée à

partir de constantes littérales, d’identificateurs et

d’opérateurs:

-x,

– x+12,

– (x>4)&&(x<10).

Une expression est destinée à être évaluée. Elle a

toujours un type et une valeur.

LANGAGE C

CONCEPTS DE BASE: EXPRESSIONS

64

L’affectation en C est symbolisée par le signe =.

variable = expression

Cet opérateur évalue l’expression « expression » et affecte

le résultat à la variable « variable » .

L’affectation effectue une conversion de type implicite : si

la variable et le résultat de expression ne sont pas du

même type, alors le résultat de expression est convertie

dans le type de variable .

Si la conversion est impossible, alors un message d’erreur

est renvoyé.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (AFFECTATION)

65

Puisque tous les types sont représentés sous forme

binaire (0 et 1), on peut convertir un objet d’un certain

type dans un autre type. On parle de l’opération de

transtypage (cast en anglais).

Cette opération peut être réalisée de deux manières :

Conversion implicite : qui consiste en une modification du

type de donnée effectuée automatiquement par le compilateur

int x;

x = 8.324;

x contiendra après affectation la valeur 8.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (TRANSTYPAGE)

66

Cette opération peut être réalisée de deux manières :

Conversion implicite : qui consiste en une modification du type

de donnée effectuée automatiquement par le compilateur

int x; x = 8.324; //x contiendra après affectation la valeur 8.

Conversion explicite (appelée aussi opération de cast) consiste

en une modification du type de donnée forcée. L’opérateur de cast

est tout simplement le type de donnée dans lequel on désire

convertir une variable, entre des parenthèses précédant la

variable.

int x; x = (int) 8.324;//x contiendra après affectation la valeur 8.

La conversion explicite est à privilégier car elle n’est

pas ambigüe.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (TRANSTYPAGE)

67

Les opérateurs arithmétiques classiques sont :

l’opérateur unaire de changement de signe : -,

les quatre opérations usuelles : +, -, *, /,

l’opérateur modulo : % qui donne le reste de la division entière

Les opérateurs d’affectation composée usuels sont

les suivants : += , -= , *= , /= , %=

Ce “raccourcis” (exp1 op= exp2) est équivalent à exp1 =

exp1 op exp2

L’avantage de ces notations est que exp1 n’est évaluée qu’en

seule fois lorsqu’on utilise l’opérateur composé, alors qu’elle

est évaluée 2 fois sinon.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (ARITHMÉTIQUES)

68

Les opérations du type i=i+1 ou j=j-1 apparaissent très

souvent dans des boucles. Le langage C mis à notre

disposition l’opérateur d’incrémentation ++ et

l’opérateur de décrémentation - -.

Ces deux opérateurs s’utilisent en suffixe ou en préfixe :

les instructions i=i+1;, i++; et ++i; incrémente i de 1.

La différence réside dans la valeur de l’expression :

int i=5,j,k; int i=7,l,m;

j=i++; /* j=5 puis i=6 */ l=i--; /* l=7 puis i=6 */

k=++i; /* i=7 puis k=7 */ m=--i; /* i=5 puis m=5 */

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (ARITHMÉTIQUES)

69

Pour comparer deux expressions exp1 et exp2 , on dispose

des opérateurs booléens de comparaison classiques :

Egalité : exp1 == exp2 ,

Inégalités strictes : exp1 < exp2 et exp1 > exp2 ,

Inégalités larges : exp1 <= exp2 et exp1 >= exp2 ,

Différence : exp1 != exp2 .

Les deux expressions exp1 et exp2 sont évaluées puis

comparées. Si la relation est fausse, alors cet opérateur

renvoie false (équivalent à l’entier 0) et renvoie true

(équivalent à un entier non nul) si la relation est vérifiée.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (DE COMPARAISON)

70

Les opérateurs logiques sont

la négation : !(exp ),

le ET logique : exp1 && exp2 ,

le OU logique : exp1 || exp2.

De même que les opérateurs de comparaison, les deux

expressions exp1 et exp2 sont évaluées puis comparées.

Si la relation est fausse, alors cet opérateur renvoie false

(équivalent à l’entier 0) et renvoie true (équivalent à un

entier non nul) si la relation est vérifiée.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (LOGIQUES)

71

L’opérateur d’affectation conditionnel ternaire

exp1 ? exp2 : exp3

Cet opérateur renvoie exp2 si exp1 est vraie et renvoie

exp3 sinon.

Exemple : l’instruction m= a>b? a:b; affecte à m le

maximum de a et de b

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS

72

L’opérateur sizeof permet de calculer la taille

correspondant à un type.

sizeof (descripteur-de-type) représente la taille

(exprimée en octet) qu’occuperait en mémoire un objet

possédant le type indiqué

sizeof exp représente la taille qu’occuperait en

mémoire un objet possédant le même type que exp.

sizeof t ou sizeof t[0] où t est un tableau de taille n.

Cette formule exprime le nombre d’éléments ou la taille

de t.

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS

73

Ordre de priorité des opérateurs (par ordre décroissant) :

1. ( ), [ ]

2. - unaire, !, ++, - - , sizeof

3. * , / , %

4. +, -

5. <, >= , <= , >

6. == , !=

7. &&

8. ||

9. ?:

10.=, *= , /= , += , -= , %=

LANGAGE C

CONCEPTS DE BASE: OPÉRATEURS (PRIORITÉS)

74

Une instruction de branchement conditionnel a la forme

suivante :

if( test ){

instructionsIF }

else{

instructionsELSE }

Les accolades ne sont pas nécessaires si le bloc d’instruction IF

ou ELSE ne contient qu’une seule instruction.

Toutes les tests doivent être entre parenthèses.

Le bloc else est optionnel

LANGAGE C

CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (CHOIX)

75

Le bloc switch est une instruction de choix multiple qui

permet de choisir un bloc d’instructions à réaliser parmi un

ensemble d’instructions possibles, en fonction de la valeur

d’une expression. switch( exp ){

case val-1 : instructions-1

break ;

case val-2 : instructions-2

break ;

...

case val-N : instructions-N

break ;

default : instructions

break ;

}

LANGAGE C

CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (CHOIX MULTIPLE)

76

Si l’évaluation de l’expression exp donne

une valeur v parmi val-1 , val-2 , ... val-

N alors les instructions instructions-v

relatives à cette valeurs sont effectuées.

L’instruction break fait ensuite sortir le

programme du block switch.

Le cas default permet d’englober toutes

les cas où exp donne une valeur qui n’est

pas parmi val-1 , val-2 , ... val-N

LANGAGE C

CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (CHOIX MULTIPLE)

77

Le langage C offre trois structures pour exécuter une boucle :

LANGAGE C

CONCEPTS DE BASE: STRUCTURES DE CONTRÔLE (BOUCLES)

78

Tant que Pour

while( exp ){

instructions

}

do{

instructions

} while( exp ) ;

for( exp1 ; exp2 ; exp3 ){

instructions

}

exp est le test de continuation qui

renvoie un booléen

exp1: l’initialisation,

exp2: la condition de continuation,

exp3: l’´evolution de la variable dont

dépend la condition de continuation

Tant que le test de

continuation est

vrai, le corps de la

boucle est effectué.

Faire le corps de la

boucle tant que le

test de

continuation est

vrai

Une formulation équivalente plus

intuitive est la suivante :

exp1 ;

while(exp2 ){

exp3 ;

instructions

}

Ces trois instructions sont équivalentes. Cependant,

Lorsque le nombre d’itérations dépend d’un paramètre dont les

valeurs initiale et finale et l’incrémentation sont connus avant

l’exécution de la boucle, on utilise plutôt une boucle for.

Dans le cas où le test de sortie, et donc le nombre d’itérations,

dépendent d’un calcul fait dans le corps de la boucle ou que celui-ci ne

peut s’apparenter à une incrémentation simple, on utilisera un boucle

while ou do ... while plutôt que for.

La boucle do ... while permet d’effectuer une fois les instructions

avant de faire le test alors que while effectue en premier lieu le test

(les instructions peuvent ne jamais être effectuées).

LANGAGE C


79

Instructions de branchement non conditionnel dans les

boucles: break et continue

LANGAGE C


80

break continue

Rôle Permet d’interrompre

l’exécution des instructions du

bloc et termine la boucle.

Permet d’interrompre l’exécution

des instructions du bloc et de

retourner au test de

continuation.

Exemple for(int i=1;i<5;i++){

if(i==3) break;

printf("i=%d, ",i);

}

printf("\n valeur de i en sortie

de boucle: %d",i);

for(int i=1;i<5;i++){

if(i==3) continue;

printf("i=%d, ",i);

}

printf("\n valeur de i en sortie

de boucle: %d",i);

Exécution i=1, i=2

valeur de i en sortie de boucle: 3

i=1, i=2, i=4, i=5

valeur de i en sortie de boucle: 5

Chaque unité d’entrée ou de sortie constitue un flux de

données.

L’entête <stdio.h> (abréviation de standard in-out) fournit

trois flux que l’on peut utiliser directement :

stdin, l’entrée standard qui envoie au programme les données

issues du clavier,

stdout, la sortie standard qui envoie les données que le programme

génère à l’écran,

stderr, la sortie standard des erreurs qui seront affichées sur l’écran.

LANGAGE C

FONCTIONS D’ENTRÉES-SORTIES

81

La fonction d’écriture sur l’unité de sortie standard avec

conversion et mise en forme des données est :

printf (format, exp1, exp2, ... expn)

Le paramètre « format » contient les caractères à afficher et les

spécifications de format d’écriture correspondants aux paramètres exp1,

exp2 , ..., expn .

Ces spécifications sont introduites par le signe % (pour afficher

simplement le signe pourcentage à l’écran, on utilisera %%).

Les chaines du type %zz seront remplacées à l’impression par les valeurs

des expressions exp1, exp2, ... expn.

Si la valeur d’une expression n’est pas du type indiqué par le format,

celle-ci sera convertie.

LANGAGE C

FONCTIONS D’ENTRÉES-SORTIES (PRINTF)

82

LANGAGE C


83

Format Type de donnée Écriture

%d int Entier signé sous forme décimale

%ld long int Entier signé sous forme décimale

%u

%o

%x

unsigned int Entier non signé sous forme décimale

Entier non signé sous forme octal

Entier non signé sous forme hexadécimale

%lu

%lo

%lx

unsigned long int Entier non signé sous forme décimale

Entier non signé sous forme octal

Entier non signé sous forme hexadécimale

%f

%e

%g

double Réel, virgule fixe

Réel, notation exponentielle

Réel, présentation la plus compacte parmi %f et %e

%lf

%le

%lg

long double Réel, virgule fixe

Réel, notation exponentielle

Réel, présentation la plus compacte parmi %f et

%c char Caractère

%s char * Chaîne de caractère

%p pointeur Adresse sous forme hexadécimale

On peut préciser certains paramètres du format d’impression

en insérant une précision entre le symbole % et le ou les

caractères précisant le format :

Pour les entiers, on peut spécifier la largeur du champs minimal

d’impression (e.g. %10d, %-10d)

Pour les flottants, on peut raffiner l’utilisation de %f et %lf en

choisissant le nombre de chiffres après la virgule (e.g. %.4f, %6.4f).

Pour les chaînes de caractères, on peut spécifier la plage réservée à

l’écriture des caractères d’une chaîne ainsi que le nombre des

caractères qui seront imprimés (e.g. %30.4s)

LANGAGE C


84

LANGAGE C


85

Exercice: Donner les messages qui seront affichés après

l’exécution de ce programme:

La fonction « scanf » permet de lire des valeurs sur l’unité

d’entrée standard, selon un format spécifié en argument et les

inscrire dans des cases mémoires dont les adresses sont

fournies en arguments.

Son appel a la forme suivante :

scanf (format, arg1,arg2,...,argn)

Souvent, les arguments argi présentent des adresses mémoires

où sont stockées des variables et sont donc de la forme &vari

où vari est l’identificateur d’une variable et & est l’opérateur

d’adressage:

scanf (format, &var1, &var2,..., &varn)

LANGAGE C

FONCTIONS D’ENTRÉES-SORTIES (SCANF)

86

Comme pour printf, la chaine « format » contient les

spécifications de format des caractères à récupérer à partir du

flux d’entrée

LANGAGE C

FONCTIONS D’ENTRÉES-SORTIES (SCANF)

87

La déclaration d’un tableau monodimensionnel a la forme

suivante :

type Nom_Tab [Nbr_elt] ;

Cette déclaration crée du tableau, composé de « Nbr_elt »

éléments de type « type » et désigné par l’identificateur «

Nom_Tab ».

« Nbr_elt » est la taille du tableau et doit être un entier

strictement positif.

Une telle déclaration alloue un espace mémoire de

sizeof(type)*Nbr_elt octets consécutifs pour stocker le tableau.

LANGAGE C

TABLEAUX STATIQUES

88

type Nom_Tab [Nbr_elt] ;

Les éléments du tableau sont numérotés de 0 à Nbr_elt -1.

On peut accéder à chaque élément en utilisant l’opérateur [ ].

Exemple: int Tab[10];

for(int i=0; i<10 ; i++) Tab[i] = 1;

On peut également initialiser un tableau lors de sa déclaration

par une liste de constantes :

type Nom_Tab [N] = {const-1,const-2,...,const-N};

Si le nombre de données dans la liste d’initialisation est

inférieur à la taille du tableau, seuls les premiers éléments

seront initialisés.

LANGAGE C

TABLEAUX STATIQUES

89

Exemple: int Tab[10];

for(int i=0; i<10 ; i++) Tab[i] = 1;

On peut également initialiser un tableau lors de sa déclaration

par une liste de constantes :

type Nom_Tab [N] = {const-1,const-2,...,const-N};

Si le nombre de données dans la liste d’initialisation est

inférieur à la taille du tableau, seuls les premiers éléments

seront initialisés.

On peut omettre la taille du tableau dans le cas d’une

déclaration avec initialisation et utiliser l’instruction suivante

: type Nom_Tab [] = {const-1,const-2,...,const-N};

LANGAGE C

TABLEAUX STATIQUES

90

Le langage C permet également de déclarer des tableaux

multidimensionnels:

type Nom_Tab [taille-1][taille-2][taille-3]……[taille-m];

Exemple: L’initialisation d’un tableau bidimensionnel,

comme représentant la matrice ci contre se fait pas le

biais d’une liste de listes comme suit:

int TAB[2][3] = {{1,2,3},{4,5,6}};

Ou simplement: int TAB[2][3] = {1,2,3,4,5,6};

LANGAGE C

TABLEAUX STATIQUES

91

1 2 3

4 5 6

Une chaîne de caractère est un tableau de caractères

dont la fin est marquée par le symbole \0.

Elle est donc désignée par l’adresse de son premier

caractère ou par l’adresse du caractère \0 si la chaine est

vide.

Exemple: une chaine s contenant le mot “Bonjour” est

initialisée ainsi : char s[8] = {’B’,’o’,’n’,’j’,’o’,’u’,’r’,’\0’};

char s[] = {’B’,’o’,’n’,’j’,’o’,’u’,’r’,’\0’};

char s[8] = "Bonjour";

char s[] = "Bonjour";

LANGAGE C

CHAÎNES DE CARACTÈRES

92

Si on déclare une chaine de caractère sans l’initialiser

char s[8]; on ne pourra PAS effectuer à posteriori une

affectation du type : s = "Bonjour"; car s est le nom d’un

tableau et donc chaque lettre doit être affectée

séparément.

Pour comparer deux chaines de caractères, il faudra les

comparer caractère par caractère... Ou bien se bénéficier

des fonctions utiles de la bibliothèque standard

string.h : calculer leur longueurs (strlen), les

comparer (strcmp), les concaténer (strcat), etc...

LANGAGE C

CHAÎNES DE CARACTÈRES

93

Une structure est une suite finie d’objets de différents types,

stockées de manières contigüe. Chacun de ces objets est appelé

champs ou membre de la structure et possède un

identificateur.

La déclaration d’un modèle de structure permet de définir le

nom du modèle ainsi que les types et les identificateurs des

différents champs que comporte le modèle.

LANGAGE C

STRUCTURES

94

struct Nom_Structure {

type1 Nom champs-1 ;


...

typeN Nom champs-N ;

};

…..

struct Nom_Structure Nom _variable ;

struct Nom_Structure {



...

typeN Nom champs-N ;

} Nom_variable ;

Lorsqu’une variable d’un type structuré est déclarée, on

peut accéder à ses différents champs via l’opérateur

champs de structure, matérialisé par un point “.”:

Nom variable.Nom champs-i

On peut initialiser les variables structurées lors de leur

déclarations. Par exemple:

struct Point {

char nom;

float x, y;

};

struct Point p1 = {’A’,2.5,1.};

LANGAGE C

STRUCTURES

95

Un pointeur est un objet dont la valeur est égale à

l’adresse d’un autre objet.

On déclare un pointeur en utilisant l’instruction :

type *ptr ;

L’identificateur «ptr» est associé à un entier (en général de

type unsigned long int) dont la valeur pourra être l’adresse

d’une variable de type « type ».

On dit que le pointeur « ptr » pointe vers un objet de type «

type » .

Exemples: int *p1; char *p2; struct personne *p3;

LANGAGE C

POINTEURS

96

Par défaut, lorsqu’on définit un pointeur sans l’initialiser,

il ne pointe sur rien : la valeur d’un pointeur est alors

égale à une constante symbolique noté NULL (définie

dans l’en-tête <stdio.h>) qui vaut ’\0’ en général.

Le test ptr == NULL permet donc de savoir si un pointeur

pointe vers quelque chose ou pas.

Les pointeurs peuvent également être des éléments d’un

tableau, ou un champs d’une structure. Par exemple:

struct personne *liste[50];

LANGAGE C

POINTEURS

97

L’utilisation des pointeurs permet également de déclarer

un type de structure de manière récursive

(autoréférence).

Exemple : struct personne {

char nom[30];

struct personne *mere;

struct personne *pere;

}

Les pointeurs peuvent également être passés comme

arguments ou comme type de retour de fonctions.

LANGAGE C

POINTEURS

98

Pour accéder à la valeur d’une variable pointée par un

pointeur, on utilise l’opérateur unaire d’indirection : *.

Exemple: double *p;

double n;

n=3;

p=&n;

printf("*p= %d\n",*p); //imprimera à l’écran 3.

LANGAGE C

POINTEURS

99

L’initialisation d’un pointeur peut s’effectuer:

Par une affectation (ptr=&variable), si on souhaite faire

pointer sur une variable existant déjà dans le programme,

Par une réservation d’un espace mémoire de taille adéquate,

puis en lui affectant directement une valeur.

L’allocation dynamique est l’opération consistant à

réserver une place mémoire pour stocker l’objet pointé

par ptr.

Elle s’effectue à l’aide des fonctions disponibles dans la

bibliothèque <stdlib.h> tel que: malloc, calloc, free, …...

LANGAGE C

POINTEURS

100

void* malloc (size_t size ) ;

Cette fonction renvoie un pointeur pointant vers un objet de

taille size octets.

Le type void* est un passe-partout, il permet de remplacer

n’importe quel autre type.

Pour initialiser les pointeurs vers des objets de type

différents, on effectue un transtypage au moment de

l’initialisation.

type * ptr =(type *) malloc(sizeof(type)) ;

LANGAGE C

POINTEURS (MALLOC)

101

Pour initialiser les pointeurs vers des objets de type

différents, on effectue un transtypage au moment de

l’initialisation.

type * ptr =(type *) malloc(sizeof(type)) ;

Pour allouer une plage mémoire à un tableau de N

éléments de type « type », on appelle la fonction malloc

ainsi : type *Tab= malloc(N *sizeof(type )) ;

LANGAGE C

POINTEURS (MALLOC)

102

void* calloc(size_t Nb Elements, size_t Taille Element ) ;

La fonction calloc permet d’allouer dynamiquement de la place

mémoire mais initialise également toutes les valeurs de

cet espace mémoire à zéro.

Elle renvoie un pointeur sur une plage mémoire de taille Nb

Elements *Taille Element .

Pour allouer une plage mémoire à un tableau de N

éléments de type « type » qui sera pointé par « ptr » et

dont les valeurs sont initialisées à zéro:

type *ptr = (type *)calloc(N,sizeof(type)) ;

LANGAGE C

POINTEURS (CALLOC)

103

void free(void *Nom_Pointeur )

La fonction « free » permet de libérer l’espace mémoire

alloué à un pointeur « Nom_Pointeur ».

Cette fonction doit être utilisée lorsqu’on n’a plus besoin

d’utiliser les données vers lesquelles pointent le pointeur «

Nom_Pointeur » et permet à les cases mémoires contenant

*Nom_Pointeur de pouvoir être de nouveau utilisées en cas

d’autre affectation.

Le pointeur *Nom Pointeur existe toujours et peut être

réutilisé dans le programme. Par contre la valeur de *Nom

Pointeur n’est pas conservée.

LANGAGE C

POINTEURS (FREE)

104

SOURCES DE CE COURS

105

N. EL-ALLIA , Cours d’Algorithmique et Structures de données

dynamiques, Ecole nationale Supérieure d’Informatique (ESI), 2010.

Djamel Eddine ZEGOUR, Cours de Structures de Données, Ecole nationale

Supérieure d’Informatique (ESI), Disponible sur

http://zegour.esi.dz/Cours/Cours_sdd.htm

M. Le Gonidec, Introduction à la Programmation – Pratique du Langage C

–, Université du Sud, disponible sur http://legonidec.univ-tln.fr/0-Cours.pdf

Maude Manouvrier, Initiation à la Programmation Procédurale, à

L'algorithmique Et aux structures de Données par le Langage C,

Université Paris Dauphine, 2015, disponible sur

http://www.lamsade.dauphine.fr/~manouvri/C/Polys_C_MM.pdf

Christian Bac, Support de Cours de Langage C; 2013; Disponible sur

http://picolibre.int-evry.fr/projects/svn/coursc/Index.pdf










http://legonidec.univ-tln.fr/0-Cours.pdf




































Chapitre 1 rappel

Education

Transcript of Chapitre 1 rappel