Introduction.................................................................................................................................

2
Exemple......................................................................................................................................3
Extensions C++...........................................................................................................................4
Les classes.................................................................................................................................14
introduction aux classes............................................................................................................15
Classes et allocation..................................................................................................................27
Notions avancées.......................................................................................................................40
Dérivation et heritage................................................................................................................46
Les patrons de fonctions et de classes ......................................................................................53
Surcharge des opérateurs..........................................................................................................58
Conversion de classe.................................................................................................................63
Méthodes virtuelles...................................................................................................................64
Heritage multiple.......................................................................................................................67
Heritage ou composition...........................................................................................................69
Les exceptions...........................................................................................................................71
Complément..............................................................................................................................75
Propriétés et identificateur........................................................................................................79

LANGAGE C++ 1
 INTRODUCTION

Historique
C++ est un langage dérivé du C (ATT 1980)
• Avec des types de données abstraits.
• C++ est un Langage Orienté Objet.
• Amélioration des structures du C.

C++ est normalisé par ANSI C et ATT 2.1

Compilateur moins permissif que celui du C

Les enjeux
Une nouvelle approche du développement ...
La réutilisation

Notes

LANGAGE C++ 2
 EXEMPLE

HELLO WORLD
Langage C
#include <stdio.h>
void main()
{
printf ( ″ hello world\n ″ ) ;
}

Langage C++
#include <iostream.h>
void main()
{
cout << ″ hello world\n ″ << endl ;
}

Iostream.h
cout << ″ entrez DEUX nombres ″ << endl ;
cin >> A >> B ;
cout << ″ La somme de A + B = ″ << A+B << endl ;

Notes

LANGAGE C++ 3
 EXTENSIONS C++

Quelques nouveautés
Les commentaires
/* ceci est un commentaire C */
// ceci est commentaire C++

La déclaration des fonctions

Le C++ attend un prototype pour chaque fonction.

void Afficher( char * ); // prototype

void Afficher( char * szText)
{ } //la déclaration de la fonction

Les arguments par défaut

Dans la déclaration du prototype d’une fonction, on peut prévoir des valeurs
par défaut pour certains arguments.
void Afficher ( int qte= 15 , char *nom =
″ Toto″ );

Afficher( 60, ″ vide″ ); //( 60,″ vide″ )

Afficher( 60 ); //( 60,″ Toto″ )
Afficher( ); //( 15,″ Toto″ )
Afficher( , ″ Truc″ ); // Erreur !

Notes

EXTENSIONS C++ 4
Les entrées , sorties
Surdéfinition des opérateurs >> et << pour s’adapter au format.

Entrées
Caractère :
char c ;
cin >> c ; /* ou */ cin.get(c) ;
cout << c ; /* ou */ cout.put(c) ;
Chaîne :
char tab[100] ;
cin >> tab ; // attention taille [100]
cin.get(tab,100,’\n’) ;
//get place un ‘\0’ en fin de chaîne
//second argument, n-1 caractères seront lus
//troisieme argument précise le caractère de fin
//attention : ‘\n’ reste toujours dans le buffer

Notes

EXTENSIONS C++ 5
Notes

EXTENSIONS C++ 6
Les déclarations de variables
En C les déclarations se font en début de bloc.
En C++ l’emplacement des déclarations est libre.

void main()
{
..... // i n’est pas connu
for ( int i = 0 ; i < 5 ; i++)
{ // i est connu
int y ; // y est connu
}
... //i n’est plus connu:(attention pas toujours)
// y n’est plus connu
}

La portée des variables

En C, une variable locale prend la précédence sur une variable globale de
même nom.
En C++, on peut forcer l’usage de la variable globale avec « :: ».

int numero = 25; //variable globale

void main(){
int numero = 50; //variable locale
cout << numero<< endl; //sur variable locale
cout << ::numero<< endl; //sur variable globale
}

« :: » ne donne accès qu'aux variables globales.

Notes

EXTENSIONS C++ 7
Les fonctions « inline »
Les instructions d’une fonction en ligne ou développée sont incorporées par le
compilateur à chaque appel.
Evite la perte de temps lors de l’appel.
Mais les instruction sont générées plusieurs fois.

Macro : substitution avec risque d’effet de bord.

Inline : le compilateur vérifie les types.

#define MAX(A,B) ((A)>(B)?(A):(B))

inline int max (int a, int b){

if(a>b) return a ;
return b ;
}
.
.
.
MAX(i++,j++) ; // effet de bord ++ et ++
max (i++,j++) ; // correct

Notes

EXTENSIONS C++ 8
l’identifiant « const »
C++ étend la notion de « const » existant en C
Ne spécifie la valeur que lors de l’initialisation.
Assure que sa valeur ne sera pas changée à l’intérieur de sa portée.

const int size=20 ;

char cBuffer[size] ; // illégale en C, correct C+
+

cout<< ″ taille de cBuffer = ″ << sizeof(cBuffer) ;

Pointeur sur une constante

const char *pCst= ″ TOTO″ ;
pCst[2]=’t’ ; //erreur chaîne constante
pCst=autreChaine ; // OK !

Pointeur constant
char * const pCst= ″ TOTO″ ;
pCst[2]=’t’ ; // OK !
pCst=autreChaine ; //erreur pointeur constant

Argument constant
char strlen(const char *pSrc) ;

Fonction constante
void Help() const ;
X::Help() const{...}

Retourne un pointeur sur une constante

const char *Peek(int i){ return tab[i] ;}

Pointeur constant sur une constante

const char *const pCst= ″ TOTO″ ;
Notes

EXTENSIONS C++ 9
Les fonctions surchargées.
En C++, plusieurs fonctions peuvent posséder le même nom.
Le compilateur choisit la bonne fonction
par rapport à la signature de la fonction, (type et nombre d’arguments).
le type de la fonction doit toujours rester le même, (même type de retour).

void ma_StrCpy(char *pDest, const char *pSrc) ;

void ma_StrCpy(char *pDest, const char *pSrc, int
len);

 Attention : si des arguments par défaut sont définis

et aux conversions implicites sur les types.

void f(long int i) ;

void f(long double i) ;

f(5) ;//Ambiguity between …

L’évasion vers le C.
Annuler l’encodage des fonctions avec une directive de lien.

extern ″ C″ strlen (const char*) ;

Notes

EXTENSIONS C++ 10
 Les références.
Un nouveau type de variable C++.

Initialisé puis impossibilité de modifier une référence.

int numero= 10 ;
int &ref= numero ; //reference
cout<< numero ;
cout << ref ; // même resultat

Déclarations :

char c ;
int i ;

int &r1=1024 ; // warning (erreur suiv syst )

const int &r2=1024 ; //w.temporary used to
initialize

int &r3=c ; //w.temporary used to initialize

//char -> int
int &r4=&i ; : // error convert int* to int
int *&r4=&i ; // OK !
int &r4=i ; // ok !

Utilisation :
cout<< &i << &r4 ; //même adresse

 Une référence du type void n’est pas autorisé.

void & X ; //erreur

Notes

REFERENCE EN C++ 11
Références et paramètres de fonction
En C les paramètres sont passés aux fonctions par valeur, et pour modifier un
paramètre, on le passe par adresse en le récupérant par un pointeur.
En C++, une troisième option : passage par référence.

struct MaStruct{
int numero ;
char nom[25] ;
} ;

void ParVal(MaStruct s) ; // par valeur

void ParPtr(MaStruct *s) ; // par pointeur
void ParRef(MaStruct &s) ; // par référence

main(){
MaStruct x ={5,″ toto″ };
ParVal(x) ;
ParPtr(&x) ;
ParRef(x) ;
return 0 ;
}
void ParVal(MaStruct s) // par valeur
{ cout<<endl<<s.numero<<endl<<s.nom ;
}
void ParPtr(MaStruct *s) // par pointeur
{ cout<<endl<<s->numero<<endl<<s->nom ;
}
void ParRef(MaStruct &s) // par référence
{ cout<<endl<<s.numero<<endl<<s.nom ;
}

