Programmation Orientée

Objets
Chapitre 3
Classes et Objets

Pr. Saïd OUATIK EL ALAOUI

s_ouatik@yahoo.com
ouatikelalaoui.said@uit.ac.ma
 Plan
 Classes en C++
 Constructeur & Destructeur
 Objets dynamiques
 Membres statiques
 Surdéfinition des fonctions
 Fonctions amies
 Surcharge des opérateurs

2011-2012 2
 Notion de classe
 Généralisation de la notion de type
 Réunir données et traitement dans la même
entité

 Intégration d’un certain niveau de sécurité

 Les données sont, généralement, protégées:
seules les méthodes de la classe peuvent y
accéder

2011-2012 3
 Notion de classe

 Exemple

class point {
int x;
int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
};

2011-2012 4
 Classes
 Droit d’accès aux membres

 Trois modes d’accès aux membres d’une classe:

 Public : accès permis à partir de n’importe quel point

du programme

 Private
– Seules les méthodes de la classe peuvent accéder
au membre "privé"

– mode par défaut

 Protected : sémantique liée à l’héritage

2011-2012 5
 Classes
 Droit d’accès aux membres

 Les modes d’accès concernent les attributs (appelés

membres données) et les méthodes (appelées fonctions
membre)

 Une fonction membre privée ne peut être appelée qu’à

partir d’une autre fonction membre

 Les membres données peuvent être "public" mais c’est

déconseillé, cela contredit le concept d’encapsulation

2011-2012 6
 Classes
 Droit d’accès aux membres
 Les mots clés public, private et protected peuvent
figurer plusieurs fois lors de la déclaration de la classe

 Exemple
class point {
private:
int x;
int y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
private:
int calculer(int p);
2011-2012 7
};
 Classes

 Définition des fonctions membres

 Les fonctions membres sont définies de la

même manière que les fonctions ordinaires

 Les fonctions membres peuvent accéder aux

membres données (sans les passer en
paramètre)

 La fonction membre est précédée (opérateur

de porté ::) par le nom de sa classe
2011-2012 8
 Classes
 Définition des fonctions membres
 Syntaxe

Type nom_classe :: nom_fonction (type param,…)

{
corps de la fonction
}
 Exemple
void point::deplace(int dx, int dy)
{
x+=dx;
y+=dy;
}
void point:: affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
2011-2012}; 9
 Classes
 Instances de classe : objets

 L’instanciation d’une classe se fait par une simple

déclaration
 Objets automatiques :
– nom_class ob1, ob2; // objets automatiques

 Objets dynamiques: nécessité d’allouer de la mémoire

– nom_class *ob1, *ob2;

– ob1 = new nom_class ; // objet dynamique

– ob2 = new nom_class ; // objet dynamique

2011-2012 10
 Classes
 Instances de classe : objets
 Affectation d’objets:

 nom_class ob1, ob2;

 ob2 = ob1; // affectation possible
– Copie les valeurs des membres données de ob1 dans
ob2
– Attention!! Si l’objet contient des membres données
dynamiques

Risque d’incohérence

2011-2012 11
 Classes
 Exemple

#include<iostream>

Using namespace std;

class point {
int x;
int y;

public:
void initialise(int,int);
void deplace(int,int);
void affiche();

2011-2012 }; 12
 Classes
 Exemple
void point::initialise(int abs, int ord)
{
x=abs;
y=ord;
}

void point::deplace(int dx, int dy)

{
x+=dx;
y+=dy;
}

void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
}
2011-2012 13
 Classes
 Exemple
int main()
{
point a,b;

a.initialise (10,20);
a.affiche();

b=a;
b.affiche();

b.deplace(3,3);
b.affiche();
return 0;
}

2011-2012 14
 Classes
 Instances de la classe
 Objet contenant un membre données
dynamique
 Exemple
#include<iostream>
using namespace std;
class point {
int *x;
int *y;
public:
void initialise(int,int);
void deplace(int,int);
void affiche();
};
2011-2012 15
 Classes
 Instances de la classe
 objet contenant un membre données dynamique
 Exemple
