UNIVERSITE ABDELMALEK ESSAADI

FACULTE DES SCIENCES ET TECHNIQUES

TANGER

Module : Programmation Orientée Objet

( POO )

Département Génie Informatique

Le C++
Filière : Cycle Ingénieur EEA - GM

Faculté des Sciences et Techniques A . U : 2010 / 2011

 Déroulement du Cours et
Evaluation
Activités Pratiques Evaluation


 Pré-Requis: 2 Contrôles
 (Algorithmique et
TP+Projet
programmation en
Lanagage c) 
NOTE
 Exposé CC1 (25%) CC2 (25%) TP+Projet
 Lié à la POO (50%)

 Mini-Projets
 De taille moyenne,
N o te M in im a le
  Approfondir
se s
re q u ise p o u r va lid e r
connaissance le m o d u le e st 12 / 20
Note s sur la AAA
de rattrapage :
Note = 0 . 67 [ Sup ( CC2 ; Note_Rattrapage )]
+ 0 . 33 ( CC1 + TP + Exposés )
2
 Programme (Partie 1)
Rappel général et Mise à Niveau (le
langage C)
• Les Opérateurs / Le types / Les
Variables
• Les Structures de contrôles (Les
Tests)
• Les Boucles
• Les fonctions
• Les Pointeurs
• Tableaux et chaînes de caractères
• Les Fichiers
• Les Structures
• Les Listes Chainées
3 • Les Arbres Binaires 12/08/10
 Programme (Partie 2)
Programmation Orientée Objet
o Introduction
o Problématique
o Notion :
• De classe,
• D’objet,
• De Méthodes et Attributs,
• D’héritage,
• De polymorphisme,
• D’encapsulation,
La langage C++
Introduction à la Programmation en
Java

4 12/08/10
Le Langage C

PARTIE 1
 Rappel général et Mise à Niveau
 Rappel général et mise à
PARTIE 1

niveau
Les Opérateurs
 L’Affectation:


 Identificateur_de_variable = expression


 Exp:
Arithmétiques
A=5; Opérateurs
+ , * , - ,Logiques
&& , || , ! De comparaison incrémentation
< ,> ++, --
A=A+1; / ,<=,>=, !
B=A*2;
=,==
SOMME=A+B;

6
 Rappel général et mise à
PARTIE 1

niveau
Les Types
4 types de base, les autres types seront dérivés de ceux-
ci.
Type Signification Exemples de valeur Codage en Peut être
mémoire

char Caractère unique 'a' 'A' 'z' 'Z' '\n' 'a' 'A' 'z' 'Z' 1 octet signed,
'\n' unsigned
Varie de –128 à 127
int Nombre entier 0 1 -1 4589 32000 2 ou 4 octets Short, long,
-231 à 231 +1 signed,
unsigned
float Nombre réel 0.0 1.0 3.14 5.32 4 octets
simple -1.23

double Nombre réel 0.0 1.0E–10 1.0 8 octets long

double précision -1.34567896
 Rappel général et mise à
PARTIE 1

niveau
Les Types
 Il existe un certain nombre de qualificateurs qui
peuvent être associés aux types de base :
 short : s'applique aux entiers 
(short int : entier codé sur deux octets)
 long : s'applique aux entiers (long
int: entier codé sur quatre octets) et aux
nombres à virgule flottante double précision 
(long double : double précision étendue)
 signed : s'applique au type char (de -128 à 127) ou
aux types entiers (de -2n-1 à 2n-1 -1, n étant le nombre
de bits utilisés).
 unsigned : s'applique au type char (de 0 à 255) ou
aux types entiers (de 0 à 2n-1 ).


8
 Rappel général et mise à
PARTIE 1

niveau
Le Mot clé Typedef

Apermet de renommer un type.
Syntaxe:
 typedef type nouveau_type ;
Exp:

Typdef short type1;

Typdef int type2;

Typdef struct ETUD STR_ETD;

9

 Rappel général et mise à
PARTIE 1

niveau
Les Variables
 Les variables sont des unités de stockage
dont l'objectif est de mémoriser des valeurs qui peuvent
être le résultat de calculs intermédiaires.
 Une variable est désignée par un
identificateur.
 Une variable est typée.
 i.e : (elle peut contenir et mémoriser des valeurs d'un
seul type.) ?
var1
 Syntaxe: Var 6

……….
……….
 nom_type indent_var1,ident_var2,…,ident_varn; Var i
 ………
Mémoire
10
 const nom_type ident_var;

 Rappel général et mise à
PARTIE 1

niveau
Les Structures de contrôles ( TESTS)
 L'instruction if …..else… :
 Syntaxe:


 if (condition) instruction1 else instruction2

 instruction1 est exécutée si condition est différent
de 0.
 instruction2 est exécutée si condition vaut 0.
Si Condition # 0
Condition ? Instruction 1

Si Condition = 0

Instruction 2
11
 Rappel général et mise à
PARTIE 1

niveau
 Les Structures de contrôles ( TESTS)
 L'instruction switch
 L'instruction permet d'effecter un choix entre
