3. LE LANGAGE C++ ... 2
3.1. Notion de classe ... 2
3.1.1. Généralités... 2
3.1.2. Déclaration et définition de classes... 2
3.1.3. Encapsulation de données ... 3
3.2. Constructeur et destructeur... 3
3.2.1. Généralités... 3
<!> NOTION DE LISTE CHAINEE <!> ... 4
3.2.2. Constructeur par recopie... 4
3.3. Complément sur les classes ... 5
3.3.1. Pointeur this... 5
3.3.2. Données et fonctions membres statiques ... 6
3.3.2.1. Données statiques... 6
3.3.2.2. Fonctions membres statiques ... 6
3.4. Amitié... 6
3.4.1. Fonctions amies... 6
3.4.2. Classes amies... 7
3.5. Surcharge des opérateurs... 7
3.5.1. Règle ... 7
3.5.2. Opérateurs de conversion ... 9
3.6. Compléments ... 10
3.6.1. Objets alloués dynamiquement ... 10
3.6.2. Tableau d’objets ... 10
3.6.3. Classe canonique... 10
3.6.4. Membres objets... 10
3.7. Exemples ... 11
Déclaration (.h)... 13
Définition (.h, le même) ... 13
pgTest.cpp ... 14
3.9. Librairie STL ... 14
3.9.1. Introduction ... 14
3.9.2. Conteneur... 14
3.9.2.1. Conteneurs séquentiels ... 14
3.9.2.2. Conteneurs associatifs ... 14
3.9.2.3. Méthodes des conteneurs... 15
3.9.3. Itérateurs... 15
3.9.4. Classe string... 15
3.10. Exceptions... 15
3. LE LANGAGE C++
3.1. Notion de classe 3.1.1. Généralités
On va regrouper des méthodes et des données.
3.1.2. Déclaration et définition de classes .h class Entier
{
int i ;
int lit_i(void) ; void Ecrit_i(int Val) {
i=Val ; }
} ;
.cpp int Entier::lit_i(void) {
return i ; }
class Client {
private:
char Nom[20], Prenom[20] ; int Date,
Solde ; public:
bool Dans_Le_Rouge(void) ; {
return (Solde<0) ; }
bool Bon_Client(void) {
return (Date<1996) ; }
} ;
main() {
Client Clientèle[100] ; for (int i=0, i<100 ; i++)
if (Clientèle[i].Dans_Le_Rouge()) cout<<… ;
}
3.1.3. Encapsulation de données private/public
3.2. Constructeur et destructeur 3.2.1. Généralités
Un constructeur est appelé automatiquement.
Destructeur : pareil, sauf que par défaut, il ne fait rien ! Constructeur :
- porte le nom de la classe - n’a aucun type
Destructeur :
- porte le nom de la classe précédé par un ~ - n’a aucun type
.h class Chaine .cpp appli
{ main()
char *s ; {
public: Chaine s1 ;
Chaine(void) ; Chaine s2(100) ;
Chaine(int) ; …
~Chaine(void) ; }
} ;
.cpp Chaine::Chaine(void) {
s=NULL ; }
Chaine::Chaine(int Taille) {
s=new char[Taille+1] ; s[0]='\0' ;
}
Chaine::~Chaine(void) {
if (s)
delete []s ; }
<!> NOTION DE LISTE CHAINEE <!>
TElt *CreerListe (double Mat[][TAILLE]) {
TElt *pDebut=NULL, *pCourant ; for (int i=0 ; i<TAILLE ; i++)
for (int j=0 ; j<TAILLE ; j++) {
if (Mat[i][j] != 0) {
pCourant=new Elt ; // alloc. Dynamique pCourant -> Ligne = i ;
pCourant -> Colonne = j ;
pCourant -> Valeur = Mat[i][j] ; pCourant -> pSuiv=pDebut ;
PDebut=pCourant ; }
}
return pDebut ; }
3.2.2. Constructeur par recopie class clx
{
… } ;
clx X1 ; //constructeur par défaut
clx X2(X1) ; //constructeur par (re)copie class clElt
{
int L, C, V ; clElt *pSuiv ;
clElt (const clElt &X) ; // constructeur par recopie
… }
X1 : clElt X1 ;
… ;
clElt X2(X1) ;
X2 : 1 2 3
1 2 3
En général, constructeur par recopie, destructeur et opérateur d’affectation vont ensemble.
class Simple {
int X ; bool Y ; public:
…
… }X1 ;
Simple X2(X1) ; Simple X3 ; X3=X1 ;
class Composee {
int X ; bool Y ; int *p ; public:
…
… }X1 ;
Composee X2(X1) ; Composee X3 ; X3=X1 ;
3.3. Complément sur les classes 3.3.1. Pointeur this
class Clx this est un pointeur constant.
{ Il est possible de transformer
int i ; ce pointeur constant en un pointeur
… constant sur des données constantes
public: pour chaque fonction membre.
F() ; }A ;
A.F() ; Clx::F() {
i=0 ; //this -> i=0 ; }
X Y
1 2 X1
X Y
1 2 X2
X Y
1 2 X3
X Y
1 2 X1
X Y
1 2 X1
X Y
1 2 X1
class Entier {
int i ; public:
int get(void) const ; void set(int) ;
} ;
Entier A ; A.set(2) ;
int Res=A.get() ;
3.3.2. Données et fonctions membres statiques 3.3.2.1. Données statiques
class Test {
static int i ; int j ;
… } ;
int Test::i=3 ; Test X, Y ;
3.3.2.2. Fonctions membres statiques class Test
{
static int i ; int j ;
public:
static int get_i(void) ; } ;
Une méthode statique ne peut accéder qu’aux objets statiques.
Test X, Y ;
Int Res=X.get_i() ; //ou
int Res=Test::get_i() ; 3.4. Amitié
3.4.1. Fonctions amies class A {
int X ;
friend void F(int) ;
… } ;
2 A
j
X
j
Y
i
void F(int B) {
X=B ; // X privé dans A mais ami utilisation OK }
3.4.2. Classes amies class A {
int X ;
friend class B ;
… } ; class B {
int A ; float X ; void F() ;
… } ;
void B::F() {
… }
3.5. Surcharge des opérateurs 3.5.1. Règle
pourquoi : - fonction membre - fonction amie class Vecteur {
int X, Y, Z ;
… public:
…
Vecteur operator+(const Vecteur &) const ; } ;
Vecteur Vecteur::operator+(const Vecteur &V) const {
Vecteur Res ; Res.X=X+V.X ; Res.Y=Y+V.Y ; Res.Z=Z+V.Z ; return Res ; }
main() {
Vecteur V1, V2, V3 ;
…
V3=V1.operator+(V2) ; // V3=V1+V2 ; }
class Vecteur {
int Tab[3] ; int X, Y, Z ;
… public:
…
friend Vecteur operator+(const Vecteur&, const Vecteur&) ;
… } ;
Vecteur operator+ (const Vecteur &V1, const Vecteur &V2) {
Vecteur Res ; Res.X=V1.X+V2.X ; Res.Y=V1.Y+V2.Y ; Res.Z=V1.Z+V2.Z ; return Res ;
}
main() {
Vecteur V1, V2, V3 ;
…
V3=V1+V2 ; }
On est obligé de surcharger par une fonction amie si le premier opérande n’est pas du type de la classe.
Quand on surcharge [], c’est forcément une fonction membre.
int n ; Vecteur V ; N=V[1] ;
lvalue : variable supportant l’opérateur d’affectation (à gauche du =).
int &operator[](int n) {
return Tab[n] ;
} X
Les opérateurs << et >> sont forcément surchargés par fonction amie.
friend ostream operator<< (ostream&, const Vecteur&) ; cout << V1 << V2 ;
cout
friend ostream &operator<< (ostream &F, const Vecteur &V) {
F << "(" << V.X << ", " << V.Y << ", " << V.Z << ")" ; Return F ;
}
friend istream &operator >> (istream&, Vecteur &) ; 3.5.2. Opérateurs de conversion
int A ; float B ; A=B ;
A=(int)B ; //transtypage
Conversion d’un objet de classe X vers un objet de classe T : Constructeur à 1 argument dans la classe T.
class T {
T(X){… …} ; } ;
Par opérateur de cast avec la méthode operator T() dans la classe X.
class X {
… public:
operator T(){… …} ;
… } ;
class Vecteur {
int X, Y, Z ;
Vecteur (int i){X=i, Y=0, Z=0}
operator int() {
return X+Y+Z ; }
… } ; int n ; Vecteur V ;
n=V ; // n=(int)V ; où (int)V vaut X+Y+Z
3.6. Compléments
3.6.1. Objets alloués dynamiquement Vecteur *pV1, *pV2 ;
pV1 = new Vecteur ; // appel du constructeur sans paramètre pV2 = new Vecteur (1,2,3) ; // avec 3 paramètres
3.6.2. Tableau d’objets
Vecteur Tab[3] ; //3 appels du constructeur sans paramètre Vecteur Tab2[3]= {
Vecteur (1,2,3) ; Vecteur (4,5,6) ; Vecteur (1,4,-2) ; } ;
3.6.3. Classe canonique
constructeur avec allocation dynamique destructeur avec libération
constructeur par recopie surcharge de l’opérateur = class Vecteur
{
double *pT ;
… public:
Vecteur (int n) ;
~Vecteur() ;
Vecteur (const Vecteur &) ;
Vecteur &operator =(const Vecteur &) ;
… } ;
3.6.4. Membres objets class clRoue {
float Diam ; int Largeur ; public:
clRoue (float d, int L)// :Diam(d), Largeur(L){}
{
Diam=d ; Largeur=L ; }
} ;
class clVoiture {
public:
clVoiture (char *m, float d, int L) : rAvG(d,L),
rArD(d,L) {
strcpy (Marque, m) ; }
private:
char Marque[20] ;
clRoue rAvG, rAvD, rArG, rAvD ; } ;
Le constructeur de la classe clVoiture appelle déjà le constructeur de la classe clRoue pour les quatre roues.
main() {
clVoiture Titine ("voiture", 60, 10) ; }
3.7. Exemples main() {
Set_int Set1(10) ; Set_int Set2(Set1) ; set < 5 < 2 ;
cout << set[10] ; Set1=Set2=Set3 ; }
class Set_int {
int *adval ; int nmax ; int nelem ; public:
Set_int (int=5) ;
~Set_int () ;
Set_int (const Set_int &) ;
Set_int &operator = (const Set_int &) ; } ;
Set_int &Set_int :: operator=(const Set_int &e) {
if (this != &e) {
delete []adval ;
adval=new int [nmax=e.nmax] ; nelem=e.nelem ;
for (int i=0 ; i<nelem ; i++) adval[i]=e.adval[i] ; }
return *this ; }
Set_int ::Set_int (int nb) {
adval=new int [nb] ; nmax=nb ;
nelem=0 ; }
Set_int :: ~Set_int() ; {
delete []adval ; }
Set_int :: Set_int (const Set_int &e) ; {
adval=new int [nmax=e.nmax] ; nelem=e.nelem ;
for (int i=0 ; i<nelem ; i++) adval[i]=e.adval[i] ; }
bool Set_int :: operator[] (int nb) ; {
bool Res, Sortie=false ; int i=0 ;
while (!Sortie) {
if (i>=nelem) {
Sortie=true ; Res=false ; }
else if (adval[i]==nb) {
Sortie=true ; Res=true ; }
else
i++ ; }
return Res ; }
Set_int &Set_int :: operator< (int nb) {
if (!(*this)[nb] && nelem < nmax) adval[nelem++]=nb ;
return *this ; }
3.8. Généricité
classes génériques patrons de classe Déclaration (.h)
template <class T> class Stack {
public:
Stack (int s) ;
Stack(){delete[] adr ;} ; void Push (T Elem) ;
T Pop ;
bool Empty() const {return Top==NULL ;}
bool Full() const ; int howmany() const ; private:
T *adr ; T *Top ; int size ; } ;
Définition (.h, le même)
La définition d’une classe générique doit se faire en ligne ou en dehors de la classe mais pas dans un fichier séparé.
template <class T> Stack <T> :: Stack (int s) {
adr = new T[s] ; Top=NULL ;
size=s ; }
template <class T> void Stack <T> :: Push (T Elem) {
if (Top==NULL) Top=adr ;
else // on suppose pile non pleine Top++ ;
*Top=Elem ; // *Top est la valeur pointée }
template <class T> T Stack <T> :: Pop() {
T Elem ;
Elem = *Top ; //on suppose pile non vide if (Top==adr)
Top=NULL ; else
Top-- ; return Elem ; }
pgTest.cpp
#include "_____.h"
class ClTruc {} ; main ()
{
Stack <int> PileEnt(10) ; Stack <char> PileChar(100) ; Stack <ClTruc> PileTruc(5) ; }
3.9. Librairie STL
3.9.1. Introduction
C’est une collection de types de données et d’algorithmes.
Elle est basée principalement sur la programmation générique.
On va manipuler des conteneurs et des itérateurs.
3.9.2. Conteneur
C’est un objet qui contient d’autres objets.
o conteneurs séquentiels o conteneurs associatifs 3.9.2.1. Conteneurs séquentiels
Séquence d’objets de même type stockés linéairement.
3 types :
vector : comme les tableaux - accès par indice [i]
- insertion ou suppression en fin de tableau list :
- insertion ou suppression n’importe où - [i] impossible !
- outils de fusion deque :
- file d’attente à double accès - [i] est possible
- insertion suppression aux deux extrémités - insertion suppression n’importe où
- fusion impossible
- peut faire une file ou une pile 3.9.2.2. Conteneurs associatifs
set , multiset , map , multimap
set ensemble qui ne contient que des clés ayant des valeurs uniques multiset pareil, valeurs non uniques
map tableaux associatifs qui contiennent des paires <clé, valeur>.
Chaque clé ne peut référencer qu’une valeur.
Données triées par clé. >>>> opérateur < doit être défini 3.9.2.3. Méthodes des conteneurs
voir polycopié 3.9.3. Itérateurs
Similaire à un pointeur sur un élément de la séquence.
Spécifie une position dans le conteneur.
Valide s’il pointe sur quelque chose : il faut le comparer à la fin de la séquence.
L’opérateur * renvoie l’objet contenu.
Il existe différentes sortes d’itérateurs en fonction des opérations qu’ils peuvent fournir
itérateurs d’entrée lecture seule du conteneur itérateurs de sortie écriture en avant
itérateurs en avant parcourt en lecture ou écriture en avant itérateurs bidirectionnels pareil en avant ou en arrière itérateurs à accès aléatoire
3.9.4. Classe string
(dans la bibliothèque standard C++) voir polycopié
3.10. Exceptions
throw try catch
signaler détecter traiter
throw permet de signaler l’exception aux fonctions ayant appelé la fonction qui vient de lancer l’exception.
Sil a mise en place du traitement (try) est prévue : traitement (catch). Sinon, une fonction appelle abort().
main() void F1()
{ {
… …
try if (…)
{ throw 0 ;
F1() ; …
F2() ; }
}
catch (int i) void F2()
{ {
… …
} if (…)
catch (char *s) throw "exemple" ;
{ …
… }
}
… }
catch (type NomVariable) {
… }
ou catch (type) {
… }
ou
catch (…) // "…" signifie tout type d’exception { // c’est donc une gestion anonyme
… // NON RECOMMANDEE ! }