void point::initialise(int abs, int ord)
{
x = new int; y=new int;
*x = abs; *y=ord;
}
void point::deplace(int dx, int dy)
{
*x+=dx;
*y+=dy;
}
void point::affiche()
{
cout << "position :" <<*x <<"," <<*y <<"\n";
2011-2012 } 16
 Classes
 Instances de classe
 objet contenant un membre données
dynamique
 Exemple
int main()
{
point a,b;

a.initialise (10,20);
a.affiche();

b=a;
b.affiche();

b.deplace(13,23); // a aussi se déplace !!

a.affiche();

}
2011-2012 17
 Classes
 Exercice

 Définir la classe rationnel avec les fonctions membres

suivantes:
 Données membres dynamique
 Saisi d’un rationnel
 Affichage d’un rationnel
 Initialisation des données membres
 Conversion d’un rationnel en un réel
 Inversion d’un rationnel

 Ecrire un programme principal qui permet de

 Créer un rationnel
 L’affecter à un autre
 Initialiser le deuxième rationnel
 Afficher le premier

 Proposer une solution pour résoudre le problème engendré par

l’affectation
2011-2012 18
 Constructeur / Destructeur
 Deux fonctions membres spéciales
 Constructeur : initialise les objets de la classe

 Destructeur : détruit les objets de la classe

 Toutes les deux sont facultatives mais très

recommandées.

2011-2012 19
 Constructeur
 Initialiseles membres données de l’objet
lors de sa déclaration par:
 Les valeurs passées en paramètres

 Un autre objet existant de la même classe

(constructeur de recopie)

 Allouede la mémoire si l’objet contient

une partie dynamique
2011-2012 20
 Constructeur
 Caractéristiques

 Porte le nom de la classe

 N’a pas de type de retour

 Peut avoir des paramètres

 Est facultatif
 S’il n’est pas défini le compilateur génère un constructeur
par défaut

2011-2012 21
 Constructeur
 Caractéristiques

 Syntaxe
nom_classe::nom_classe([param1,…]) {…}

 Peut être surdéfini

nom_classe::nom_classe(param1,param2) {…} //avec
deux paramètres

nom_classe::nom_classe(param1) {…} // un seul paramètre

nom_classe::nom_classe() {…} // sans paramètres

2011-2012 22
 Constructeur
 Caractéristiques

 Est appelé implicitement lors de la déclaration

 Objets automatiques
nom_classe ob1(val1,val2);
nom_classe ob2(val);
nom_classe ob3;

 Objets dynamiques

nom_classe *ob4; ob4 =new nom_classe (val1,val2);

nom_classe *ob5; ob5 =new nom_classe (val);
nom_classe *ob6; ob6 =new nom_classe ();

2011-2012 23
 Constructeur
 Exemple
#include<iostream.h>
class point {
int x;
int y;

public:
point(int,int); // constructeur

void deplace(int,int);
void affiche();
};

2011-2012 24
 Constructeur
 Exemple
point::point(int abs, int ord)
{
x=abs;
y=ord;
}

void point::deplace(int dx, int dy)

{
x+=dx;
y+=dy;
}

void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
}
2011-2012 25
 Constructeur
 Exemple
void main()
{
point a(10,20), b(30,30);
point c; // erreur
a.affiche();
a.deplace (5,5);
a.affiche();
b.affiche();
}

2011-2012 26
 Constructeur
 Exemple: membres données dynamiques

#include<iostream>
using namespace std;

class dvecteur {
int dim;
float *V;

public:
dvecteur(int,float*);
void decaler(float);
void afficher();
};

2011-2012 27
 Constructeur
 Exemple: membres données dynamiques
dvecteur::dvecteur (int n, float *T)
{
dim=n;
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
}