plusieurs possibilités. Il s'agit d'un opérateur de
branchement.
Syntaxe:

 switch(expression)
 {
 case const1 : instruction1
 case const2 : instruction2
 ...
 default : instruction_def
 }

12
 Rappel général et mise à
PARTIE 1

niveau
Les Boucles


While For do … while

while (expression) for ( exp1;exp2;exp3) do
{ { {
Exemples:
instruction1; Instruction1; instruction1;
….. …. …..
while(n<=0)
} For(i=0;i<n;i++)
} do }
{ { {
while ( expression);
Printf(“Donner n”); Printf(“Donner n”); Printf(“Donner n”);
Scanf(“%d”,&n); Scanf(“%d”,&n); Scanf(“%d”,&n);
} } } while(n<=0)

13
 Rappel général et mise à
PARTIE 1

niveau
bon programme?

Il doit résoudre le
PROBLEME  !

Efficacité Rap
idité?

INSTANTANE  ! DUREE DE
VIE ? 
- Lisible
- Structuré

14
 Rappel général et mise à
PARTIE 1

niveau
Exigence de qualité d’un programme :

 Clarté
 Simplicité
 Efficacité
 Modularité
 Extensibilité

15
 Structure d'un programme C
PARTIE 1

#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(intx);
int fonc2(int x); Déclaration des fonctions
voidmain()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */

int fonc1(intx) {
return x; Définitions des
}
fonctions
int fonc2(intx) {
return (x * x);
}
16
 Rappel général et mise à
PARTIE 1

niveau
Les Fonctions

A Encapsule un traitement particulier formant un

tout :

•       Peut implémenter la notion de module en logique

•       Notion de librairie
•       Augmente la lisibilité d’un programme
•       Réalise un objectif précis

 Son utilisation se décompose en trois phases  :

•       Définition de la fonction

•       Déclaration de la fonction
•       Appel de la fonction

17
 Rappel général et mise à
PARTIE 1

niveau
Déclaration d ’ une Fonction :

TYPE de la valeur de 3 valeurs de type

retour float comme
paramètres
int Moyenne(float note1, float note2, float note3)
{
double moy;

moy = 1/3*(note1+note2+note3); Nom de la

fonction
return moy;
}

18 Valeur
renvoyée
 Rappel général et mise à
PARTIE 1

niveau
Appel d ’ une Fonction :
IMPORTANT : cette
#include <stdio.h> instruction spécifie
comment la fonction est
définie
int Moyenne(float, float, float);
void main(void)
{
int n1,n2,n3; Le compilateur attend des
float ; les conversions
n1=10; sont automatiques
n2=16;
n3=19;
Moyenne(n1,n2, n3);
}

Ici , on ne tient pas compte de la valeur de

retour
19
 Rappel général et mise à
PARTIE 1

niveau
Fonction Récursive :

Une fonction est dite récursive, dès lors ou elle se fait appel pour
calculer une sous partie de la valeur finale qu'elle retournera.

int fact( int n ); int fib( int n )

{
if ( n < 2 ) {
return 1; if ( n < 2 ) return n ;
}
else { else return fib( n - 1 ) +
return (( int ) n * fact ( n - 1 ) ); fib( n - 2 );
}
}
printf ("% d\n ", fib ( 10 ));

Fonction
FonctionFactorielle
Fibonacci

20
 Rappel général et mise à
PARTIE 1

niveau
Les Fonctions

1.
2.
3 . Ecrire le programme qui permet de saisir un nombre réel
et de vérifier sa parité ( pair ou impaire ).
4.
5 . Ecrire la fonction age ( ? ) qui renvoie l ’ âge , en jours ,
d ’ une personne en saisissant sa date de naissance
( jour , mois , année ).
6.

21
 Rappel général et mise à
PARTIE 1

niveau
Les Tableaux
Les tableaux sont utilisés pour manipuler un ensemble de
données du même type.
Les éléments du tableaux sont indexés par des entiers.

 Tableau Unidimensionnel
tab [ i ]:
Int tab [ 6 ]={ 9 , 4 , 17 , 12 , 15 , 100 , 120 }; Initialisation du Tableau

9 4 17 12 15 100 120
tab [ 0 ] tab [ 1 ] tab [ 2 ] ……………………… tab [ 6 ]

For ( i = 0 ; i <= 6 ; i ++) tab [ i ]= 0 ; Initialisation à 0

du Tableau

0 0 0 0 0 0 0
22
tab [ 0 ] tab [ 1 ] tab [ 2 ] ……………………… tab [ 6 ]
 Rappel général et mise à
PARTIE 1

niveau
Les Tableaux

1.
2.
3 . Ecrire le programme qui permet de calculer la moyenne
des éléments d ’ un tableau .
4 . Ecrire le programme qui permet de copier le contenu d ’ un
tableau dans un autre .
5 . Ecrire un programme qui permet de remplir un tableau de
caractères et calcul le nombre de voyelles saisis .
6.
7.

23
 Rappel général et mise à
PARTIE 1

