Chapitre 3 - Classes Et Objets

Programmation Orientée
Objets
R. Ben Abbou & A. Zahi

FSTF, Fez, Maroc
Programmation Orientée
Objets
Chapitre 3
Classes et Objets
Plan
 Structures
 Classes
 Constructeur & Destructeur
 Objets dynamiques
 Membres statiques
 Surdéfinition des fonctions
 Fonctions amies
 Surcharge des opérateurs
 Organisation du code
2011-2012 LST INFO, FSTF 3
Les structures
 En C les structures contiennent uniquement des données
 Exemple
Struct point {
int x;
int y;
};
 En C++ les structures peuvent contenir des fonctions

 Exemple
struct point { int x;
int y;
void initialise(int,int);
void deplace(int,int);
void affiche();
};
Les structures
 L’accès aux champs de la structure peut
s’effectuer directement ou via les fonctions
 Exemple
Point a, b;
a.x=10;
équivalent à a.initialise(10,20)
a.y=20;
Les structures
 Exemple
#include<iostream.h>
Using namaspace std; Int main()
struct point { int x; int y; {
void initialise(int,int); point a,b;
void affiche(); a.initialise (10,20);
}; a.affiche();
void point::initialise(int abs,int ord) a.deplace (5,5);
{ a.affiche();
x=abs;
y=ord; b.x=1;
} b.y=1;
void point::deplace(int dx,int dy)
b.affiche();
{
return 0;
x+=dx;
}
y+=dy;
}
void point::affiche()
{
cout << "position :" <<x <<"," <<y <<"\n";
}
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

Notion de classe
 Exemple
class point {
int x;
int y;
public:
void affiche();
};

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

Classes
 Les modes d’accès concernent les membres données et

les méthodes
 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
 La structure en C++ est un cas particulier de classe où

tous les membres sont publics
Classes
 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 affiche();
private:
int calculer(int p);
};

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 indexée (opérateur de

porté ::) par le nom de sa classe
Classes
 Définition des fonctions membres
 Syntaxe
Type nom_classe :: nom_fonction (type param,…)
{
corps de la fonction
}
 Exemple
{
x+=dx;
y+=dy;
}
void point:: affiche()
{
};

Classes
 Instances de classe : objets
 L’instanciation d’une classe se fait par une
simple déclaration
 Objets statiques :
– nom_class ob1, ob2; // objets statiques
 Objets dynamiques: nécessité d’allouer de la

mémoire
– nom_class *ob1, *ob2 // objets dynamiques
– ob1 = new nom_class ;

– ob2 = new nom_class ;

Classes
 Instances de classe : objets
 Affectation d’objets:
 nom_class ob1, ob2;

 ob2 = ob1;
– 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

Classes
 Exemple
#include<iostream>
Using namespace std;
class point {
int x;
int y;
public:
void affiche();
};

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

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

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;
}

Classes
 Instances de classe
 Objet contenant un membre données
dynamique
 Exemple
#include<iostream>
using namespace std;
class point {
int *x;
int *y;
public:
void affiche();
};
Classes
 objet contenant un membre données
dynamique
 Exemple
{
x = new int; y=new int;
*x = abs; *y=ord;
}
{
*x+=dx;
*y+=dy;
}
{
cout << "position :" <<*x <<"," <<*y <<"\n";
}
Classes
 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 deplace

a.affiche();

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
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

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
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

Constructeur
 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

Constructeur
 Est appelé implicitement lors de la déclaration

 Objets statiques
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 ()

Constructeur
 Exemple
class point {
int x;
int y;
public:
point(int,int);
void affiche();
};

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

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

Constructeur
 Exemple
void main()
{
point a(10,20),b(30,30);
point c; // erreur
a.affiche();
a.deplace (5,5);
a.affiche();
b.affiche();
}

Constructeur
 Exemple: membres données dynamiques
#include<iostream>
class dvecteur {
int dim;
float *V;
public:
dvecteur(int,float*);
void decaler(float);
void afficher();
};

Constructeur
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" ;
}
Constructeur
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;
}

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

 Porte le nom de la classe
 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
 Ne peut pas être surdéfini

 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;

 Exemple