void dvecteur::decaler(float d)
{
for(int i=0;i<dim;i++) V[i] += d;

void dvecteur::afficher()
{
for(int i=0;i<dim;i++) cout << V[i] <<" \n" ;
}
2011-2012 28
 Constructeur
 Exemple: membres données dynamiques
int main()
{
float t1[]={1,1,1}, t2[]={2,2,2,2};
dvecteur V1(3,t1),V2(4,t2);
V2 = V1;
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}

2011-2012 29
 Constructeur de recopie
 Initialise
l’objet lors de sa déclaration
par un autre objet
P_existant P_nouveau

Mamouni Mamouni

Mustapha Mustapha

C67965 C67965

2011-2012 30
 Constructeur de recopie
 Caractéristiques
 Porte le nom de la classe

 N’a pas de type de retour

 A un seul paramètre : une référence à un

objet

 Est facultatif
 S’il n’est pas défini le compilateur génère un constructeur
par défaut

2011-2012 31
 Constructeur de recopie
 Syntaxe
nomclasse :: nomclasse (nomclasse&) { …}
 Est appelé implicitement lors des situations
suivantes:
 Déclaration initialisation
nomclasse nouveau_objet=objet_existant;
 Passage par valeur d’un objet en paramètre
f( nomclasse objet)

 Retour d’un objet déjà existant par une fonction

return objet_existant;

2011-2012 32
 Constructeur de recopie
 Exemple
#include<iostream>
using namespace std;

class point {
int x;
int y;

public:
point(int,int);
point(point&); // constructeur de recopie
void deplace(int,int);
void affiche();
};

2011-2012 33
 Constructeur de recopie
 Exemple
point::point(int abs,int ord)
{
x=abs;
y=ord;
}

point::point(point &p)
{
x=p.x;
y=p.y;
}

void point::deplace(int dx,int dy)

{ x+=dx;
y+=dy;
}
2011-2012 34
 Constructeur de recopie
 Exemple

void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
}
void f(point p)
{
p.affiche();
}
point g()
{
point h(1,1);
return h;
}
2011-2012 35
 Constructeur de recopie
 Exemple
Int main()
{
point a(10,20);
point c=a;
c.affiche();
c.deplace (5,5);
cout << "ici la fonction f" << endl;
f(c);
cout << "ici la fonction g" << endl;
c = g();
c.affiche();
return 0;
2011-2012 } 36
 Constructeur de recopie
 Problèmes lorsqu’une classe contient des membres
données dynamiques

 Risque d’incohérence

 Les deux objets (initial et la copie) se partageront une

même zone mémoire

 La modification des données de l’un affectera l’autre

 On doit définir le constructeur de recopie

2011-2012 37
 Constructeur de recopie
 Exemple: membres données dynamiques
#include<iostream>
using namespace std;

class dvecteur {
int dim;
float *V;

public:
dvecteur(int,float*);
dvecteur(dvecteur&);
void decaler(float);
void afficher();
};

2011-2012 38
 Constructeur de recopie
 Exemple: membres données dynamiques
dvecteur::dvecteur (int n,float *T) void dvecteur::decaler(float d)
{ {
dim=n;
V= new float[dim]; for(int i=0;i<dim;i++)
for(int i=0;i<dim;i++) V[i]=T[i];
V[i] += d;
}
dvecteur::dvecteur (dvecteur& vect)
{ }
dim=vect.dim;
V= new float[dim]; void dvecteur::afficher()
for(int i=0;i<dim;i++) {
V[i]=vect.V[i]; for(int i=0;i<dim;i++)
} cout << V[i] <<" \n" ;
}

2011-2012 39
 Constructeur de recopie
 Exemple: membres données dynamiques
int main()
{
float t1[]={1,1,1};
dvecteur V1(3,t1);
dvecteur V2 = V1;
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}

2011-2012 40
 Destructeur
 Fonction membre qui a pour Rôle

 Libération des ressources de l’objet à

la fin de son utilisation

 Libération de la zone mémoire allouée

par un constructeur

2011-2012 41
 Destructeur
 Caractéristiques

 Porte le nom de la classe précédé par le

caractère ~

 N’a pas de paramètres

 N’a pas de type de retour

 Ne peut pas être surdéfini

2011-2012 42
 Destructeur
 Exemple
#include<iostream>
using namespace std;

class dvecteur {
int dim;
float *V;

public:
dvecteur(int,float*);
dvecteur(dvecteur&);
~dvecteur(); // destructeur
void decaler(float);
void afficher();
};

2011-2012 43
 Destructeur
 Exemple