niveau
Les Tableaux
 Tableau multidimensionnels :
Un tableau multidimensionnel se définit de la manière
suivante :
type Nom_du_tableau [a 1 ][a 2 ][a 3 ] ... [a n ]
J : 0A
Exemple 1 :
tab [ 0 ][ 0 ] tab [ 0 ][ 1 ] tab [ 0 ][ 2 ]

i
Int tab[2][3];
tab [ 1 ][ 0 ]

: 0A
tab [ 1 ][ 1 ] tab [ 1 ][ 2 ]

int i,j;
for (i=0; i<=1; i++)
{
for (j=0; j<=2; j++)
{ 0 0 0
Tableau[i][j] = 0; 0 0 0
}
}
24
 Rappel général et mise à
PARTIE 1

niveau
Les Tableaux

1.
2.
3 . Ecrire le programme qui permet de calculer la moyenne
par ligne des éléments d ’ un tableau de deux dimensions .
4 . Ecrire le programme qui permet de calculer la somme des
éléments diagonales d ’ une matrice M( n , n );
5 . Ecrire le programme qui permet de calculer la transposée
d ’ une matrice M( n , n );
6.

25
 Rappel général et mise à
PARTIE 1

niveau
Les Pointeurs :

 Un pointeur est une variable particulière, dont la valeur est l'adresse
 d'une autre variable.
Exxemple :
i nt v a l= AAA
cha r r e p=’ a ’ A
i nt *ptr  A * d é c l a r a t i on
d ’un po i nt e ur sur e nt ie r * 
cha r *ptr AA  * d é c l a r a t i on
d ’un po i nt e ur sur ca r ac tr e * 
ptr A = A v a l A  * ptr  c ont ie n d r a
l’ ad r e ss e de v a l * 
ptr  =  r e p   * ptr 
c ont ie n d r a l’ ad r e ss e de r e p* 
2FF3 5A0F3
 2FF3 5A0F3
a 17
ptr2 ptr1
26
rep val
 Rappel général et mise à
PARTIE 1

niveau
Tableau et pointeur :

On peut accéder aux éléments par pointeurs en faisant des calculs
d’adresses (addition ou soustraction)

int tab[6] = { 1,2,3,4,5,6 }; p += 4

int *p; p+
p = tab; +
printf("%d\n", *p);
p++; p
printf("%d\n", *p); 1000 1 2 3 4 5 6
p += 4; ta
printf("%d\n", *p); b1000 1008 1016
1004 1012 1020

11
Qu ’ affiche ce programme? 22
66

27
 Rappel général et mise à
PARTIE 1

niveau
Les Pointeurs

1.
2.
3 . Ecrire le programme qui lit un entier X et un tableau
des entiers et élimine toutes les occurrences de X dans
T en tassant les éléments restants .
A Utiliser 2 pointeurs pour parcourir le tableau T.
1 . Ecrire le programme qui range les éléments d ’ un tableau
d ’ entiers T dans l ’ ordre inverse .
Utiliser 2 pointeurs et une variable de permutation.
1.

28
 Rappel général et mise à
PARTIE 1

niveau
Allocation dynamique:

malloc ( nombre_octets )
 ⇒Αλ λ ο υ ε υ ν ε ζ ο ν ε δ ε
 τ αι λ λ ε ν ο µ β ρ ε _ο χ τ ε τ σ
 ο χ τ ε τ σ ε ν µ  µ ο ι ρ ε ε τ
ρ ε τ ο υ ρ ν ε υ ν π ο ι ν τ ε υ ρ .
Exemple 1 :
σηο ρ τ ∗ π ;
π =
(σ η ο ρ τ ∗)µ α λ λ ο χ (σ ι ζ ε οFEE01
φ (σ ηt e t s
ο ρ τ )); 2 o
c

FEE01

29
p
Mémoire
 Rappel général et mise à
PARTIE 1

niveau
Allocation dynamique :
Exemple 2 :
 # include < stdio . h >

