Académique Documents
Professionnel Documents
Culture Documents
Simulation Numérique
Chapitre 3
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 . ;
}
dim x y z mémoire
POINT P
mémoire dim pCor x y z
mémoire x y z
libéré non libéré et inaccessible
c l a s s POINT
{ public :
double pCor [ 3 ] ; OK : allocation statique à la compilation
};
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
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
}
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
};
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
}
mémoire partagée !
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
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 :
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)