Vous êtes sur la page 1sur 10

Ecole Nationale de Techniques Avancées

Simulation Numérique
Chapitre 3

Introduction à la notion d’objet


Eric Lunéville

Qu’est ce qu’un objet ?


Une classe d'objet est une nouvelle structure définie
par l'utilisateur encapsulant des membres :
des données (types primaires ou dérivés)

des fonctionnalités (fonctions usuelles)

dont on doit assurer :


l'autoconsistance (logique et "complétude" des fonctionnalités)

la robustesse (protection des données)

la généricité (caractère "universel")

nécessite une réflexion à la conception !


Sim. Numérique – chapitre 3 1
Plan

Déclaration d'une classe d'objet


Allocation mémoire
Protection des données
Constructeur/destructeur
Fonction membres
Données statiques et fonctions « constantes »
Différence avec une structure (struct)
Organisation

Sim. Numérique – chapitre 3 2

Déclaration d’une classe d’objets


Classe d’objets = nouveau type de variable C++ défini par l'utilisateur
c l a s s POINT
{ public :
déclaration avec le mot class i n t dim ;
données membre
double x , y , z ;
(généralisation de struct) void p r i n t ( ) fonction membre
{ cout<<x<<y<<z ; }
};

in t main ( )
{POINT P ; // o b j e t POINT
P . dim=3; Opérateur d'accès à un membre :
P . x=0;P . y=0;P . z = 0 . ; objet.membre (variable ou référence)
P. print ( ) ;
POINT ∗pQ=&P ; // p o i n t e u r POINT p_objet->membre (pointeur)
pQ−>x = 1 . ;
}

Sim. Numérique – chapitre 3- 3


Allocation mémoire automatique
Lors de l'instanciation d'un objet d'une classe :
allocation automatique de la place pour stocker les membres

classe POINT : allocation de 4 octets (dim) et 3x4 octets (x,y,z)

dim x y z mémoire

Lorsque l'objet « meurt » (delete ou fin de bloc d’instructions) :

désallocation automatique de la place occupée

Pas d’allocation automatique des pointeurs membres !!!


(taille inconnue)
Sim. Numérique – chapitre 3- 4

Allocation non automatique


in t main ( )
c l a s s POINT {. . .
{ public : {POINT P ; // o b j e t POINT
in t dim ; P . dim=3;
double ∗pCor ; P . pCor=new double [ P . dim ] ;
}; . . .
} Fuite mémoire
. .P .supprimé sans désallocation
}

POINT P
mémoire dim pCor x y z

mémoire x y z
libéré non libéré et inaccessible

Sim. Numérique – chapitre 3- 5


Allocation de mémoire
c l a s s POINT
{ public :
i nt dim ;
double pCor [ dim ] ; Interdit : allocation dynamique à la compilation
};

c l a s s POINT
{ public :
double pCor [ 3 ] ; OK : allocation statique à la compilation
};

Sim. Numérique – chapitre 3- 6

Protection des membres


Un membre d'une classe peut être déclaré :
public : accessible par tout le monde
private : accessible seulement par les fonctions membres de la classe
protected : accessible par la classe et ses descendants (héritage)
par défaut : private

c l a s s POINT int main ( )


{ public : {POINT P ; // i n s t a n c i a t i o n
in t dim ; P . dim=3;
private : P . pCor=new double [ P . dim ] ;
double ∗pCor ; // c oo rdo n né e s . . .
}; } Erreur de compilation :
pCor inaccessible

Allocation à gérer par la classe et non par l'utilisateur !

Sim. Numérique – chapitre 3- 7


Protection : accesseur
La protection private sert à renforcer la sécurité du code
en limitant l'accès à des données fondamentales de la classe.