Notes

REFERENCE EN C++ 12
Exercices (01)

Programme de permutation de données « swap(a,b) »

cout, cin, <iostream.h>

fonctions surchargées
avec pointeurs et références

Utilisation du debugger
pose de points d’arrêt
visualisation des variables
visualisation de la hiérarchie des classes « iostream »

Notes

REFERENCE EN C++ 13
 LES CLASSES

Plan
Introduction aux classes
Déclaration d’une classe.
Propriétés et méthodes.

Classes et allocation dynamique

Les opérateurs « new » et « delete ».
Classes avec des pointeurs membres.

Classes template
Déclaration d’une classe générique.
Propriétés et méthodes générique.

Notions avancées
Membres statiques.
Classe et fonction « friend ».
Surcharge des opérateurs.

Les exceptions

Notes

CLASSES C++ 14
 INTRODUCTION
AUX CLASSES

Déclaration d’une classe

La structuration des données en C
struct SDate{
short int annee;
short int mois,
jour;
};

Pas de contrôle sur les données.

Toujours accès aux membres de la structure.
Pas d’indépendance par rapport à l’implémentation.

Les classes C++

Une classe = propriétés (données membres).
méthodes (fonctions membres).

Une classe = une section « public ».

une section « protected ».
une section « private ».

Les propriétés (données) sont encapsulées.

Accès aux propriétés par les méthodes.
Indépendance par rapport à l’implémentation.

Notes

CLASSES C++ 15
Déclaration de la classe
class TDate{
public:
TDate(int j,int m,int a); //constructeur
~TDate(); //destructeur
void Afficher();

private:
int annee,mois,jour;
};

Définition des méthodes

TDate::TDate(int j,int m,int a){ //constructeur
//contrôle sur les arguments ex j>0…

//renseigner les propriétés

jour=j;
mois=m;
annee=a;
}
TDate::~TDate(){ //destructeur
}
void TDate::Afficher(){ //méthode
cout<< jour <<‘/’ << mois << ‘/’ <<annee;
}

Notes

CLASSES C++ 16
Implementation de la classe

Fichier Header.h
Placer dans un « .h » ou un « .hpp » la définition de la classe.

Néanmoins:
La partie privée de la classe est visible.
Les propriétés inline sont visibles.

Fichier Source.cpp

Placer l’implémentation des méthodes de la classe.

Notes

CLASSES C++ 17
Visibilité des membres
Public:
Les membres public sont accessibles par tout le programme.
Les membres public définissent l’interface de la classe.