dvecteur::dvecteur (int n,float *T)
{ void dvecteur::decaler(float d)
dim=n; {
V= new float[dim];
for(int i=0;i<dim;i++) V[i]=T[i];
} for(int i=0;i<dim;i++)
dvecteur::dvecteur (dvecteur& vect) V[i] += d;
{
dim=vect.dim;
V= new float[dim]; }
for(int i=0;i<dim;i++)
V[i]=vect.V[i];
} void dvecteur::afficher()
{
dvecteur::~dvecteur () for(int i=0;i<dim;i++)
{
dim=0; cout << V[i] <<" \n" ;
delete V; }
cout<<"\n Appel du destructeur\n";
}
2011-2012 44
 Destructeur
 Exemple
void scenario(float d)
{
float t1[]={1,1,1};
dvecteur V1(3,t1);

V1.afficher(); V1.decaler(d);
V1.afficher();
}
int main()
{
int d;
for(d=1;d<4;d++)
scenario(d);
return 0;
}

2011-2012 45
 Constructeur: Exercices
 Définir des constructeurs pour la classe
Rationnel

 Modifier le constructeur qui reçoit deux

paramètres afin d’obtenir un rationnel dans
sa forme irréductible (ajouter les fonctions
nécessaires )

 Ajouter un constructeur de recopie.

2011-2012 46
 Le Qualificatif static
 Stockage dans la zone statique
 Durée de vie permanente, égale à celle du
programme
 Même portée que les variables automatique
 Initialisation au moment de la compilation,
initialisation par défaut à 0
 Syntaxe
static float x;

2011-2012 47
 Le Qualificatif static
 Exemple
#include <stdio.h>
void fonct()
{
static int x=0;
int y=0;
printf("x = %d, y = %d\n",x++, y++);
}

Int main()
{
int i ;
for (i=0;i <10; i++)
{
printf(" iteration = %d ", i);
fonct();
}
return 0;
}
2011-2012 48
Attributs et Méthodes static

 Le terme static Applicable aux

méthodes et aux attributs

 On parle de: Attributs de classe et

méthodes de classe

 Propriété indépendante de tous les

objets (propriété de la classe)
2011-2012 49
 Membres données Static

 Lors de la déclaration des objets chaque

objet possède ses propres membres
données

 Exemple
Ob1 Ob2

10 20

15 30

2011-2012 50
 Membres données Static
 Un membre static est partagé par tous les objets de la
classe
 Syntaxe: Le membre est précédé par le mot clé static lors
de la déclaration de la classe
static type nom_var;

 L’initialisation n’est pas automatique

Type class_name::ident = 0;
Ob1 Ob2
15 20 30

10
Ob3
2011-2012 51
 Membres données Static
 Exemple
#include<iostream.h> void point::deplace(int dx,int dy)
class point { {
static int nb;
int x; x+=dx;
int y; y+=dy;
}
public: void point::affiche()
point(int,int); {
void deplace(int,int); cout << "position :" <<x <<"," <<y
void affiche(); <<"nombre d'objets" << nb <<"\n";
}; }
int point::nb=0;
void main()
point::point(int abs,int ord) { point a(10,20);
{ a.affiche();
nb++; a.deplace (5,5);
x=abs; a.affiche();
y=ord; point b(30,30);
} b.affiche();
2011-2012 } 52
 Fonctions membres static
 Sont indépendantes de tous les objets de
la classe

 Agissent sur des membres static

 Sont appelées sans référence à un objet

 référencées directement par le nom de la classe

 nom_classe::fonct_static(…);

2011-2012 53
 Fonctions membres static
 Peuvent être appelées avant la création de
tout objet

 Syntaxe:
class nom_classe {
….
public:
…
static type fonct_static(….);
};

2011-2012 54
 Membres données Static
 Exemple
#include<iostream.h> void point::deplace(int dx,int dy)
class point { {
static int nb; x+=dx;
int x; y+=dy;
int y; }
void point::affiche()
public: {
point(int,int); cout << "position :" <<x <<"," <<y
void deplace(int,int); <<"nombre d'objets" << nb <<"\n";
void affiche(); }
static void compteur();
}; void main()
int point::nb=0; {
point a(i,i);
point::point(int abs,int ord) a.affiche();
{nb++; point::compteur();
x=abs; for(int i=0;i<4;i++)
y=ord; senario(i);
} return 0;
void point::compteur() }
{cout <<"\n nombre de points :"<<nb;
}
2011-2012 55
 Surdéfinition
des fonctions membres
 La surdéfinition peut être appliquée aux fonctions