#include<iostream>
class point {
int x;
int y;
public:
point(int,int);
point(point&);
void affiche();
};

 Exemple
point::point(int abs,int ord)
{
x=abs;
y=ord;
}
point::point(point &p)
{
x=p.x;
y=p.y;
}

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

 Exemple
{
}
void f(point p)
{
p.affiche();
}
point g()
{
point h(1,1);
return h;
}
 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;
}

 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

#include<iostream>
class dvecteur {
int dim;
float *V;
public:
dvecteur(dvecteur&);
void afficher();
};

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] += 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" ;
}

int main()
{
float t1[]={1,1,1};
dvecteur V1(3,t1);
dvecteur V2 = V1;
V2.afficher();
V1.decaler(5);
V2.afficher();
return 0;
}

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

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

caractère ~
 N’a pas de paramètres
 Ne peut pas être surdéfini

Destructeur
 Exemple
#include<iostream>
class dvecteur {
int dim;
float *V;
public:
dvecteur(dvecteur&);
~dvecteur();
void afficher();
};

Destructeur
 Exemple
dvecteur::dvecteur (int n,float *T)
{ void dvecteur::decaler(float d)
dim=n;
V= new float[dim]; {
}
dvecteur::dvecteur (dvecteur& vect) for(int i=0;i<dim;i++)
{ 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 ()
{ {
dim=0; for(int i=0;i<dim;i++)
delete V;
cout<<"\n Appel du destructeur\n"; cout << V[i] <<" \n" ;
} }

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;
}

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.

Classe d’allocation 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;

Classe d’allocation 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;
}
Classe Static et Classes
 Applicable aux méthodes et aux

attributs
 Propriété indépendante de tous les

objets (propriété de la classe)

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

 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
 Exemple
#include<iostream.h> void point::deplace(int dx,int dy)
class point { {
static int nb; x+=dx;
int x; y+=dy;
int y; }
public: {
point(int,int); cout << "position :" <<x <<"," <<y
void deplace(int,int); <<"nombre d'objets" << nb <<"\n";
void affiche(); }
}; void main()
int point::nb=0; {
point a(10,20);
point::point(int abs,int ord) a.affiche();
{ a.deplace (5,5);
nb++; a.affiche();
x=abs; point b(30,30);
y=ord; b.affiche();
} }
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(…);

Fonctions membres static
 Peuvent être appelées avant la
création de tout objet
 Syntaxe:
class nom_classe {
….
public:
…
static type fonct_static(….);
};

 Exemple
class point { void point::deplace(int dx,int dy)
static int nb; {
int x; x+=dx;
int y;
y+=dy;
public: }
point(int,int); void point::affiche()
void deplace(int,int); {
void affiche(); cout << "position :" <<x <<"," <<y
static void compteur(); <<"nombre d'objets" << nb <<"\n";
}; }
int point::nb=0;
void main()
point::point(int abs,int ord) {
{ point a(i,i);
nb++; a.affiche();
x=abs; point::compteur();
y=ord; for(int i=0;i<4;i++)
} senario(i);
void point::compteur()
return 0;
{cout <<"\n nombre de points :"<<nb; }
}
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

Surdéfinition
 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); {
x=100;
void affiche();
y=100;
}; }

Paramètres par défaut
 Une fonction membre peut attribuer des valeurs
par défaut à certains paramètres omis lors de
l’appel
 Seuls les derniers paramètres peuvent avoir des
valeurs par défaut
 ≠ surdéfinition des fonctions :
 Une seule fonction
 !!! Attention risque d’ambiguïté avec la

surdéfinition

Paramètres par défaut
 Exemple
class point {
int x;
int y;
public:
void initialise(int =10,int =10);
void affiche();
};
{
x=abs;
y=ord;
}
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
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(…)
{
…
}
Fonctions amies
 Fonction indépendante et amie d’une classe
 Remarque
// Attention !!!! Fausse définition

type_retour A::fonct_amie(…)
{
…
}

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(…);
};
Fonctions amies
 Toutesles 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 sont amies de
classe B
};
Fonctions amies
 Exemple 1
