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) ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
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";
-- 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) ?
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 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
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) ?
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
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 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";
}
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
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
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) ?
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
On Mar 28, 11:24 am, Serge Paccalin wrote:
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
On Mar 28, 11:24 am, Serge Paccalin
<s...@mailclub.no.spam.net.invalid> wrote:
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:james.kanze@gmail.com
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
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