membres d’une classe
 Plusieurs fonctions membres portent le même nom mais
diffèrent dans le contenu selon le type et/ou le nombre de
paramètres
 Sémantiquement ces fonctions font la même action (ex
afficher)
 Le compilateur choisit la fonction à invoquer selon les
paramètres effectifs
 Plus de lisibilité : pas besoin de chercher plusieurs
identificateurs pour la même action

2011-2012 56
 Surdéfinition
des fonctions membres
 Exemple
#include<iostream.h> void point::initialise(int abs,int ord)
class point { {
x=abs;
int x; y=ord;
int y; }
public: void point::initialise(int c)
{
void initialise(int,int); x=c;
void initialise(int); y=c;
}
void initialise (); void point::initialise()
void deplace(int,int); {
void affiche(); x=100;
y=100;
}; }

2011-2012 57
 Paramètres par défaut
des fonctions membres
 Unefonction membre peut attribuer des
valeurs par défaut à certains paramètres
omis lors de l’appel

 Seulsles derniers paramètres peuvent

avoir des valeurs par défaut

2011-2012 58
 Paramètres par défaut
des fonctions membres
 Exemple
class point {
int x;
int y;
public:
void initialise(int =10,int =10);
void deplace(int,int);
void affiche();
};
void point::initialise(int abs,int ord)
{
x=abs;
y=ord;
}
2011-2012 59
 Fonctions amies
 Une fonction amie est une fonction non membre d’une
classe et possédant le droit d’accès aux membres privés
de ses objets.

 Intérêt : résoudre certains problèmes de communication

entre objets
 Fonction qui a besoin, dans certains cas, d’accéder aux
membres privés de deux classes différentes
 Attention !! : Violation du concept d’encapsulation
 L’amitié est déclarée par le mot clé friend
2011-2012 60
 Fonctions amies
 Fonction indépendante et amie d’une classe
 Syntaxe
class A {
…
public:
…
friend type_retour fonct_amie(…);
…
};
// définition de la fonction amie
type_retour fonct_amie(…)
{
…
}
2011-2012 61
 Fonctions amies
 Fonction indépendante et amie d’une classe

 Remarque

// Attention !!!! Fausse définition

type_retour A::fonct_amie(…)
{
…
}

2011-2012 62
 Fonctions amies
 Fonction membre d’une classe A et amie d’une ou plusieurs
classes
 Syntaxe
class A {
…
public:
…
type_retour fonct_amie(…);
…
};
class B {
…
public:
…
friend type_retour A::fonct_amie(…);
};
2011-2012 63
 Fonctions amies
 Toutes les fonctions membres d’une classe A sont
amies d’une autre classe B
 Syntaxe
class A {
…
public:
…
};
class B {
…
public:
…
friend class A; // les fonctions membres de A sont amies de
classe B
};
2011-2012 64
 Fonctions amies
 Exemple 1
class point { class complexe {
int x; int x;
int y; int y;
public:
complexe(int,int);
public:
int coincide(point&);
point(int,int);
void affiche();
void deplace(int,int);
…
friend int complexe::coincide(point&); };
void affiche();
};

2011-2012 65
 Fonctions amies
 Exemple 2
class point { class complexe {
int x; int x;
int y; int y;
public:
complexe(int,int);
public:
int coincide(point&);
point(int,int);
friend int coincide(complexe&,point&);
void deplace(int,int); void affiche();
friend int coincide(complexe&, …
point&); };
void affiche();
};

2011-2012 66
 Surcharge des opérateurs
 Opérateur?

 Opération entre des opérandes.

 Un appel à un opérateur est similaire à un

appel de fonctions.

A Op B se traduit par A.fonction(B)

 Exemples

 a+b a.somme(b)
 a=b a.affectation(b)
 ++a a.incrementation()

2011-2012 67
 Surcharge des opérateurs
 Alternative aux fonctions membre

 Utilisation plus naturelle que les fonctions

 Exemple : somme de deux complexes c1 et c2
 c3 = c1 + c2 au lieu de
c3=c1.somme(c2)

 Etendre la sémantique d’un opérateur de

type de base aux nouveaux types
utilisateurs (instances de classes)
2011-2012 68
 Surcharge des opérateurs
 Opérateurs à surcharger

 Opérateurs arithmétiques