c l a s s POINT
{ private :
double ∗pCor ;
public :
i nt dim ;
void a l l o c ( i nt d ) // a l l o c a t i o n
{dim=d ; pCor=new double [ P . dim ] ; }
double & v a l ( i nt i ) // f o n c t i o n d ’ a c c e s
{ i f ( i <1 | | i >dim ) e x i t ( − 1); // i n d i c e h o r s l i m i t e
return pCor [ i − 1 ] ;
}

int main ( )
{POINT P ; P . a l l o c ( 3 ) ;
cout<<P . v a l ( 1 ) ; accès protégé
}
Sim. Numérique – chapitre 3- 8

Constructeur
L’instanciation d’un objet réserve la place pour les données membre
construction minimaliste par défaut

Il est possible d’intervenir au moment de la construction


en créant des fonctions membre particulières : des constructeurs
syntaxe : nom_classe ( liste arguments){…}
pas d’argument de retour !!!

c l a s s POINT POINT : : POINT( in t d )


{double ∗pCor ; {dim=d ;
int dim ; pCor=new double [ dim ] ;
public : for ( int i =0; i <dim ; i ++) pCor [ i ] = 0 ;
POINT( int d ) ; }
};
pCor et dim sont privés Implémentation externe du constructeur
Sim. Numérique – chapitre 3- 9
Constructeur
Exemple de création de POINT

i nt main ( )
{POINT P ; Constructeur par défaut
POINT Q( 3 ) ; Constructeur avec dimension
POINT R=POINT ( 3 ) ; Equivalent à POINT R(3)
POINT ∗pS=new POINT( 3 ) Allocation dynamique
}

un constructeur est forcément public


sauf si on veut interdire toute construction !!!

différence essentielle avec struct


qui n’autorise pas les constructeurs

Sim. Numérique – chapitre 3- 10

Plusieurs constructeurs
Possibilité de définir plusieurs constructeurs (arguments ≠)
c l a s s POINT
{ i n t dim ;
double ∗ pCor ;
public :
POINT( i n t d , double v =0); // c o n s t r . ( dimension , v )
POINT( const POINT & P ) ; // c o n s t r . par c o p i e
};

POINT : : POINT( i n t d , double v ) // dimension , i n i t i a l i s e à v


{dim=d ;
pCor=new double [ dim ] ;
f o r ( i n t i =0; i <dim ; i ++) pCor [ i ]=v ;
}

POINT : : POINT( const POINT & P) // par c o p i e


{dim=P . dim ;
i f ( dim==0) return ;
pCor=new double [ dim ] ;
f o r ( i n t i =0; i <dim ; i ++) pCor [ i ]=P .pCOR[ i ] ; // r e c o p i e
}

Sim. Numérique – chapitre 3- 11


Constructeur par copie
Il existe par défaut un constructeur par copie
recopie les données membre (pas les zones allouées dynamiquement)

syntaxe : nom_classe ( const nom_classe &)

est automatiquement invoqué lors des transferts d’arguments


d’entrée et de retour par valeur
POINT s y m e t r i q u e (POINT P)
{ f o r ( i n t i =0; i <P . dim ; i ++) P . pCor [ i ]=−P . pCor [ i ] ;
return P ; }

i n t main ( )
{POINT P ( 3 , 1 . ) ; // C o n s t r u c t i o n du p o i n t ( 1 , 1 , 1 )
POINT M(P ) ; // C o n s t r u c t i o n de M c o p i e de P
POINT S=s y m e t r i q u e (Q ) ; // i n d u i t une r e c o p i e de Q
}

La dernière instruction induit 3 recopies : arg. entrée, arg. sortie et = !


Q n’est pas modfifié, c’est sa copie qui a été modifiée !
Sim. Numérique – chapitre 3- 12

Constructeur par copie


Oublier de redéfinir le constructeur par copie est FATAL
si il ya des opérations d’allocation mémoire
i nt main ( )
{POINT P ( 3 , 1 . ) ;
POINT M(P ) ;
}

POINT P adr. 10 POINT M


3 0x10 1 1 1 3 0x10

mémoire partagée !

Attention l’opérateur = a le même type de comportement !


Sim. Numérique – chapitre 3- 13
Destructeur
A la destruction (delete ou fin de bloc), par défaut
la mémoire occupée par les données membre est libérée
Il est possible d’intervenir durant cette phase
en définissant un destructeur (unique !) :

syntaxe : ~nom_classe (){…}

c l a s s POINT
{ int dim ;
double ∗pCor ;
public :
POINT( in t d ) ; // c o n s t r u c t e u r
˜POINT( in t d ) ; // d e s t r u c t e u r
{ delete [ ] pCor ; }
};
Sim. Numérique – chapitre 3- 14

Fonctions membres
On peut déclarer autant de fonctions membre que l’on souhaite
Une fonction membre a accès à tous les membres de sa classe
Une fonction membre peut retourner l’objet sur lequel elle
s’applique :
this : pointeur sur l’objet
*this : référence sur l’objet

POINT & r o t a t e x y ( double theta )


{double c t=c o s ( t h e t a ) ; double s t=s i n ( t h e t a ) ;
double x=pCor [ 0 ] ; double y=pCor [ 0 ] ;
pCor [ 0 ] = x∗ ct−y∗ s t ; pCor [ 0 ] = x∗ s t+y∗ c t ;
return ∗ t h i s ; // r e n v o i e l ’ o b j e t m o d i f i e
}

Sim. Numérique – chapitre 3- 15


Protection des données
Attribut const à une fonction membre :
type_retour fonction_membre(liste_arg) const {…}

interdit à la fonction de modifier les données membre


ne peut pas s’appliquer à un objet non const
mécanisme relevant de la compilation
const fait partie de la signature de la fonction

int main ( )
{ const POINT un ( 3 , 1 ) ; double & POINT : : v a l ( in t i ) const
POINT M( 3 ) ; { return pCor ( i +1);}
M. v a l (1)=un . v a l ( 1 ) ; double & POINT : : v a l ( in t i )
un . v a l (1)=M. v a l ( 1 ) ; { return pCor ( i +1);}
}
erreur de compilation
Sim. Numérique – chapitre 3- 16

Membre statique
Un membre (donnée ou fonction) déclaré static :

static type donnée_membre;


static type fonction_membre (liste_argarg);

se rapporte à la classe et non à un objet particulier

class maclasse i nt main ( )


{ public : { m a c l a s s e : : nbobj =0;
s t a t i c in t nbobj ; m a c l a c s e O1 ;
s t a t i c void addobj ( ) cout<<m a c l a s s e : : nbobj ;
{ nbobj +=1;} }
m a c l a s s e ( ) // c o n s t r u c t e u r
{ add object ( ) ; }
};

Sim. Numérique – chapitre 3 - 17


class versus struct
Pas de protection des membres dans struct (public)

Obligation de définir les données avant les fonctions dans struct

Pas de constructeur ni destructeur pour une struct

Utiliser struct pour des structures de données très simples

c l a s s Complex s t u c t complex
{ private : {double X,Y;
double X, Y; double module ( )
public : { return s q r t (X∗X+Y∗Y) ; }
Complex ( double x , double y ) };
{X=x ;Y=y ; }
double & r e e l ( ) { return X; }
double & imag ( ) { return Y; }
double module ( )
{ return s q r t (X∗X+Y∗Y) ; }
};
Sim. Numérique – chapitre 3 - 18

Conclusion
Une classe a par défaut :
un constructeur vide et un destructeur par défaut
un constructeur par copie (des données membre)

on peut définir ou redéfinir :


des données membres privées ou publiques
des fonctions membres privées ou publiques
des constructeurs ou un destructeur
obligatoirement le constructeur par copie et le destructeur
si il y a allocation dynamique des données

Attention à l’utilisation de l’attribut const et au retour de référence d’objet

Sim. Numérique – chapitre 3 - 19