Rendre opérateur << virtuel?

J’ai besoin d’utiliser un opérateur virtuel Cependant, quand j’essaye d’écrire:

virtual friend ostream & operator<<(ostream& os,const Advertising& add); 

Je reçois l’erreur du compilateur

Erreur 1 Erreur C2575: ‘opérateur <<': seules les fonctions membres et les bases peuvent être virtuelles

Comment puis-je transformer cet opérateur virtuel?

Le problème avec cette configuration est que l’opérateur << que vous avez défini ci-dessus est une fonction libre, qui ne peut pas être virtuelle (elle n'a pas d'objet récepteur). Pour que la fonction soit virtuelle, elle doit être définie en tant que membre d'une classe, ce qui pose problème car si vous définissez operator << en tant que membre d'une classe, les opérandes seront dans le mauvais ordre:

 class MyClass { public: virtual ostream& operator<< (ostream& out) const; }; 

signifie que

 MyClass myObject; cout << myObject; 

ne comstack pas, mais

 MyClass myObject; myObject << cout; 

sera légal

Pour résoudre ce problème, vous pouvez appliquer le théorème fondamental du génie logiciel - tout problème peut être résolu en ajoutant une autre couche d'indirection. Plutôt que de rendre opérateur << virtual, envisagez d'ajouter une nouvelle fonction virtuelle à la classe qui ressemble à ceci:

 class MyClass { public: virtual void print(ostream& where) const; }; 

Ensuite, définissez operator << comme

 ostream& operator<< (ostream& out, const MyClass& mc) { mc.print(out); return out; } 

De cette façon, la fonction opérateur << libre a le bon ordre de paramètre, mais le comportement de l'opérateur << peut être personnalisé dans des sous-classes.

J'espère que cela t'aides!

Vous définissez votre opérateur << pour appeler une méthode d'impression virtuelle:

 class Base { protected: virtual void print(std::ostream& str) const = 0; public: friend std::ostream& operator<<(std::ostream& str, Base const& data) { data.print(str); return str; } } 

Il semble que vous souhaitiez réellement fournir une fonctionnalité de sortie pour une hiérarchie de classes et, si tel est le cas, vous pouvez fournir un friend operator << qui appelle une fonction virtual .

 class Parent { public: friend std::ostream& operator<< (std::ostream& os, const Parent& p); // ... other class stuff protected: virtual void printMyself(std::ostream& os) const { // do something if you must, or make this a pure virtual } }; std::ostream& operator<< (std::ostream& os, const Parent& p) { p.printMyself(os); return os; } class Child : public Parent { // other class stuff... protected: virtual void printMyself(std::ostream os) const { // whatever you need to do } }; 

Aussi détaillé dans la FAQ C ++