class TXX{
public:
int Calculer(int);
void Afficher();
...
Par convention: ne mettre que des méthodes en public.

Private:
Les membres privés ne sont accessibles que par les méthodes membres (ou
friend , notion vue plus tard).

class TXX{
private:
int numero;
...

Protected:
Un membre public pour une classe dérivée.
Un membre privé pour le reste du programme.

Notes

CLASSES C++ 18
Les propriétés
Accès par des méthodes membres

class TDate{
public:
TDate(int j,int m,int a); //constructeur
~TDate(); //destructeur

int GetJour() { return jour;}

int GetMois() { return mois;}
int GetAnnee() {return annee;}

int SetJour(int j);

int SetMois(int m);
int SetAnnee(int a);
...

Limiter les propriétés publiques

Permettre le contrôle des données saisies.
Assurer l’indépendance avec l’implémentation (encapsulation).
Chaque classe est responsable de son INTÉGRITÉ.

Notes

CLASSES C++ 19
Exemple de classe

Accès aux propriétés

class TDate{
public:
...
};

main(){
int i;
TDate Anniversaire(2,8,90);
...
i= Anniversaire.mois; //erreur accès private
...
i=Anniversaire.GetMois();
...
Anniversaire.SetAnnee(88);
...
return 0;
}

Mise en œuvre
Saisie d’un ensemble de dates.
Déclaration de variables TDate (locale et global).
Suivi avec les outils de DEBUGGING.
Inspection de la classe créée.

Notes

CLASSES C++ 20
Les méthodes
 Accès aux propriétés membres de sa classe.
 Pas d’accès aux propriétés d’une autre classe.
 Sa portée est limitée à sa classe et non au fichier.
 Ne peut surcharger que des méthodes membres de sa classe.

Rôle
Méthodes de gestion constructeur/ destructeur
Méthodes exécutrices liées à l’abstraction
Méthodes d’accès lire et écrire
Méthodes internes implémentations internes

Exemple
void TDate::Copier(const TDate& date){
jour=date.jour;
mois=date.mois;
annee= date.annee;
};

Notes

CLASSES C++ 21
Le constructeur
En C pas de contrôle lors de la création d’une structure.
En C++ lors de la création d’une instance (ou un objet) : appel du constructeur.

Le constructeur est appelé automatiquement.

Le constructeur est une méthode particulière membre du nom de la classe.
Le constructeur ne renvoie pas de valeur (pas de type de retour).

Possibilité de définir plusieurs constructeurs :

TDate::TDate();
TDate::TDate(int j,int m, int a);
TDate::TDate(const char *stDate);
TDate::TDate(const TDate& s);

Le destructeur
Fonction membre appelée automatique avant la destruction d’un objet.
Permet les libérations mémoires,...
Pas d’argument ni de type de retour.
Un seul destructeur par classe.

TDate::~TDate();

Notes

CLASSES C++ 22
Objets constants

Déclarer, initialiser un objet et empêcher les modifications.

const TDate anniversaire(15,7,90);

anniversaire.SetJour(16); //erreur

Déclaration de fonctions « READONLY » avec « const ».

Dès que possible, déclarer les fonction « const ».

class TDate{
public:
int GetJour() const; //readOnly
...
int SetJour(int j);
...
}
...
int TDate::GetJour()const{
return jour;
}
...

main(){
int i;
const TDate Anniversaire(17,7,77);
...
i= Anniversaire.GetJour();
return 0;}

Notes

CLASSES C++ 23
Exemple de classe

Compléter la classe TDate avec des méthodes membres

L’action du constructeur et du destructeur ?

Résultat de Anniversaire.Copier(Anniversaire) ?

Suivi avec les outils de debugging

Notes

CLASSES C++ 24
Les objets membres d’une classe
Une classe peut contenir des instances comme membres.
Création de classe par composition

Distinguer composition et dérivation

Déclaration
class TPersonne{
public:
...
private:
char szNom[25];
char szAdresse[100];
TDate naissance; //pas d’arguments
};

naissance sera construit à la création d’une instance « TPersonne ».

Constructeur
Attention à l’initialisation d’un objet membre.
class TPersonne{
public:
TPersonne(char*nom, char *add,int j,int m,int
a);
...
}; //------------fin classe TPersonne---------------
TPersonne::TPersonne(char*nom,char*add,int j,int m,
int a):naissance(j,m,a){
...
strncpy(szNom,nom,25);
strncpy(szAdresse,add,100);
}//-------------------------------------------------
Notes -

CLASSES C++ 25
 Le constructeur « TDate » est invoqué pour l’instance naissance.
Si on ne définit pas d’initialisation de naissance, le constructeur par défaut de
« TDate » sera invoqué.
Erreur s’il n’y a pas de constructeur par défaut défini pour « TDate ».

Accès aux données privées de naissance par les méthodes membres.

TPersonne::TPersonne(...){
...
naissance.SetJour(27);
naissance.SetMois(7);
naissance.SetAnnee(1982);
}
Si l’instance « naissance » est déclarée en « const »
alors « init » est obligatoire.

Initialisation de propriété constante

Une propriété const ne peut recevoir de valeur dans le constructeur.
class TCompte{
public:
TCompte(int num);
...
private:
const int numeroCompte;
};
//-----------------------------------
TCompte::TCompte(int num):numeroCompte(num){ }

Exemple de mise en oeuvre

Composition de classes.
Constructeurs et destructeurs.
Suivi avec DEBUGGING.

Notes

CLASSES C++ 26
 CLASSES ET
ALLOCATION

MALLOC et FREE
En C, la mémoire disponible: coreleft (pile :stackavail)

En C++, la mémoire disponible:

Operateur NEW

Allocation en C
malloc ne connaît pas de type d’objet alloué.

struct Date *ptr;

ptr=(struct Date*) malloc(sizoef(struct Date));

En C++
« malloc » n’est pas approprié pour allouer un objet car le constructeur de la classe
n’est pas invoqué.
On utilise l’opérateur « new » qui connaît le type de l’objet. « new » invoque
automatiquement le constructeur approprié.

Notes

ALLOCATION 27
Operateur new

« new » n’est pas une fonction mais un opérateur.

« new » retourne un pointeur du type de l’objet.

Operateur DELETE

En C malloc et free
En C++ new et delete

« delete » invoque automatiquement le destructeur de la classe.

TDate *ptr;
...
ptr = new TDate(1,2,90);
...
delete ptr;

Notes

ALLOCATION 28
NEW et DELETE
Pour des types simples
int *ptr;
ptr = new int;
...
delete ptr;

Pour des tableaux dynamiques

int taille;
char *ptr;
...
ptr = new char[taille];
...
delete [ ] ptr;

Pour des tableaux multi dimensionnel

int taille;
int (*matrice)[10];
...
ptr = new int[taille][10];
...
delete [ ] ptr;

Tableau de pointeurs sur fonctions

ptr = new (int(*[10])());
//tableau de 10 pointeurs sur fonctions sans
argument
//et retournant un int

Notes

ALLOCATION 29
Classe avec pointeurs membres

Réalisation d’une classe « TString »

public:
Plusieurs constructeurs
Destructeur
Lire un caractère TString::GetChar
Ecrire un caractère TString::SetChar
Obtenir sa longueur TString::GetLen
Afficher la chaîne TString::Afficher
Recopier TString::Copier
Concaténer TString::Append

private:
taille de la chaîne int length
contenu de la chaîne char *string

Notes

ALLOCATION 30
Opérateur d’assignation

Problème avec la classe TString

TString s1(″ chien″ );

TString s2(″ chat″ );

s2=s1; // assignation d’objet

Lors de l’assignation d’instance le compilateur : membre à membre.

s2.length = s1.length;
s2.string = s1.string; // ????

La chaîne « chat » n’est pas désallouée.

« s1.string » et « s2.string » pointent sur la même zone.
Problème à la destruction de seconde instance.

Pour les classes avec pointeurs l’opérateur standard

d’assignation n’est pas satisfait

Notes

ALLOCATION 31
Surcharge de l’opérateur d’assignation

Définir une fonction membre de nom operator =( )

s1 =s2;
s1.operator = (s2); //moins lisible

class TString{
public:
...
void operator = (const TString& src);
...
};

void TString::operator=(const TString & src){

length = src.length; // copie de la longueur
delete [] string; // libérer string initial

string = new char[length +1]; // réallouer

::strncpy(string,src.string,length+1);
string[length]=‘\0’;
}

Notes

ALLOCATION 32
Le pointeur THIS
Encore un problème sur TString

TString s1;
...
s1 = s1; // self assignation

TString *ptr= &s1;

s1=*ptr; // self assignation

Le pointeur THIS
• Pointeur spécial accessible aux fonctions membres.
• Pointe sur l’instance pour laquelle la méthode est appelée.
• Pas de pointeur « this » pour les méthode « static » (voir plus tard).

A l’appel d’une méthode membre le compilateur renseigne « this »

void TDate::Afficher(){
cout << mois;
cout << this->mois;
cout << (*this).mois;
}

void TString::operator=(const TString & src){

if( &src == this)

return; //self assignation
...
}

Notes

ALLOCATION 33
 return *this
a = b = c;
cout<< a << b << c ;

Ces opérateurs doivent retourner l’objet désigné

TString& TString::operator=(const TString& src){

...
return *this; //par référence
}

Attention
this est un pointeur constant qui ne peut pas être modifié
(this est supporté différement suivant les versions C++)

TString& TString::operator=(const TString & src){

if( &src == this)

return *this; //self assignation

length = src.length; //
delete [] string; //
//
string = new char[length +1]; //
::strncpy(string,src.string,length+1); //
string[length]=‘\0’; //

return *this;
}

Notes

ALLOCATION 34
Exemple
Réaliser une classe TEnsemble d’entiers

Support des opérations suivantes:

Ajouter un élément
Déterminer le cardinal de l’ensemble
Déterminer si un élément appartient à l’ensemble

Conserver dans un tableau dynamique les éléments

Programme « main » utilise cette classe

Essayer le passage par valeur d’une instance de TEnsemble

Définir une autre implémentation de cette classe

Notes

ALLOCATION 35
Assignation et initialisation
Assignation
Changer la valeur d’un objet existant

int i;
TString s1,s2;

...
i=3;
s1 = s2; // invoque operator=()

Initialisation

Définir la valeur lors de la déclaration de l’instance

int i;
TString s1(″ chien″ ); //invoque un
constructeur
TString s2(s1); //invoque copy constructor

Notes

ALLOCATION 36
Copy constructor
Déclaration
Un constructeur prend comme argument une instance de même type.

TString s2 = s1;
TString s2(s1);

Par défaut l’initialisation effectue une copie membre à membre. Les mêmes
problèmes que lors de la copie d’une chaîne

class TString {
public:
TString(const TString& src);
...
}

TString::TString(const TString& src)

{
length=src.length;
string = new char[length+1];
strcpy(string, src.string);
}
operator= agit sur une instance existante, retourne *this
copy constructor crée une nouvelle instance

A définir pour les classes avec pointeurs membres

Utilisation
Lors de la déclaration
Lorsqu’une fonction ou une méthode reçoit un objet comme paramètre
Lorsqu’une fonction ou méthode retourne un objet.

Notes

ALLOCATION 37
 Objet comme argument

void func(TString param){ //par valeur

//initialisation par copy constructor,
//problème sur string si pas de copy constructeur
}
void main(){
TString auto(″ voiture″ );
func(auto);
}

Objet comme retour

TString getInfo(){
TString Info(″ version 1.32″ );
return Info;
}
void main(){
TString version;
version=getInfo();;
}

Notes

ALLOCATION 38
Passer et retourner des références
Eviter la surcharge occasionnée par l’appel du copy constructor
Passer des références pour éviter la création d’objet temporaire
La fonction ou l’instance utilise les mêmes instances que l’appelant

Passer une référence

void func(TString& param){
//utilise l’instance param, pas de copie constructeur
}
void main(){
TString auto(″ voiture″ );
func(auto);
}

Retourner une référence

TString &TString::operator=(const TString & src){
...
return *this;;
}

Attention:
Ne pas retourner de référence sur une variable locale

Notes

ALLOCATION 39
 NOTIONS
AVANCÉES

Les propriétés statiques

Déclaration
Définir des propriétés commune à toutes les instances de cette classe.
class TCompte{
public :
TCompte() ;
float Interet(){return(total+= Taux*total );}
static float Taux ;
private :
float total ;
} ;//---------------------------------
void main(){
TCompte cpt ;
cpt.Taux=17.6 ; //correct
TCompte ::Taux= 17.6 ; //conseillé
}

Initialisation
Les propriétés statiques ne sont pas initialisées par le constructeur.
Initialisées comme des variables globales

TCompte ::Taux= 17.6 ; // pas dans le « header »

Notes

NOTIONS AVANCEES C++ 40

Les méthodes statiques
Les méthodes membres qui n’accèdent qu’aux propriétés statique de la classe.
N’agissent pas sur une instance particulière, donc pas de pointeur « this »

class TCompte
{
public :
static SetTaux(float ntx){
Taux=ntx ;
}
private :
static float Taux ;
}

void main()
{
TCompte : :SetTaux(10.6) ;
}

Les membres statiques :

Gestion des ressources communes à la classe
Nombre d’instance de la classe
...

Notes

NOTIONS AVANCEES C++ 41

Les FRIENDS
Rendre accessible à certaines classes ou méthodes les propriétés privées.
La classe donne une autorisation explicite d’accès à ses données.
Le mot clé « friend » autorise l’accès sans restriction.
L’amitié n’est pas transitive, l’amitié est dérivée.

Les classes amies

class TAppart{
public :
friend class TImmeuble ; //autorise l’accès
private :
int cle ;
} ;//--------------------------------
class TImmeuble{
public :
void change(TApart m) ;
} ;//-------------------------------
void TImmeuble :: change(TAppart m){ m.cle ++ ;}

Les fonctions « friend »

Donner l’accès à une fonction et non plus à une classe.
Principalement utilisée pour la surcharge des opérateurs.
class TAppart{
public :
friend void change(TAppart);
private :
int cle ;
} ;
void change(TAppart m){
m.cle ++ ;
}

Notes

NOTIONS AVANCEES C++ 42

Les tableaux d’instances

Déclaration

Le constructeur est appelé pour chacune des instances.

TDate Anniversaire[10];//tableau de 10 instances

Initialisation possible :
appel explicite de constructeur

TDate Anniversaire[10]= {
TDate(17,7,77),
TDate(27,7,82) } ;

Allocation dynamique

TString * text ;

text = new TString[5] ; //pas d’initialisation

. . .
delete [] text ; //5 appels du destructeur

Notes

NOTIONS AVANCEES C++ 43

Surcharge de NEW et DELETE
Pour définir le comportement de « new » et « delete ».
 « new » et « delete » sont des operateurs.

Général
A la création, appel de new puis du constructeur.

void * operator new (size_t taille){

. . .
}
void operator delete(void *ptr){
. . .
}

Spécifiques à une classe

class TAppli{
public :
void * operator new (size_t taille) ;
void operator delete(void *ptr) ;
. . .
} ;

« new » est appelé avant le constructeur.

« delete » est appelé après le destructeur.
« new » et « delete » sont considérées comme des fonctions « static »

Notes

NOTIONS AVANCEES C++ 44

_set_new_handler (new.h)
Personnaliser l’allocation dynamique de mémoire

En C, « malloc » retourne NULL si erreur.

En C++, « new » retourne 0 si erreur.

« _set_new_handler » permet de définir une gestion d’erreur. En cas d’erreur,

l’opérateur « new » appel la routine ainsi définie.

Evite ainsi de tester le reour de « new » à chaque appel ;

#include <iostrem.h>
#include <stdlib.h>
#include <new.h>

int Finish(size_t taille)

{
cout<< ″ Plus de mémoire dispo.\n″ ;
exit(1) ;
}

void main()
{
_set_new_handler(Finish) ;
while(. . .){
//allocation avec new…
}
}

Notes

NOTIONS AVANCEES C++ 45

