Héritage et fonction amie

Le
Philip K. Dick
Hello

J'ai 2 classes liées par héritage :

class A {
public:
()
friend std::ostream & operator << (std::ostream & os, A a);
()
};

class B : public A {
public:
()
friend std::ostream & operator << (std::ostream & os, B b);
()
}

et je souhaite que l'operateur << de B utilise celui de A,
j'ai donc écrit :

std::ostream & operator << (std::ostream & os, B b) {
os << A(b) << " bla bla de B";
};

Le problème, c'est qu'avec cette syntaxe, *on appelle le constructeur de A*
(puis le destructeur), ce que je voudrais éviter.
Bien évidemment, "os << b << " provoque une boucle infinie.

Comment forcer le premier "<<" à être celui de A sans utiliser A(b) ?

Merci d'avance,

PKD
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Serge Paccalin
Le #305475
Le 28.03.2007 10:53, Philip K. Dick a ecrit:

J'ai 2 classes liées par héritage :

class A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, A a);
(...)
};

class B : public A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, B b);
(...)
}

et je souhaite que l'operateur << de B utilise celui de A,

std::ostream & operator << (std::ostream & os, B b) {
os << A(b) << " bla bla de B";
};

Le problème, c'est qu'avec cette syntaxe, *on appelle le constructeur de A*
(puis le destructeur), ce que je voudrais éviter.
Bien évidemment, "os << b << ..." provoque une boucle infinie.

Comment forcer le premier "<<" à être celui de A sans utiliser A(b) ?


os << (A)b << " bla bla de B";

--
Serge Paccalin

Serge Paccalin
Le #305474
Le 28.03.2007 10:53, Philip K. Dick a ecrit:

J'ai 2 classes liées par héritage :

class A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, A a);
(...)
};

class B : public A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, B b);
(...)
}

et je souhaite que l'operateur << de B utilise celui de A,

std::ostream & operator << (std::ostream & os, B b) {
os << A(b) << " bla bla de B";
};

Le problème, c'est qu'avec cette syntaxe, *on appelle le constructeur de A*
(puis le destructeur), ce que je voudrais éviter.
Bien évidemment, "os << b << ..." provoque une boucle infinie.

Comment forcer le premier "<<" à être celui de A sans utiliser A(b) ?


os << (A)b << " bla bla de B";

--
Serge Paccalin

Falk Tannhäuser
Le #305473
Philip K. Dick wrote:
class A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, A a);


Ça devrait être
friend std::ostream & operator << (std::ostream & os, A const& a);
sinon l'argument passé pour 'a' sera toujours copie.

(...)
};

class B : public A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, B b);


Pareil ici.

(...)
}

et je souhaite que l'operateur << de B utilise celui de A,

std::ostream & operator << (std::ostream & os, B b) {
os << A(b) << " bla bla de B";
};


std::ostream & operator << (std::ostream & os, B const& b)
{
A const& a = b; // Pas de copie - 'b' est juste lié à une référence
return os << a << " bla bla de B";
}

Falk

Philip K. Dick
Le #305472
Merci à tous pour vos réponses!

Philip K. Dick wrote:
Hello

J'ai 2 classes liées par héritage :

class A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, A a);
(...)
};

class B : public A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, B b);
(...)
}

et je souhaite que l'operateur << de B utilise celui de A,

std::ostream & operator << (std::ostream & os, B b) {
os << A(b) << " bla bla de B";
};

Le problème, c'est qu'avec cette syntaxe, *on appelle le constructeur de A*
(puis le destructeur), ce que je voudrais éviter.
Bien évidemment, "os << b << ..." provoque une boucle infinie.

Comment forcer le premier "<<" à être celui de A sans utiliser A(b) ?

Merci d'avance,

PKD



James Kanze
Le #305471
On Mar 28, 11:24 am, Serge Paccalin
Le 28.03.2007 10:53, Philip K. Dick a ecrit:

J'ai 2 classes liées par héritage :

class A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, A a);
(...)
};

class B : public A {
public:
(...)
friend std::ostream & operator << (std::ostream & os, B b);
(...)
}

et je souhaite que l'operateur << de B utilise celui de A,

std::ostream & operator << (std::ostream & os, B b) {
os << A(b) << " bla bla de B";
};

Le problème, c'est qu'avec cette syntaxe, *on appelle le
constructeur de A* (puis le destructeur), ce que je voudrais
éviter.
Bien évidemment, "os << b << ..." provoque une boucle infinie.

Comment forcer le premier "<<" à être celui de A sans utiliser A(b) ?


os << (A)b << " bla bla de B";


C'est pareil au même. Qu'on écrit « A(b) », « (A)b » ou
« static_cast< A >( b ) », c'est exactement pareil. Ce qu'il lui
faut, c'est une conversion qui en donne un lvalue, à la place
d'un rvalue :

os << static_cast< A const& >( b ) << ...

(Mais comme Falk a déjà indiqué, il a un problème aussi parce
qu'il passe ses paramètres par valeur.)

--
James Kanze (GABI Software) mailto:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


Publicité
Poster une réponse
Anonyme