# include < stdlib . h >
main ()
{
int i = 3 ;
int j = 6 ;
int * p ; Qu ’ affiche
p = ( int *) malloc ( 2 * sizeof ( int ));
*p = i; ce
*( p + 1 ) = j ;
programme???
printf (" p = % ld \t * p = % d \t p + 1 = % ld \t *( P + 1 ) =
% d\n ", p ,* p , p + 1 ,*( p + 1 ));
}

30
 Rappel général et mise à
PARTIE 1

niveau
La fonction calloc
La fonction calloc de fournie dans l’en-tête
stdlib.h à le même rôle que le malloc mais
initialise en plus *p à zéro :
 calloc(nb-elements, taille-element)


31
 Rappel général et mise à
PARTIE 1

niveau
Libération de l ’ espace alloué
Il faut libérer chaque espace alloué
dynamiquement
 lorsqu'il n ’ est plus utilisé dans
le programme
La libération est effectuée à l’aide de la
fonction
 free () de l’en-tête stdlib.h :
 free ( nom - du - pointeur )
Exemple :

int *pA = (int*Am a llo c ( A
 *s i A e o f ( i nt AAA
 int *pA =
(int*ca llo c ( AA s i A e o f ( i n
t
if (p == p
32 f r ee (p A
else
 Rappel général et mise à
PARTIE 1

niveau
Les chaînes de caractères ( Déclaration ):
ALes chaînes de caractères sont des tableaux de
caractères.


Leur manipulation est donc analogue à celle d'un

tableau à une dimension:

Déclaration : char nom [ dim ];

ou bien
char * nom ;
nom = ( char *) malloc ( dim * sizeof ( char ));

Exemple : char texte [ 10 ];

ou bien
char * texte ;
texte = ( char *) malloc ( 10 * sizeof ( char ));

33
 Rappel général et mise à
PARTIE 1

niveau
Les chaînes de caractères ( Affichage ):

On peut utiliser la fonction printf et le

AFFICHAGE

format %s:
char texte[10] = « BONJOUR »;
printf("VOICI LE TEXTE: %s \n",texte);

On utilisera aussi la fonction puts non

formatée:
puts(texte); printf("%s\n",texte);
 Rappel général et mise à
PARTIE 1

niveau
Les chaînes de caractères ( Lecture ):

On peut utiliser la fonction scanf et le format

%s:
LECTURE

char texte[10] ;
scanf("%s ",texte);

On utilisera aussi la fonction gets non

formatée:
gets(texte); scanf(" %s ",texte);

35
 Rappel général et mise à
PARTIE 1

niveau
Les chaînes de caractères :

1.
2.
3 . Écrire un programme qui lit 5 mots , séparés par des
espaces et qui les affiche ensuite dans une ligne , mais
dans l'ordre inverse . Les mots sont mémorisés dans 5
variables M1 , ... , M5 .
Exemple
Math Info Physique Chimie !
! Chimie Physique Info Math

36
 Rappel général et mise à
PARTIE 1

niveau
Traitement des chaînes de caractères :
La bibliothèque <string> fournit une multitude de fonctions
pratiques pour le traitement de chaînes de caractères.
strlen(<s>) fournit la longueur de la chaîne sans compter le '\0' final

strcpy(<s>, <t>) copie <t> vers <s>

strcat(<s>, <t>) ajoute <t> à la fin de <s>

strcmp(<s>, <t>) renvoie un nombre:
strncpy(<s>, <t>, <n>) - positif
copie ausiplus
la chaîne1 est supérieure
<n> caractères à la <s>
de <t> vers chaine2 (au sens de l'ordre
strncat(<s>, <t>, <n>) alphabétique)
ajoute au plus <n> caractères de <t> à la fin de <s>
- négatif si la chaîne1 est inférieure à la chaîne2
- nul si les chaînes sont identiques.

37
 Rappel général et mise à
PARTIE 1

niveau
Les chaînes de caractères ( Conversion ):
La bibliothèque <stdlib> contient des déclarations de fonctions
pour la conversion de nombres en chaînes de caractères et
vice - versa.
Chaîne 
Nombre
atoi(<s>) retourne la valeur numérique représentée par <s> comme int

atol(<s>) retourne la valeur numérique représentée par <s> comme long

atof(<s>) retourne la valeur numérique représentée par <s> comme double

Nombre  Chaîne
itoa (< n_int >, < s >, convertit son premier argument en une chaîne de caractères
< b >) qui sera ensuite attribuée à <s>. La conversion se fait dans
la base <b>.
38
 Rappel général et mise à
PARTIE 1

niveau
Les chaînes de caractères :
1 . Ecrire un programme qui demande l'introduction du nom et
du prénom de l'utilisateur et qui affiche alors la
longueur totale du nom sans compter les espaces .
Employer la fonction strlen .
Exemple:
Introduisez votre nom et votre prénom: Ahmed Jalali
Bonjour Ahmed Jalali !
Votre nom est composé de 11 lettres

2 Ecrire un programme qui

lit deux chaînes de caractères CH1 et CH2 et qui copie
la première moitié de CH1 et la première moitié de CH2
dans une troisième chaîne CH3 . Afficher le résultat .
aA Utiliser les fonctions spéciales
de <string>A
bA Utiliser uniquement les
fonctions gets et puts
39
 Rappel général et mise à niveau
Les Structures
PARTIE 1

AUne structure est une collection de plusieurs variables (champs)

groupées dans un ensemble pour un traitement commode,
Les variables d’une structure sont appelées membres et peuvent
être de n’importe quel type (tableaux, pointeurs, entiers ….)
n
n

struct
struct Membre
Membre
{{
char
char nom
nom[ 80
[ 80];];
char
char adresse
adresse[ 200 [ 200];];
int
int **numero
numero; ;
float
float amende
amende[ 10 [ 10];];
};};

40
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Déclaration de Structures
 D é c l a r a t i on  D é c l a r a t i on
de l a
struct

stru c produit
tur e
de stru c tur e
{ e t v a r iab l e s
de l aproduit
struct mêm e
 int code ; stru c tur e A
 int qte ; {
float prix ; int code ;
} ; int qte ;
float prix ;
} prd1,prd2 ;
D é c l a r a t i on
de s v a r iab l e s
de la
struct
stru produit
c tur e
prd1 ;
struct produit prd1,
41 prd2
METHODE
; 1 METHODE 2
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Déclaration de Structures
 D é c l a r a t i on
de l a
Typedef
 stru c turstruct
e
{
 int code ;
 int qte ;
float prix ;
 } Enregistrement ;
Enregistrement prd1, prd2 ;

METHODE 3

42
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Utilisation des champs d ’ une structure

 prd1 . code = 2015 ;
struct
 produit
affecte la valeur 2015 au
{ champ code de la structure
int code; prd1 .
 int qte ;
float prix ; printf
} ; ("% f ", prd1 . prix ) ;
affiche la valeur du champ prix
struct produit prd1, de la structure prd1 .
prd2 ; scanf
("% f ",& prd2 . prix ) ;
Lit une valeur qui sera
affectée au champ prix de la
structure prd2 .
 Notez bien la présence de
l ’ opérateur &.
43
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Utilisation des champs d ’ une structure

 prd1 = prd2 ;
struct
 produit
 Possible pour le cas de
{ structures de même type .
int code;
 int qte ;
float prix ;
} ;
struct produit prd1,  Ça vient a remplacer :
prd2 ; prd1.code = prd2.code;
prd1.qte =
prd2.qte ;
prd1.prix =
prd2.prix ;
44
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Structure et Pointeur

typedef struct  L ’ accès aux membres de la
structure pointée par prd3 se
 { fait de la manière suivante :
 int code ;
int qte ; prd3 A code = 2017 ;
 float prix ; prd3  qte = 1200 ;
} Enregistrement
; L’ affichage A
printf (“% d
Enregistrement \n ”, Prd3 A qte ); 1200
* prd3 ; L a L ec tur e  7000
EF01
Enregi- code 2017 scanf (“% f ”,& Prd3  pri
prd3 strementqte x );
EF01 1200
prix

45
7000
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Structures contenant des tableaux :

struct personne employe
{ nom
char
nom[30] ; prenom
char
prenom [20] ; heures
double
heures [31] ;
} employe;
Réserve les emplacements pour d’une structure nommée
employe .Ces dernières comportent trois champs:
· nom qui est un tableau de 30 caractères,
· prenom qui est un tableau de 20 caractères,
· heures qui est un tableau de 31 flottants.

46
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Tableaux de Structures :
struct point { point Courbe [ 2 ] Courbe [ 49
char nom ; courbe [ B courbe [ 17 F
]
int x ; 0]
A ]
int y ; 1 C 12
}; 0 0 2 19
struct point courbe[50]; 0 2

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 structure courbe, quant à elle, pourrait servir à représenter

un ensemble de 50 points du type ainsi défini.

47
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Structures imbriquées :
struct Date struct Membre
{ {
int jour ; char nom [ 80 ];
int mois ; char adresse [ 200 ];
int an ; int numero ;
}; float amende [ 10 ];
struct Date emprunt ;
struct Date creation ;
};

struct Livre
{ struct Pret
char titre [ 80 ]; {
char auteur [ 80 ]; struct Livre b;
float prix ; struct Date due ;
struct Membre * who ;
}; };

48
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Exercice 1 :
Ecrire un programme qui lit au clavier des informations
dans un tableau de structures du type point défini comme
suit :
struct point {
char nom ;
double x ;
double y ;
}
A Le nombre d'éléments du tableau sera fixé par une
instruction # define .

49
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Exercice 2 : Soit la structure suivante  :

typedef struct {
char Matricule  [ 10 ];
char nom  [ 50 ];
char prenom  [ 50 ];
int Nb_heures_sup ;
float salaire_fixe  ;
float salaire  ;
float prime  ;
}   employé ;
Ecrire un programme permettant de déclarer , de remplir et
d ’ afficher un tableau de N éléments de type employé .

NB  : salaire = salaire_fixe + prime avec prime

= Nb_heures_sup * 10  ;

50
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Transmission d ’ une structure en argument

Transmission
d ’ une
 fonction par
Valeur
#include
 <stdio.h>
struct
 produit {
 int code ; void fct (struct prdoduit prd)
{
 float prix ; prd.code = 0; prd.prix=1;
} ; printf ("\ndans fct : %d %f", prd.code,

main() prd.prix);
{ 
}
struct produit prd1 ;
void fct (struct produit p) ;
prd1.code = 1055; prd1.prix = 12.5;
printf ("\navant appel fct : %d %f",prd1.code,prd1.prix);
fct (prd1) ;
printf ("\nau retour dans main : %d %f", prd1.code,prd1.prix);
}

51
 Rappel général et mise à niveau
Les Structures
PARTIE 1

Transmission d ’ une structure en argument

d ’ Transmission
 une fonction par
Adresse
#include
 <stdio.h>
struct
 produit {
 int code ; void fct (struct prdoduit *prd)
{
 float prix ; prdcode = 0; prdprix=1;
} ; printf ("\ndans fct : %d %f", prdcode,

main() prdprix);
{ 
}
struct produit prd2 ;
void fct (struct produit *) ;
prd2.code = 1055; prd2.prix = 12.5;
printf ("\navant appel fct : %d %f",prd2.code,prd2.prix);
fct (& prd2) ;
printf ("\nau retour dans main : %d %f", prd2.code,prd2.prix);
}

52
 Rappel général et mise à
PARTIE 1

niveau
Les Fichiers

Un fichier est un ensemble d'informations stockées

sur une mémoire de masse (disque dur, disquette, bande
magnétique, CD-ROM).

53
 Rappel général et mise à
PARTIE 1

niveau
Les Fichiers

 Déclaration : FILE
* fichier ;
On définit un pointeur qui
fournit l'adresse d'une cellule
donnée.

pointeur

NB : La déclaration des fichiers

doit
figurer AVANT la déclaration des
autres variables.
54
 Rappel général et mise à
PARTIE 1

niveau
Ouverture et fermeture de fichiers :

A L ’ ouverture se fait à l’aide de la fonction fopen :
FILE * f ;
f = fopen(const char* name, const char* mode);
La Fermeture se fait à l’aide de la fonction fclose :
int fclose (FILE *f);

Exemples:
FILE *fichier ;
fichier = fopen(“c :\listes.txt “, “w” ) ;
/* instructions et traitements*/
fclose(fichier) ;

55
 Rappel général et mise à
PARTIE 1

niveau
Modes d ’ ouverture de fichiers :

FILE * fopen ( char * nom , char * mode ) ;
mode (pour les fichiers TEXTES) :
« r » ouverture d’un fichier en lecture : le fichier doit
exister, autrement la fonction fopen return NULL ;
« w » création et ouverture d’un fichier en écriture : si le
fichier existe, son contenu est détruit ;
« a » ouverture d’un fichier en écriture à la fin du
fichier : si le fichier n’existe pas, il est créé ;
« r+ » ouverture d’un fichier en lecture et écriture : le
fichier doit exister,
autrement la fonction fopen return NULL ;
«w+ » création et ouverture d’un fichier en lecture et
écriture : si le fichier existe,son
contenu est détruit ;
« a+ » ouverture d ’ un fichier en lecture et en écriture
à la fin du fichier : si le fichier n’existe pas, il est
créé.
56
 Rappel général et mise à
PARTIE 1

niveau
Modes d ’ ouverture de fichiers :

FILE * fopen ( char * nom , char * mode ) ;

mode (pour les fichiers BINAIRES) :

On ajoute un b apres chaque indice
Exp : mode « rb » : lecture seul

57
 Rappel général et mise à
PARTIE 1

niveau
Lecture et Ecriture dans les fichiers :

Fonctions de lecture
int
int fscanf(
fscanf FILE
fscanf
fscanf( FILE** stream
stream,, const
const char
char**
format
format,, ...);
...);
int
int fgetc(
fgetc FILE
fgetc
fgetc( FILE** stream
stream););
char
char** fgets(
fgets char
fgets
fgets( char** buffer
buffer,, int
int size
size,, FILE
FILE** stream
stream););
Fonctions d ’ écriture
int §
fprintf(
fprintf FILE
fprintf
int fprintf( FILE** stream
stream,, const
const char
char**
format §
format,, ...);
...);
int
int fputc(
fputc§
fputc(
fputc int
int ch
ch,, FILE
FILE** stream
stream););
int
int fputs(
fputs const
fputs
fputs( const char
char** buffer
buffer,, FILE
FILE** stream
stream););
58
 Rappel général et mise à
PARTIE 1

niveau
Exemple de Lecture / Ecriture de
fichiers :
#include <stdio.h> #include <stdio.h>
void main(void) void main(void)
{  {
char titre[81];
char titre[81]; float x[10];
float x[10]; int ind[10], i=0;
int ind[10], i=0,n=10; FILE *f;
FILE *f; f = fopen(“monfichier.txt”,”r”);
f = fopen(“monfichier.txt”,”w”); if (f!= NULL) {
if (f !=NULL){ fgets(titre,80,f);
fprintf(f,”%s\n”,titre); while(!feof(f)) {
fscanf ( f ,”% f
for (i=0; i < n; i++ ) { % d ”,& x [ i ],& ind [ i ]);
fprintf ( f ,”% f % d\n ”, i++;
x [ i ], ind [ i ]); }
} }
} fclose(f);
fclose(f); }
}

59
 Rappel général et mise à
PARTIE 1

niveau
Les Listes Chaînées
Stocker des données en mémoire, nous avons



utilisé des variables simples :
 Type int, double. . .,
 Des tableaux,
 Des structures personnalisées. Si vous souhaitez
Difficulté

Atocker une série de données, le plus simple est



en général d'utiliser des tableaux.

 LimitationA (AxempleA


Int tab [ 4 ]

60
 Rappel général et mise à
PARTIE 1

niveau
Les Listes Chaînées

Lors
 de la manipulation de nombre variable d’instances
d’une structure, et on souhaite insérer, supprimer
dynamiquement;
Les Tableaux de structures ne

x
su ffisent plusStrct[k]
Struct strct {
Difficulté

……
champ2
champ1

champ1 ;
Champ2 ;
};
struct strct strct [ n ];

Strct[1] Strct[2] Strct[3] Strct[4] …… …… Strct[n] Strct[n+1]

champ1 champ1 champ1 champ1 …… …… champ1 champ1

champ2 champ2 champ2 champ2 …… …… champ2 champ2

…… …… …… …… …… …… …… ……
 Rappel général et mise à
PARTIE 1

niveau
Les Listes Chaînées
Une liste chaînée est un moyen d'organiser une
série de données en mémoire . Cela consiste à assembler
des structures en les liant entre elles à l'aide de
pointeurs . On pourrait les représenter comme ceci :

 Chaque élément peut contenir ce que l'on veut : un

ou plusieurs données ( int , double …) .
A En plus de cela , chaque élément possède un pointeur
vers l'élément suivant

62
 Rappel général et mise à
PARTIE 1

niveau
Construction d ’ une Liste Chaînée :

Dans l’exemple suivant, nous allons créer une liste


chaînée de nombres entiers. Chaque élément de la liste aura la
forme de la structure suivante :

typedef struct Element

Element ;
struct Element
{
int nombre ;
Element * suivant ;
};

63
 Rappel général et mise à
PARTIE 1

niveau
Construction d ’ une Liste Chaînée :
En plus de la structure qu'on vient de créer (que l'on
dupliquera
 autant de fois qu'il y a d'éléments), nous allons avoir
besoin d'une autre structure pour contrôler l'ensemble de la liste
chaînée. Elle aura la forme suivante :

typedef struct Liste Liste ;

struct Liste
{
Element * premier ;
}; Premier élément de la
liste

64
 Rappel général et mise à
PARTIE 1

niveau
Construction d ’ une Liste Chaînée :


Il manque une dernière chose :
On aimerait retenir le dernier élément de la liste.:
Ail faudra bien arrêter de parcourir la liste à un moment
donné. le dernier élément ?

 il suffit de faire pointer le dernier élément de la

liste vers NULL , c'est - à - dire de mettre son pointeur
suivant à NULL .
65
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :
les principales fonctions qui vont manipuler la liste
chaînée sont :


qInitialiser la liste ;
q
qAjouter un élément ;
q
qSupprimer un élément ;
q
qAfficher le contenu de la liste ;
q
qSupprimer la liste entière .

66
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :
 Initialiser la liste :
q
Première que l'on doit appeler,
Elle crée la structure de contrôle et le premier élément
de la liste.
Liste * initialisation ()
{
Liste * liste = malloc ( sizeof (* liste ));
Allocation
Element * element Dynamique
= malloc ( sizeof (* element ));

if ( liste == NULL || element == NULL )

{
Vérification des allocations dynamiques
exit ( EXIT_FAILURE );
}

element -> nombre = 0 ;

element -> suivant = NULL ;
Initialisation
liste -> premier = des valeurs
element ; de la liste
return liste ;
}

67
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :

qAjouter un élément :
Ajout au début?
Ajout au milieu? De la liste
Ajout à la fin?

68
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :

qAjouter un élément :
qAjouter un élément au début :

 nouveau -> suivant = liste -> premier

 = liste -> premier = nouveau

69
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :

qAjouter un élément :
qAjouter un élément au début :
void insertion ( Liste * liste , int
nvNombre )
{ Création du nouvel élément
/* Création
Et Vérification dudenouvel élément
l’allocation */
dynamique
Element * nouveau =
malloc ( sizeof (* nouveau ));
if ( liste == NULL || nouveau ==
NULL )
{
exit ( EXIT_FAILURE );
}
nouveau -> nombre = nvNombre ;
Initialisation des valeurs de la liste
/* Insertion de l'élément au début de
la liste */

nouveau -> suivant = liste -> premier ;

70 liste -> premier = nouveau ;
}
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :


qSupprimer un élément :
void suppression ( Liste * liste )
{
if ( liste == NULL )
{ Vérification
exit ( EXIT_FAILURE );
}
if ( liste -> premier != NULL )
{
Element * aSupprimer = liste -> premier ;
liste -> premier = liste -> premier -> suivant ;
Suppression
free de la ); valeur de la liste
( aSupprimer
}
}

71
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :

qAfficher La liste :
void afficherListe ( Liste * liste )
{
if ( liste == NULL )
{ Vérification et Test
exit ( EXIT_FAILURE );
}
Element * actuel = liste -> premier ;
while ( actuel != NULL )
{
printf ("% d -> ", actuel -> nombre );
actuel = actuel
Affichage suivant ;
de la->liste
}
printf (" NULL\n ");
}

72
 Rappel général et mise à
PARTIE 1

niveau
Gestion d ’ une Liste Chaînée :


qRechercher dans la liste :

int rechercher ( int x , liste * l )

{
if (( l == NULL )
return ( FAUX );
else if ( l -> nombre == x )
return ( VRAI );
else
return ( rechercher , l -
> suiv ));
}

73
Programmation
Orientée Objet ( POO )

PARTIE 1
 Programmation Orientée Objet
PARTIE 2

Un Programme C

75
PARTIE 2

Limitations

76
PARTIE 2

Introduction
Est-ce qu’il faut oublier le C?

 NON!
Vous allez avoir
le choix parmi

plusieurs

méthodes de

programmation!

77
PARTIE 2

Introduction
Paradigmes de Programmation

Programmation Structurée :PS

Programmation Orientée Objet : POO

Pascal
Langage C
COBOL C++
FORTRAN Java
ALGOL Delphi
C#
WinDev
78
PARTIE 2

Programmation Structurée
Programme composé de fonctions,
Aanipulation de Données (variables),
Créées à l’intérieure des fonctions ou
paramètres,
Programme principal (main).

Algorithmes + Structures de données =

Programmes

79 Sélection Répétition Séquence

PARTIE 2

Exigences de Qualité
Fournir les résultats voulus ,
dans des conditions normales
Exploiter un même d ’ utilisation
logiciel dans
différentes
implémentations

bien réagir
lorsque l ’ on
s ’ écarte des
conditions
normales
d ’ utilisation
Temps
d ’ exécution , Programme devrait
taille mémoire ... être adapté pour
satisfaire à une
évolution des
spécifications

80
Utiliser certaines parties ( modules ) du logiciel pour résoudre un autr
PARTIE 2

Paradigme Orienté Objet

q Les principes de la POO reposent sur la notion de la décomposition

(diviser pour régner) et sur celle de l'abstraction.
q
q L'abstraction permet :
La généricité: possibilité de paramétrer un objet
Le polymorphisme:
Possibilité à une procédure d'accepter:
Des paramètres de type différent,
Nombre variable de paramètres,
L’attribution d’un même nom à une
méthode qui s'adapte au type d'objet
concerné
q
qEn POO la séparation entre données et procédures disparaît.

81
PARTIE 2

Notion d ’ Objet


La programmation orientée objet



consiste à modéliser informatiquement un

ensemble d'éléments d'une partie du
monde réel (que l'on appelle domaine) en
un ensemble d'entités informatiques. Ces
entités informatiques sont appelées
objets.
Il s'agit de données informatiques
regroupant les principales caractéristiques
des éléments du monde réel (taille,
82
couleur, ...).
PARTIE 2

Paradigme Orienté Objet

Comment peut on y arriver?
 Introduction des nouvelles notions:
objet (Object)
classe (Class)
Méthodes et Attributs
instanciation
hiérarchie des classes
héritage
Polymorphisme
Encapsulation

83
PARTIE 2

Notion d ’ Objet
Objet de la Classe ANIMAL

Données
Propriétés
de de
L ’ objet
La
Classe
L ’ objet
Opérations
Méthodes
de de
L ’ objet
La
Classe

Objet de la catégorie ANIMAL

84
PARTIE 2

Notion d ’ Objet
Objet de la Classe Véhicule

Marque Propriétés
Couleur Données
de La
L ’ objet Puissance fiscale deClasse
L ’ objet
Vitesse maximale

Démarrer() Méthodes
Accélérer () Opérations
de La
Avancer() deClasse
L ’ objet
Reculer()

Objet de la catégorie Véhicule

85
PARTIE 2

Notion d ’ Objet


Un objet est une entitéde monde réel qui



se caractérise par des états (ou attributs )

et des comportements (ou des méthodes).


 Remarques:
 Pour distinguer les objets de même
type on aura besoin d’un identificateur
unique appelée identité
  Les objets peuvent être distingués
grâce à leur existence et non à la
description des propriétés qu’ils peuvent
avoir;
86
c’est la tâche qui nous dira quelles sont
les propriétés et les méthodes qu’on
PARTIE 2

Notion d ’ Objet
Un objet est caractérisé par plusieurs
notions  :

87
PARTIE 2

Notion d ’ Objet

Objet = identité + Etats + comportement

 Lorsque des objets ont Classe Véhicule

les mêmes attributs et
comportements ; ils sont
regroupés dans une
famille appelée Classe,

L es objets appartenant à
celle - ci sont les instances
de cette classe .

 L ’ instanciation C réation d’un objet d’une classe.

88
PARTIE 2

Notion d ’ Objet
 EXERCICE:

qPropriétés intéressantes?
qActions intéressantes?
89
PARTIE 2

Notion d ’ Objet
lecteur MP3
 EXERCICE: lève-vitres arrière électrique
lève-vitres avant électrique
ordinateur de bord
peinture métallisée
phares avec extinction retardée
radio/CD
régulateur/limiteur de vitesse
rétro. ton carrosserie
rétroviseurs électriques
sièges AV à réglage électrique
sièges avant réglables en hauteur
ABS
vitres teintées
volant multifonctions

qPropriétés intéressantes?
qActions intéressantes?

90