opérateurs << et >> puissent être utilisés à plusieurs reprises dans une même expression,
il est nécessaire que, par exemple :
p << n1 << n2 << n3 ;
soit équivalent à :
( ( (p << n1) << n2 ) << n3 ) ;
Pour ce faire, les opérateurs << et >> doivent fournir comme résultat la pile reçue en
premier opérande, après qu’elle a subi l’opération voulue (empilage ou dépilage). Il
est préférable que ce résultat soit transmis par référence (on évitera la perte de temps
due au constructeur par recopie).
En ce qui concerne la transmission par valeur d’un objet de type stack_int, nous ne
pouvons pas nous contenter du constructeur par recopie par défaut puisque ce dernier
ne recopierait pas la partie dynamique de l’objet, ce qui poserait les problèmes
habituels. Nous devons donc surdéfinir le constructeur par recopie de façon qu’il
réalise une « copie profonde » de l’objet.
Pour satisfaire à la contrainte imposée par l’énoncé sur l’affectation, nous allons
surdéfinir l’opérateur d’affectation. Comme ce dernier doit se contenter d’afficher un
message d’erreur et d’interrompre l’exécution, il n’est pas nécessaire qu’il renvoie une
quelconque valeur (d’où la déclaration void).
Voici ce que pourrait être la déclaration de notre classe :
#include
#include
using namespace std ;
class stack_int
{ int nmax ; // nombre maximal de la valeurs de la pile
int nelem ; // nombre courant de valeurs de la pile
int * adv ; // pointeur sur les valeurs
public :
stack_int (int = 20) ; // constructeur
~stack_int () ; // destructeur
stack_int (stack_int &) ; // constructeur par recopie
// voir remarque 1 ci-après
void operator = (stack_int &) ; // affectation – voir remarque 2
stack_int & operator << (int) ; // opérateur d'empilage
stack_int & operator >> (int &) ; // opérateur de dépilage
// (attention int &)
int operator ++ () ; // opérateur de test pile pleine
int operator -- () ; // opérateur de test pile vide
} ;
1. Il est nécessaire que l’argument de stack_int soit transmis par référence. On peut
utiliser const ; dans ce cas, on pourra initialiser un objet avec un objet constant ou
une expression d’un type susceptible d’être converti implicitement dans le type
221
il est nécessaire que, par exemple :
p << n1 << n2 << n3 ;
soit équivalent à :
( ( (p << n1) << n2 ) << n3 ) ;
Pour ce faire, les opérateurs << et >> doivent fournir comme résultat la pile reçue en
premier opérande, après qu’elle a subi l’opération voulue (empilage ou dépilage). Il
est préférable que ce résultat soit transmis par référence (on évitera la perte de temps
due au constructeur par recopie).
En ce qui concerne la transmission par valeur d’un objet de type stack_int, nous ne
pouvons pas nous contenter du constructeur par recopie par défaut puisque ce dernier
ne recopierait pas la partie dynamique de l’objet, ce qui poserait les problèmes
habituels. Nous devons donc surdéfinir le constructeur par recopie de façon qu’il
réalise une « copie profonde » de l’objet.
Pour satisfaire à la contrainte imposée par l’énoncé sur l’affectation, nous allons
surdéfinir l’opérateur d’affectation. Comme ce dernier doit se contenter d’afficher un
message d’erreur et d’interrompre l’exécution, il n’est pas nécessaire qu’il renvoie une
quelconque valeur (d’où la déclaration void).
Voici ce que pourrait être la déclaration de notre classe :
#include
#include
using namespace std ;
class stack_int
{ int nmax ; // nombre maximal de la valeurs de la pile
int nelem ; // nombre courant de valeurs de la pile
int * adv ; // pointeur sur les valeurs
public :
stack_int (int = 20) ; // constructeur
~stack_int () ; // destructeur
stack_int (stack_int &) ; // constructeur par recopie
// voir remarque 1 ci-après
void operator = (stack_int &) ; // affectation – voir remarque 2
stack_int & operator << (int) ; // opérateur d'empilage
stack_int & operator >> (int &) ; // opérateur de dépilage
// (attention int &)
int operator ++ () ; // opérateur de test pile pleine
int operator -- () ; // opérateur de test pile vide
} ;
1. Il est nécessaire que l’argument de stack_int soit transmis par référence. On peut
utiliser const ; dans ce cas, on pourra initialiser un objet avec un objet constant ou
une expression d’un type susceptible d’être converti implicitement dans le type
221