overloading << operatori e classi ereditate

Question

Ho una classe base e quindi diverse classi derivate. Vorrei sovraccaricare l'operatore "< <" per queste classi derivate. Per gli operatori normali, cioè '+', le funzioni virtuali fanno il trucco. Quello che capisco essere la convenzione standard è dichiarare

friend ostream& operator<<(ostream& out, MyClass& A); 

all'interno della mia classe e quindi definire la funzione dopo la classe. A priori penserei che aggiungere una virtual alla definizione di cui sopra lo farebbe funzionare, ma dopo un po 'di riflessione (ed errori dal mio compilatore) mi rendo conto che non ha molto senso.

Ho provato una virata diversa in un caso di test, in cui tutti i membri della classe sono pubblici. Per esempio:

class Foo{ 
//bla 
}; 

ostream& operator<<(ostream& out, Foo& foo){ 
    cout << "Foo" << endl; 
    return foo; 
} 

class Bar : public Foo{ 
//bla 
}; 

ostream& operator<<(ostream& out, Bar& bar){ 
    cout << "Bar" << endl; 
    return bar; 
} 

/////////////////////// 

Bar bar = Bar(); 
cout << bar << endl; // outputs 'Foo', not 'Bar' 

Quindi, in qualche modo, questo è "il polimorfismo gone bad" - l'operatore di classe di base < < che viene chiamato, piuttosto che l'operatore classe derivata. Nell'esempio sopra, come faccio a chiamare l'operatore corretto per la classe derivata? E più in generale, se la mia classe ha membri privati ​​che voglio proteggere, come posso correggere l'overloading dell'operatore durante l'utilizzo della parola chiave friend?

Answer 1

È possibile utilizzare una funzione di supporto virtuale. Ecco un esempio del tutto testato, quindi si scusa per eventuali errori di sintassi:

virtual ostream& Foo::print(ostream& out) const { 
    return out << "Foo"; 
} 

virtual ostream& Bar::print(ostream& out) const { 
    return out << "Bar"; 
} 

// If print is public, this doesn't need to be a friend. 
ostream& operator<<(ostream& out, const Foo& foo) { 
    return foo.print(out); 
} 

Edit: Ripulito per suggerimenti @Omnifarious.

Answer 2

Effettuare operator<< una funzione gratuita che inoltra la chiamata a un metodo .

See it in action.

Answer 3

Generalmente si crea un metodo polimorfico print nella classe base chiamato da una singola funzione di libero amico.

Answer 4

Con le corrette correzioni del codice, il codice funziona correttamente; niente da fare:

ostream& operator<<(ostream& out, Foo& foo) { 
    out << "Foo" << endl; // 'out' and not 'cout' 
    return out; // returns 'out' and not 'foo' 
} 

ostream& operator<<(ostream& out, Bar& bar) { 
    out << "Bar" << endl; // 'out' and not 'cout' 
    return out; // returns 'out' and not 'bar' 
} 

Demo. Per accedere ai membri private, è possibile effettuare questa funzione come friend nello class desiderato.