 DÉRIVATION ET
HERITAGE

La structuration des données en C

Exemple d’une entreprise avec plusieurs catégories de salariés.

Un structure par catégorie

 réecrire les ″ mêmes fonctions ″ pour chaque catégorie.

Une structure générale

un seul ensemble de fonctions

perte de place, nombreux champs inutillisés.

Utilisation de unions

 des fonctions avec « switch » sur le type d’employé

Notes

HERITAGE 46
Les classes dérivées en C++
Une classe de base « TEmploye »: caractéristique communes.

class TEmploye
{
public :
TEmploye(const char*n) ;
char *GetNom() ;
private :
char *nom ;
} ;

Des classes dérivées pour chaque catégorie d’employés.

class TSalarie :public TEmploye

{
public :
TSalarie(const char*n) ;
void SetPaie(float p) ;
private :
float heures;
float salaire ;
} ;

Notes

HERITAGE 47
Classe dérivées

Chaque instance de « TSalarie » contient les propriétés membres de

« TEmploye »
Accès aux méthodes membres de « TSalarie » et de « TEmploye ».

Les méthodes membres de la classe dérivée n’ont pas accès aux

propriétés privées de la classe de basse.

Une classe dérivée doit utiliser l’interface public de la classe de base.

Une classe dérivée peut devenir une classe de base .

class TCommercial : public TSalarie

{
. . .
private :
float commission ;
float ventes ;
} ;

class TA : public TB //dérivation publique

Les membres « public » de la classe base restent des membres « public ».

class TA : private TB //dérivation privée

Les membres « public » de la classe base deviennent des membres « privés ».

Notes

HERITAGE 48
Les membres protected
Définir des membres privés accessibles aux méthodes de la classes dérivées.
(A utiliser avec soin, perte du bénéfice de l’encapsulation)
class TBase {
public :
int PasSecret ;
protected :
int SecretDeFamille ;
private :
int SecretPerso ;
} ; //------------------------------
class TDerive : public TBase{
public :
int Acces() ;
} ;//------------------------------
int TDerive ::Acces(){
PasSecret = 3; //-- OK
SecretDeFamille = 2; //-- OK
✭ SecretPerso = 1; //-- erreur
}//------------------------------
void main(){
TBase pere ; TDerive fils ;
pere.PasSecret = 3; //-- OK
pere.SecretDeFamille = 2; //- erreur
pere.SecretPerso = 1; //- erreur

fils.PasSecret = 3; //-- OK
fils.SecretDeFamille = 2; //- erreur
fils.SecretPerso = 1; //- erreur
}

Notes

HERITAGE 49
Redéfinir une méthode de la classe de base

Le calcul de paie de chaque catégorie d’employés

float TSalarie::CalculPaie()const
{
return heure * salaire ;
}

float TCommercial :: CalculPaie()const

{
return (heure*salaire + commission*vente) ;//??
return (CalculPaie() + commission*vente) ;//??
return (TSalarie::CalculPaie()
+commission*vente) ;
}

La classe dérivée appelle la méthode de la classe de base et effectue un

traitement spécifique.

Notes

HERITAGE 50
Constructeur de classe dérivée

Une classe dérivée contient tous les membres de la classe de base.

Le constructeur de la classe dérivé appel le constructeur de base .
Appel du constructeur de base, puis du constructeur dérivé.

TSalarie::TSalarie(const char*n):TEmploye(n)
{
heure=0. ;
salaire=0. ;
}

Conversion de classe

TEmploye * ptrEmp ;
TCommercial * ptrCom ;

TEmploye emp ; //constructeur ??

TCommercial vendeur(″ Dupont″ ) ;

emp = vendeur ; //conversion correcte

vendeur = emp ; //erreur val indéfinies

ptrEmp = &vendeur ;
ptrEmp->SetVente() ; //probl :car ptr TEmploye
ptrEmp->GetNom() ; // OK !

ptrCom =(TCommercial*) ptrEmp ;//dangereux,correct

Notes

HERITAGE 51
Exemple

Une classe TPoint

Propriétés : coordonnées x et y
Méthodes : Get et Set

Définir une classe dérivée de gestion des coordonnées polaires.

Définir les constructeurs.

Déterminer les blocs :

public

private

protected

Définir une classe sans utiliser la dérivation.

Notes

HERITAGE 52
 LES PATRONS DE
FONCTIONS ET DE
CLASSES

Le typage fort
C++ contrôle le type des arguments des fonctions.

Pb : max(int,int) , max(float,float) …

Définir des macros pour les types simples ?

Définir une multitude de fonctions surchargées ?

Fonctions génériques
Un patron ou un modèle de base pour toute une fammile de fonctions surchargées.
Une notation compacte avec contrôle des types.

une fonction générique:

template<class Type> //paramètre formels
Type min(Type a, Type b){
return (a<b?a:b);
}

main(){
min(10,50); //min(int,int)
min(20.5,56.3); //min(double,double)
return 0;
}

Notes

TEMPLATE 53
L'instanciation
La fonction « template » décrit un modèle de construction des fonctions.
Instanciation à l’appel par l’examen des paramètres d’appel.

La surcharge
Une fonction « template » peut être surchargée (signatures différentes)
template <class T> // une classe générique
class TClasse{ … }

template<class T>
T Somme(TClasse<T>, int) ;

template<class T>
T Somme( T *, int) ;

template<class T>
T Somme( T , T ) ;

Spécialisation
Pour un type particulier spécialiser la fonction générique.

template<class T> T Max( T x, T y){

. . .
}
char * Max(char*s1, char *s2){
return(strcmp(s1,s2)<0 ?s2 :s1) ;
}

Notes

TEMPLATE 54
Les classes génériques
Déclaration
Modèle ou classe dite générique pour d’autres classes.

Exemple : conteneurs, tableaux, piles …

template<class T>
class TList{
public :
TList(int n) ;
T& opérator[](int i) {
return liste[i] ;
}
private :
T* list ;
int size ;
}//------------------------

teplate<class T> TList<T> ::TList(int i){

liste= new T[i] ;
size=i ;
}
//------------------------

TList<int> t_int(20) ; //Liste d’entiers

TList<TString> s(20) ; //Liste de chaînes

Notes

TEMPLATE 55
Implémenter une queue

Les Classes

Une classe TQueue sous fome de liste chaînée.

Une classe TQueueItem pour chacun des éléments

Les méthodes de TQueue

Ajouter un élément à la fin de la queue
Retirer un élément au début de la queue
Déterminer si la queue est vide

Remarques :
Envisager TQueue « friend » de TQueueItem

Notes

TEMPLATE 56
Classe « template »
Spécialisation
TQueueItem<char*> ::TQueueItem(char*str){ . . . }

Membres statiques
Une classe template peut déclarer des propriété statique
Chaque instanciation d’un type possède une série de propriétés communes.

TGraphics ::inst ;
x = TXyz ::UneMethode() ;

Types imbriqués
La classe TQueueItem implémentée comme une classe amie.
Possible de déclarer TQueueItem comme classe imbriquée.

Attention au « template »
template<class T>
class TQueue{
. . .
private :
class TQueueItem{
public :
TQueueItem(T val) :item(val),next(0){};
T item ;
TQueueItem *next ;
} ;
TQueueItem *debut, *fin ;
. . .
}

Notes

TEMPLATE 57
 SURCHARGE DES
OPÉRATEURS

Qui ?

Le C++ permet la surcharge :

Les méthodes membres.

Les fonctions indépendantes.

Les opérateurs « new » et « delete ».

Les opérateurs d’une classe.

Attribuer le même identificateur à différentes méthodes.

Le choix de la méthode est fait par le compilateur, Sur la

signature de la méthode (nombre et type de paramètres)

Fournir avec la classe des opérateurs appropriés.

Notes

SURCHARGE DES OPERATEURS 58

Les opérateurs pouvant être surchargés.
Règles
+ - * / % ^ |

< > <= >= == !=

= *= /= += -= << >>

++ -- -> ->* new delete ,

& ~ ! <<= >>= ^= &=

|=
Se limiter aux opérateurs existants et conserver leur pluralité.
Toujours posséder une opérande de type class.

Les opérateurs non surchargeable

. .* :: sizeof

Mise en œuvre par « operator »

Soit par une méthode membre de la classe

Soit par une fonction indépendante (sauf pour : «[]», «( )», «new», «delete» et « -> »)
La méthode membre impose que l’opérande gauche soit une instance de la classe.
exemple :
TString s1,s2 ; //chaîne de caractère
s2 = ″ chat″ ; //operator=
s1 = ″ le ″ + s2 ; //s1= ″ le chat″
const TString& operator= (const char*) ;
friend TString operator+ (const char*, const TString) ;

Notes

SURCHARGE DES OPERATEURS 59

Surcharge par une fonction AMIE
class TPoint{
public :
friend TPoint operator+(TPoint, TPoint) ;
private :
int x,y ;
} ;//-------------------------------------------
TPoint operator+(TPoint a, TPoint b){
TPoint tmp ;
tmp.x = a.x + b.x ;
tmp.y = a.y + b.y ;
retrun tmp ;
}

c=a+b;  c = operator+( a, b ) ;

Surcharge par une méthode membre

class TPoint{
public :
TPoint operator+( TPoint) ;
private :
int x,y ;
} ;//-------------------------------------------
TPoint TPoint :: operator+(TPoint a){
TPoint tmp ;
tmp.x = a.x + x ;
tmp.y = a.y + y ;
retrun tmp ;
}
c=a+b;  c = operator+( a ) ;

Notes

SURCHARGE DES OPERATEURS 60

Exemple class « TString »

operator=()
const TString& operator=(const TString&) ;
const TString& operator=(const char*) ;
const TString& operator=(const char) ;

operator+()
friend TString operator+(const TString&,const
char*) ;
friend TString operator+(const TString &, char) ;
friend TString operator+(char, const TString &) ;
friend TString operator+(const char*,const TString
&);
friend TString operator+(const TString&,const
TString&);

operator+=()
void operator+=(const TString&) ;
void operator+=(const char*) ;
void operator+=(const char) ;

operator==()
BOOL operator==(const TString &,const char*) ;
BOOL operator==(const char*, const TString &) ;
BOOL operator==(const TString&, const TString&);

operator[]()

char operator[](int indice) const ;

Notes

SURCHARGE DES OPERATEURS 61

Remarques

A utiliser à bon escient, attention à l’ambiguïté

dateJ = date1 + date2 ; //signification ?

string1 == string2 //case sensitive ?

La surcharge de l’operateur « operator=( ) » ne peut être hérité.

Utiliser des passages par références

Exemple

Pour une classe TFraction

Numérateur / Dénominateur

Redéfinir l’opérateur « + »

Notes

SURCHARGE DES OPERATEURS 62