+-*/ %

 Opérateurs d’incrémentation/décrémentation
++, --

 Opérateurs de comparaison
< > >= <= == !=

 Opérateur d’affectation
=
…
2011-2012 69
 Surcharge des opérateurs
 Quelques opérateurs non surchargeables
 . Opérateur pointeur vers un membre via objet

 * Opérateur pointeur vers un membre via objet

 :: Opérateur de résolution de portée

 ?: Opérateur conditionnel ternaire

 Sizeof Opérateur déterminant la taille en octets

2011-2012 70
 Surcharge des opérateurs

 Un opérateur peut être surchargé comme:

 Fonction membre

 Fonction indépendante (fonction amie)

2011-2012 71
 Surcharge des opérateurs
 Syntaxe

 Comme la définition des fonctions, sauf on

rajoute devant l’opérateur le mot clé operator

type_retour classe :: operator op([parm1],…)

{
…
}

2011-2012 72
 Surcharge des opérateurs
 Exemple
#include<iostream.h> complexe complexe::operator+(complexe & c)
class complexe { {
int reel; complexe z;
int img;
public: z.reel=reel+c.reel;
void saisir(int,int); z.img=img+c.img;
complexe operator+ (complexe &); return z;
void affiche(); }
};
void complexe::saisir(int r,int i)
{ void main()
reel=r; {
img=i; complexe z1,z2,z3;
} z1.saisir(1,1);
z2.saisir(2,2);
void complexe::affiche() z3=z1+z2;
{
cout << " partie réelle :" << reel z3.affiche();
cout <<", partie imaginaire :" <<img
<<"\n"; }
}
2011-2012 73
 Surcharge des opérateurs
 Surcharge de l’opérateur d’affectation

 L'opérateur
d'affectation est surchargé
comme une fonction membre.

 L’opérateur d'affectation stocke le résultat

dans l'objet appelant et retourne une
référence sur cet objet.

2011-2012 74
 Surcharge des opérateurs
 Surcharge de l’opérateur d’affectation
class rationnel {
int a,b;
public:
rationnel & operator=(const rationnel &)
};

rationnel& rationnel::operator=(const rationnel & r)

{
a = r.a; b = r.b;
return *this;
}
2011-2012 75
 Organisation du code
 Pour une meilleure réutilisabilité, il est préférable
d’organiser le code en trois fichiers:
 Le premier fichier en-tête qui contient la déclaration de la classe
 nom_classe.h

 Le deuxième fichier qui contient la définition des fonctions membres

de la classe

 Le troisième fichier correspond au programme principal

 Dans le 2ème et 3ème fichier on doit inclure le fichier en-tête

nom_class.h

2011-2012 76
 Organisation du code
 Exemple
#include<iostream.h>
#include<string.h>
class personne {
char nom[20];
char prenom[20];
int CIN;
public:
void saisir(char*,char*,int);
void afficher();
};

void personne::saisir(char *n,char *p, int numero)

{
strcpy(nom,n);
strcpy(prenom,p);
CIN=numero;
}

2011-2012 77
 Organisation du code
 Exemple
void personne::afficher()
{
cout <<"nom : " <<nom<<"\n";
cout <<"prenom : " <<prenom<<"\n";
cout <<"CIN : " <<CIN<<"\n";
}

void main()
{ personne p;
p.saisir("dupont","pascal",11111);
p.afficher();
}

2011-2012 78
 Organisation du code
 Exemple: fichier en-tête « personne.h »

class personne {
char nom[20];
char prenom[20];
int CIN;
public:
void saisir(char*,char*,int);
void afficher();
};

2011-2012 79
 Organisation du code
 Exemple: fichier définition des fonctions membres
« p1.h »
void personne::saisir(char *n,char *p, int numero)
{
strcpy(nom,n);
strcpy(prenom,p);
CIN=numero;
}
void personne::afficher()
{
cout <<"nom : " <<nom<<"\n";
cout <<"prenom : " <<prenom<<"\n";
cout <<"CIN : " <<CIN<<"\n";
}
2011-2012 80
 Organisation du code
 Exemple: fichier programme principale « p2.cpp »

void main()
{
personne p;
p.saisir("dupont","pascal",11111);
p.afficher();
}

2011-2012 81