class point { class complexe {
int x; int x;
int y; int y;
public:
public: complexe(int,int);
point(int,int); int coincide(point&);
void deplace(int,int); void affiche();
friend int :complexe::coincide(point&); …
void affiche(); };
};

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 affiche();
friend int coincide(complexe&, point&); …
void affiche(); };
};

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()

 Alternative aux fonctions
 Utilisation plus naturelle que les fonctions

 Exemple : somme de deux complexes c1 et c2
 c3 = c1 + c2 au lieu de c3=c1.somme(c2)
 Généraliser la sémantique d’un opérateur de

type de base aux nouveaux types utilisateurs
(nouvelles classes)
 Donner une nouvelle sémantique à un opérateur

 Opérateurs à surcharger
 Opérateurs arithmétiques
+-*/ %
 Opérateurs d’incrémentation/décrémentation
++, --
 Opérateurs de comparaison
< > >= <= == !=
 Opérateur d’affectation
=
…
 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

 Un opérateur peut être surchargé comme:
 Fonction membre
 Fonction indépendante (fonction amie)

 Syntaxe
 Comme la définition des fonctions, sauf on

rajoute devant l’opérateur le mot clé
operator
type_retour classe :: operator op([parm1],…)

{
…
}
 Exemple
#include<iostream.h> complexe complexe::operator+(complexe& c)
class complexe { {
int reel;
int img; complexe z;
public: z.reel=reel+c.reel;
void saisir(int,int); z.img=img+c.img;
complexe operator+ (complexe &); return z;
void affiche_complexe();
}
};
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);
z3=z1+z2;
void complexe::affiche_complexe()
{ z3.affiche_complexe();
cout << " partie réelle :" << reel
cout <<", partie imaginaire :" <<img <<"\n"; }
}

 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.

 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;
}
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
 Exemple
#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;
}

 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();
}

 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();
};

 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";
}

 Exemple: fichier programme principale « p2.h »
void main()
{
personne p;
p.saisir("dupont","pascal",11111);
p.afficher();
}

Chapitre 3 - Classes Et Objets

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 3 - Classes Et Objets

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée

R. Ben Abbou & A. Zahi

 En C++ les structures peuvent contenir des fonctions

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

2011-2012 LST INFO, FSTF 7

2011-2012 LST INFO, FSTF 8

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

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

– mode par défaut

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

2011-2012 LST INFO, FSTF 9

 Les modes d’accès concernent les membres données et

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

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

 La structure en C++ est un cas particulier de classe où

2011-2012 LST INFO, FSTF 11

 Définition des fonctions membres

 Les fonctions membres sont définies de la

 Les fonctions membres peuvent accéder aux

 La fonction membre est indexée (opérateur de

2011-2012 LST INFO, FSTF 13

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

– ob1 = new nom_class ;

2011-2012 LST INFO, FSTF 14

 nom_class ob1, ob2;

2011-2012 LST INFO, FSTF 15

Using namespace std;

2011-2012 LST INFO, FSTF 16

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

2011-2012 LST INFO, FSTF 17

2011-2012 LST INFO, FSTF 18

b.deplace(13,23); // a aussi se deplace

2011-2012 LST INFO, FSTF 21

 Définir la classe rationnel avec les fonctions membres

 Ecrire un programme principal qui permet de

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

 Destructeur : détruit les objets de la

 Toutes les deux sont facultatives

2011-2012 LST INFO, FSTF 23

 Un autre objet existant de la même classe

 Allouede la mémoire si l’objet contient

 Porte le nom de la classe

 N’a pas de type de retour

 Peut avoir des paramètres

2011-2012 LST INFO, FSTF 25

 Peut être surdéfini

nom_classe::nom_classe(param1) {…} // un seul

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

2011-2012 LST INFO, FSTF 26

 Est appelé implicitement lors de la déclaration

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

2011-2012 LST INFO, FSTF 27

2011-2012 LST INFO, FSTF 28

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

2011-2012 LST INFO, FSTF 29

2011-2012 LST INFO, FSTF 30

2011-2012 LST INFO, FSTF 31

for(int i=0;i<dim;i++) V[i] += d;

2011-2012 LST INFO, FSTF 33

2011-2012 LST INFO, FSTF 34

 N’a pas de type de retour

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

 Ne peut pas être surdéfini

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