 CONVERSION DE
CLASSE

Convertir une classe en un autre type de classe

Conversion par constructeur

class TFraction
{
public :
TFraction(long num, long den = 1) ;
. . .
} ;

// constructeur à un argument
TFraction a(5) ;
TFraction b(6,7) ;

a=8 ;

Conversion par operateur

Définir une méthode membre « operator float() const »

float TFraction :: operator (float) const

{
return ((float)num / (float)den) ;
}

Notes

CONVERSION DE CLASSE 63
 MÉTHODES
VIRTUELLES

Typage statique
En C++ un pointeur sur un type d’objet peut recevoir l’adresse d’un objet descendant.

TSalarie * parSal ;
ptrSal = new TCommercial(″ Dupont″ ) ;

Mais l’appel d’une méthode déclenche la méthode correspondant au type du pointeur

et non au type de l’instance pointée.

ptrSal -> CalculePaie() ;

//TSalarie ::CalculPaie()
// et non TCommercial ::CalculPaie()

En C++, le type d’une instance est déterminée au moment de la

compilation, (typage statique).

Typage dynamique
La détermination de la méthode à invoquer est déterminée à l’exécution, par le type de
l’instance adressé par le pointeur.

Le typage dynamique permet d’étendre la hiérarchie des classes.

L’implémentation utilise des tables mémoire de pointeurs sur méthodes

Notes

MEHODE VIRTUELLE 64
Méthodes virtuelles

Méthode membre redéfinie dans une classe dérivée.

A l’appel de cette méthode depuis un pointeur de la classe de base, c’est la méthode

définie dans la classe dérivée qui sera appelée.

class TEmploye
{
public :
virtual float CalculPaie() const ;
} ;//------------------------
float TEmploye::CalculPaie()const;// jamais utilisée
{ . . .}

class TSalarie : public TEmploye{

public :
float CalculPaie()const ;// virtual inutile
. . .
} ;

TEmploye *ptr ;
ptr = &UnSalarieQ ;
. . .
ptr->CalculPaie() ; // TSalarie::CalculPaie

ptr = &UnCommercialQ ;
. . .
ptr->CalculPaie() ; // TCommercial::CalculPaie

Notes

MEHODE VIRTUELLE 65
Polymorphisme
Appel des méthodes membres sans spécifier le type de l’instance.
Une même méthode possède un comportement différent suivant l’instance.

Edition de lien dynamique

Le compilateur ne peut pas déterminer la méthode à appeler.

Implémentation par tables de pointeurs sur méthodes.

Méthode virtuelle pure

Définir « TEmploye » comme une classe abstraite sans instance propre.

Impossible de créer une instance « TEmploye », mais des pointeurs de type
« TEmploye ».

class TEmploye
{
public :
virtual float CalculPaie()const=0 ;
. . .
}

Les destructeurs virtual

Appel du destructeur dérivé puis du destructeur de base.
 Pb : lors d’un « delete » sur un pointeur de la classe de base.

Définir le destructeur de la classe de base « virtual ». Ansi le destructeur adéquat de la

classe dérivé sera invoqué.

Un constructeur ne peut être virtuel.

Notes

MEHODE VIRTUELLE 66
 HERITAGE
MULTIPLE

Construction
Une classe est dérivée de plusieurs classes de base.

class TMammifere{...}; //classe de base abstraite

class TCarnivore {...}; //classe de base auxiliaire
class TPlantigrade{...};
class TDigitigrade{...};
//les classes dérivées
class TUrsidé : public TMammifere, public
TCarnivore, public TPlantigrade {...}
class TFelidé :public TMammifere,public TCarnivore,
public TDigitigrade {…}
class TOurs:public TUrsidé {...} ;
class TChat:public TFelidé{...};

Appel des constructeur.

TOurs Panda(Yeti) ; //instanciation
Appel des constructeurs :
TMammifere, TCarnivore, TUrsidé et TOurs

Constructeur de «TUrsidé».
TUrsidé::TUrsidé(…):TMammifere(…), TCarnivore(…),
TPlantigrade{ … };

Les destructeurs sont invoqués dans l’ordre inverse.

Notes

HERITAGE MULTI¨PLE 67
Le conflit d’héritage

class TVendeur : public TEmploye{...};

class TDirecteur : public TEmploye{...};

class TDirecteurVente :
public TVendeur, public TDirecteur{...};

Dans « TDirecteurVente », les propriétés de « TEmploye » sont dupliquées.

Attention à l’ambiguité sur identifiants identiques des membres.

Les classes abstraites

Pour éviter la duplication définir des classes abstraites.

class TVendeur : public virtual TEmploye{...};

class TDirecteur : public virtual TEmploye{...};

class TDirecteurVente :
public TVendeur, public TDirecteur{...};

Une classe de base virtuelle est initialisée par sa classe la plus dérivée.

TDirecteurVente:TDirecteurVente(…):TEmploye(…),
TVendeur(…), TDirecteur(…)
{...};

Notes

HERITAGE MULTI¨PLE 68
 HERITAGE OU
COMPOSITION

Les deux manières de réutiliser des classes existantes

Composition : A possède-un B

Héritage : B est-un A

Exemple :

Un « TCercle » n’est pas un « TPoint » mais possède un « TPoint ».

Une « TPile » possède-un ou est-un « TTableau ».

Une « TFenetre » possède-un ou est-un « TBuffer ».

Remarques
Composition :
pour dissimuler une implémentation
pour éviter certains héritage multiples

Héritage : pour utiliser le polymorphisme

Notes

HERITAGE/COMPOSITION 69
Hiérarchie des classes
Abstraction
Généralisation : classe de base
Spécialisation : classe dérivée

Hériter du code
Ecrire une nouvelle classe et réutiliser du code existant.

Regrouper les traitements dans la classe de base.

Les classes dérivées sont des spécialisations.

Hériter des interfaces

Hériter l’indentificateur d’une méthode mais pas le code.

La classe dérivée possède la même interface.

Le code des méthodes est situé dans les classes dérivées.

Assure le polymorphisme.

Notes

HERITAGE/COMPOSITION 70
 LES EXCEPTIONS

Les rubriques
• Lancement d’une exception.
• Gestion d’une exception.
• Spécification d’une exceptions.
• Constructeur et destructeur dans la gestion d’exceptions.
• Exceptions non gérées.
• Paramétrage des options de gestion des exceptions.

Notes

MEHODE VIRTUELLE 71
Définition
Une exception est une situation anormale qui se produit lors de l’exécution
d’un programme.

Gestion des exceptions en C++

Pour gérer une exception il faut préciser le bloc à surveiller avec le mot clé
« try ».
Seules les exceptions synchrones sont gérées, c’est-à-dire que la cause du
problème doit être générée dans le programme.

Bloc à surveiller
...
try {
traitement(. . .);
...
} // fin du bloc à surveiller

Gestionnaire
Le gestionnaire, qui est spécifié par « catch », doit suivre immédiatement le
bloc à surveiller.
...
try {...} // fin du bloc à surveiller
catch(TExept_1 expVide){
//fournit un gestionnaire de type: TExept_1
... // effectuer des actions
}
catch(...){/*interception toute except, quel que
soit son type, (non intercepte précédemment)*/
...
}

Notes

MEHODE VIRTUELLE 72
Lancement d’une exception
L’exception interrompt le déroulement du programme, et teste l’existance d’un
gestionnaire approprié. Si aucun gestionnaire n’est trouvé le programme est
interrompu.

exemple 1:
throw TObjet_Except; //indique que:
//TObjet_Except doit être passée à un gestionnaire

exemple 2:
throw ;//indique que:
//l’exception en train d’être traitée doit être relancée.
//(l’exception doit réellement exister

exemple 3:
void MaFonction() throw (TA,TB){//indique:
//la liste d’exception que MaFonction peut lancer.

... // Corps de la fonction

}

exemple 4:
void MaFonction() throw (){
//indique que: MaFonction ne lance aucune
exception.

... // Corps de la fonction

}

Notes

MEHODE VIRTUELLE 73
 template <class T>
class TTablo10Elem{
public:
...
T& operator [](int indice){
if (indice>=10 || indice<0)
throw TErreurIndice();
}
class TErreurIndice(){
TErreurIndice();
}
private:
T tab[10];
};

Une exception transporte de l’information depuis le point où elle est lancée jusqu’au
point où elle est interceptée.

Lancement:
• Le programme recherche le gestionnaire approprié.
• Si le gestionnaire est trouvé, la pile est déroulée à ce point..
• Le contrôle du programme est remis au gestionnaire.

Notes

MEHODE VIRTUELLE 74
 COMPLÉMENT

Complément « template »
Compilation de modèle de fichier séparé
commutateur:
« -Jgx » générant des références externes aux modèles.
« -Jg » revient à l’état initial du commutateur modèle.
« -Jgd » générant des références publiques .

//vecteur.h
template <class T, int taille> class TVector{
public:
...
private:
T tab[taille];
};// fin du fichier vecteur.h

//vecteur.cpp
#include ″ vecteur.h″
template<class T,int taille> TVector::TVector(){}
...
// générez les instances nécessaires.
#pragma option -Jgd
typedef TVector<int, 100> ;
typedef TVector<char,20> ;
//fin fichier vecteur.cpp

LANGAGE C++ 75
 // fichier source main.cpp
#include ″ vecteur.h″
#pragma option -Jgx
main(){
TVector<int, 100> int_100;
TVector<char, 20> char_20;
...

Complément « exit » et « abord »

exit
« exit » permet d’interrompre l’exécution d'un programme et de fermer tous les
fichiers ouverts avant l'arrêt.
Lorsque vous appelez « exit » dans un programme, les destructeurs ne sont pas
appelés pour aucune variable locale dans la portée en cours. Les variables globales
sont pour leur part détruites normalement.

abord
Si vous appelez « abort » n'importe où dans un programme, aucun destructeur n'est
appelé, pas même pour les variables globales.

Notes

LANGAGE C++ 76
Exceptions
Support de la gestion des exceptions
Les exceptions C++ peuvent être interceptées par référence, par pointeur ou par valeur.
Les exceptions déclenchées par le constructeur:
• Les destructeurs de la classe de base sont appelés uniquement pour les
instances construites entièrement.

terminate
« terminate » est lancée quant une exception est soulevée et que le programmeur n’a
pas prévu de géré. La forme par défaut définie pour « terminate » est un appel à
« abord » qui provoque l’arrêt brutal.

unexpected
« unexpected »(inattendu) l’execution d’une fonction génère une exception qui ne fait
pas partie de la liste des exceptions qu’elle est susceptible de générer. Puis, à son tour
elle appellera « ternimate »

set_teminate
La fonction « void (*)(void)set_terminate(void (*ptr_sur_fonct)(void)) » permet de
remplacer l’appel à la fonction « abord » par un appel à une fonction définie par le
programmeur. La fonction « set_terminate » renvoie comme valeur de retour un
pointeur sur la fonction initialement associée.
Attention : la fonction appelée par « terminate » doit obligatoirement terminer le
programme (par « abord » ou « exit »).

set_unexpected
La fonction « void (*)(void)set_unexpected(void (*ptr_sur_fonct)(void)) » permet de
remplacer la fonction « unexpected ».La fonction ddéfinie par le programmeur en
remplacement ne doit pas rendre la main, mais elle peut générer de nouvelles
exceptions qui seront gérées selon le principe habituel.
En cas de redéfinition de « unexpected », la fonction « terminate » ne sera plus
appelée.

Notes

LANGAGE C++ 77
Exceptions du système d’exploitation
Ces exceptions incluent :
• Violations d’accès.
• Erreurs arithmétiques (de nombres entiers, floattants).
• Débordements de pile.
• Interruption « Ctrl+C ».
ces exceptions sont gérées dans la RTL et converties en instances. Les exceptions du
système d’exploitation ne peuvent être interceptées que par pointeur ou par référence.
=> Par référence est la meilleure approche.

catch (const EAccesViolation &e){...}

Les exceptions standard

xmsg(string&); //erreur:string
xmsg(xmsg&);

xalloc(string&,size_t):xmsg;//erreur:new
Bad_typeid //erreur:typeid
Bad_cast //erreur: dynamic_cast

Notes

LANGAGE C++ 78
 PROPRIÉTÉS ET
IDENTIFICATEUR

Propriétés associer à un identificateur

Les attributs de propriétés sont une extension naturelle des données membres d’un
objet. Le mot clé « __property » permet d’associer un accès lecture/écriture spécialisé
à un identificateur.

Attributs
« stored » détermine si cette propriété doit être enregistrée dans le fichier de fiche
correspondant (.DFM)

« default »
« nodefault »: utilisé par des propriétés pour outrepasser une précédente déclaration
« default=valeur »

« index »: un attribut d’accès d’une propriété

« write »
« read »: spécifier lecture ou écriture d’une donnée membre d’une classe.

« __automated »
« __dispid »

Notes

LANGAGE C++ 79
Exemple
Voici une classe qui déclare trois propriétés utilisant un spécificateur d'index qui
permet à ces trois propriétés d'avoir les mêmes méthodes d'accès read et write :

class TSampleCalendar : public TCustomGrid{

private:
int __fastcall GetDateElement(int Index);
// remarquez le paramètre Index
void __fastcall SetDateElement(int Index,int Val);
public:
__property int Day = {
read =GetDateElement,
write =SetDateElement,
index=3,
nodefault
};
__property int Month = {
read=GetDateElement,
write=SetDateElement,
index=2,
nodefault
};
__property int Year = {
read=GetDateElement,
write=SetDateElement,
index=1,
nodefault
};

};

Notes

LANGAGE C++ 80
 Comme chaque élément de la date (jour, mois, année) est un entier et comme définir
chaque élément demande d'encoder la date, le code évite la duplication en partageant
les méthodes read et write des trois propriétés. Vous n'avez besoin que d'une seule
méthode pour lire un élément de date et d'une seule pour l'écrire.
Voici la méthode read qui extrait un élément de date :

int __fastcall
TSampleCalendar::GetDateElement(int Index){
unsigned short AYear, AMonth, ADay;
int result;
FDate.DecodeDate(&AYear, &AMonth, &Aday);
// décompose la date en éléments
switch (Index){
case 1: result = AYear; break;
case 2: result = AMonth; break;
case 3: result = ADay; break;
default: result = -1;
}
return result;
}//-------------------------------------------------
-

Notes

LANGAGE C++ 81
 Voici la méthode write qui définit un élément de date :

void __fastcall TSampleCalendar::SetDateElement

(int Index, int Value){
unsigned short AYear, AMonth, ADay;
if (Value > 0){
// tous les éléments doivent être positifs
FDate.DecodeDate(&AYear, &AMonth, &ADay);
// obtient les éléments de date
switch (Index){
case 1: AYear = Value; break;
case 2: AMonth = Value; break;
case 3: ADay = Value; break;
default: return;
}
}
FDate = TDateTime(AYear, AMonth, ADay);
// encode la date modifiée
Refresh(); // met à jour le calendrier visible
}

Notes

LANGAGE C++ 82
Introduction.................................................................................................................................2
Historique................................................................................................................................2
Les enjeux...............................................................................................................................2
Exemple......................................................................................................................................3
HELLO WORLD....................................................................................................................3
Langage C...........................................................................................................................3
Langage C++.......................................................................................................................3
Iostream.h............................................................................................................................3
Extensions C++...........................................................................................................................4
Quelques nouveautés...............................................................................................................4
Les commentaires...............................................................................................................4
La déclaration des fonctions...............................................................................................4
Le C++ attend un prototype pour chaque fonction.....................................................4
Les arguments par défaut....................................................................................................4
Les entrées , sorties.............................................................................................................5
Surdéfinition des opérateurs >> et << pour s’adapter au format................................5
Entrées.............................................................................................................................5
Caractère :...................................................................................................................5
Chaîne :.......................................................................................................................5
Les déclarations de variables..................................................................................................7
La portée des variables........................................................................................................7
Les fonctions « inline ».......................................................................................................8
l’identifiant « const »..........................................................................................................9
Pointeur sur une constante..............................................................................................9
Pointeur constant.............................................................................................................9
Argument constant..........................................................................................................9
Fonction constante..........................................................................................................9
Retourne un pointeur sur une constante..........................................................................9
Pointeur constant sur une constante................................................................................9
Les fonctions surchargées.....................................................................................................10
L’évasion vers le C...............................................................................................................10
Les références.......................................................................................................................11
Références et paramètres de fonction...................................................................................12
Exercices (01).......................................................................................................................13
Programme de permutation de données « swap(a,b) ».....................................................13
Utilisation du debugger.....................................................................................................13
Les classes.................................................................................................................................14
Plan........................................................................................................................................14
Propriétés et méthodes..............................................................................................14
introduction aux classes............................................................................................................15
Déclaration d’une classe.......................................................................................................15
La structuration des données en C....................................................................................15
Les classes C++.................................................................................................................15
Déclaration de la classe.....................................................................................................16
Définition des méthodes....................................................................................................16

...............................................................................................................................................16
Implementation de la classe..................................................................................................17
Visibilité des membres..........................................................................................................18
Public:...............................................................................................................................18
 Private:..............................................................................................................................18
Protected:..........................................................................................................................18
Les propriétés........................................................................................................................19
Accès par des méthodes membres ...................................................................................19
Limiter les propriétés publiques........................................................................................19
Exemple de classe.................................................................................................................20
Accès aux propriétés.........................................................................................................20
Mise en œuvre...................................................................................................................20
Les méthodes.........................................................................................................................21
Rôle...................................................................................................................................21
Exemple........................................................................................................................21
Le constructeur..................................................................................................................22
Le destructeur....................................................................................................................22
Objets constants................................................................................................................23
Déclarer, initialiser un objet et empêcher les modifications.....................................23
Dès que possible, déclarer les fonction « const ».....................................................23
Exemple de classe.................................................................................................................24
Les objets membres d’une classe..........................................................................................25
Déclaration........................................................................................................................25
Constructeur......................................................................................................................25
Attention à l’initialisation d’un objet membre..........................................................25
Initialisation de propriété constante..................................................................................26
Exemple de mise en oeuvre..........................................................................................26
Classes et allocation..................................................................................................................27
MALLOC et FREE...............................................................................................................27
Operateur NEW.................................................................................................................27
Allocation en C.............................................................................................................27
En C++..........................................................................................................................27
Operateur new...................................................................................................................28
Operateur DELETE...........................................................................................................28
NEW et DELETE..................................................................................................................29
Pour des types simples......................................................................................................29
Pour des tableaux dynamiques..........................................................................................29
Pour des tableaux multi dimensionnel..............................................................................29
Tableau de pointeurs sur fonctions...................................................................................29
Classe avec pointeurs membres............................................................................................30
Réalisation d’une classe « TString ».................................................................30
Destructeur............................................................................................................30
Opérateur d’assignation....................................................................................................31
Problème avec la classe TString...................................................................................31
Lors de l’assignation d’instance le compilateur : membre à membre...................31
Surcharge de l’opérateur d’assignation.............................................................................32
Le pointeur THIS..................................................................................................................33
Encore un problème sur TString.......................................................................................33
Le pointeur THIS..............................................................................................................33
A l’appel d’une méthode membre le compilateur renseigne « this »....................33
return *this....................................................................................................................34
Ces opérateurs doivent retourner l’objet désigné..................................................34
Exemple............................................................................................................................35
Réaliser une classe TEnsemble d’entiers..........................................................35
 Conserver dans un tableau dynamique les éléments.............................................35
Assignation et initialisation...................................................................................................36
Assignation........................................................................................................................36
Changer la valeur d’un objet existant ..................................................................36
Initialisation......................................................................................................................36
Définir la valeur lors de la déclaration de l’instance............................................36
Copy constructor...................................................................................................................37
Déclaration........................................................................................................................37
Utilisation..........................................................................................................................37
Objet comme argument.................................................................................................38
Objet comme retour......................................................................................................38
Passer et retourner des références.....................................................................................39
Passer une référence......................................................................................................39
Retourner une référence................................................................................................39
Notions avancées.......................................................................................................................40
Les propriétés statiques.........................................................................................................40
Déclaration........................................................................................................................40
Initialisation......................................................................................................................40
Les méthodes statiques..........................................................................................................41
Les FRIENDS.......................................................................................................................42
Les classes amies..............................................................................................................42
Les fonctions « friend »....................................................................................................42
Les tableaux d’instances.......................................................................................................43
Déclaration........................................................................................................................43
Allocation dynamique.......................................................................................................43
Surcharge de NEW et DELETE............................................................................................44
Général..............................................................................................................................44
Spécifiques à une classe....................................................................................................44
_set_new_handler (new.h)...................................................................................................45
Dérivation et heritage................................................................................................................46
La structuration des données en C........................................................................................46
Les classes dérivées en C++..................................................................................................47
Classe dérivées..................................................................................................................48
Les membres protected.....................................................................................................49
Redéfinir une méthode de la classe de base......................................................................50
Constructeur de classe dérivée..........................................................................................51
Conversion de classe.........................................................................................................51
Exemple............................................................................................................................52
Les patrons de fonctions et de classes ......................................................................................53
Le typage fort........................................................................................................................53
Fonctions génériques.............................................................................................................53
L'instanciation...................................................................................................................54
La surcharge......................................................................................................................54
Spécialisation....................................................................................................................54
Les classes génériques..........................................................................................................55
Déclaration........................................................................................................................55
Implémenter une queue.........................................................................................................56
Les Classes........................................................................................................................56
Les méthodes de TQueue..................................................................................................56
Classe « template »...............................................................................................................57
 Spécialisation....................................................................................................................57
Membres statiques.............................................................................................................57
Types imbriqués................................................................................................................57
Surcharge des opérateurs..........................................................................................................58
Qui ?......................................................................................................................................58
Les opérateurs pouvant être surchargés................................................................................59
Règles................................................................................................................................59
Les opérateurs non surchargeable.....................................................................................59
Mise en œuvre par « operator »........................................................................................59
Surcharge par une fonction AMIE........................................................................................60
Surcharge par une méthode membre.....................................................................................60
Exemple class « TString »................................................................................................61
operator=()....................................................................................................................61
operator+()....................................................................................................................61
operator+=()..................................................................................................................61
operator==()..................................................................................................................61
operator[]()....................................................................................................................61
Remarques.........................................................................................................................62
Exemple............................................................................................................................62
Conversion de classe.................................................................................................................63
Conversion par constructeur.................................................................................................63
Conversion par operateur......................................................................................................63
Méthodes virtuelles...................................................................................................................64
Typage statique.....................................................................................................................64
Typage dynamique................................................................................................................64
Méthodes virtuelles...............................................................................................................65
Polymorphisme.....................................................................................................................66
Edition de lien dynamique................................................................................................66
Méthode virtuelle pure......................................................................................................66
Les destructeurs virtual.....................................................................................................66
Heritage multiple.......................................................................................................................67
Construction..........................................................................................................................67
Le conflit d’héritage..............................................................................................................68
Les classes abstraites.............................................................................................................68
Heritage ou composition...........................................................................................................69
Exemple :..............................................................................................................................69
Remarques.............................................................................................................................69
Hiérarchie des classes ..........................................................................................................70
Abstraction........................................................................................................................70
Hériter du code..................................................................................................................70
Hériter des interfaces........................................................................................................70
Les exceptions...........................................................................................................................71
Les rubriques.........................................................................................................................71
Définition..............................................................................................................................72
Gestion des exceptions en C++.............................................................................................72
Bloc à surveiller................................................................................................................72
Gestionnaire......................................................................................................................72
Lancement d’une exception..............................................................................................73
exemple 1:.....................................................................................................................73
exemple 2:.....................................................................................................................73
 exemple 3:.....................................................................................................................73
exemple 4:.....................................................................................................................73
Complément..............................................................................................................................75
Complément « template ».....................................................................................................75
Compilation de modèle de fichier séparé..........................................................................75
Complément « exit » et « abord ».........................................................................................76
exit.....................................................................................................................................76
abord..................................................................................................................................76
Exceptions.............................................................................................................................77
Support de la gestion des exceptions................................................................................77
terminate........................................................................................................................77
unexpected....................................................................................................................77
set_teminate..................................................................................................................77
set_unexpected..............................................................................................................77
Exceptions du système d’exploitation...............................................................................78
Les exceptions standard................................................................................................78
Propriétés et identificateur........................................................................................................79
Propriétés associer à un identificateur..................................................................................79
Attributs............................................................................................................................79
Exemple............................................................................................................................80