sobrecarga << operadores y clases heredadas

Question

Tengo una clase base y luego varias clases derivadas. Me gustaría sobrecargar el operador "< <" para estas clases derivadas. Para los operadores normales, es decir, '+', las funciones virtuales hacen el truco. Lo que yo entiendo que es la convención estándar es declarar

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

dentro de mi clase y luego definir la función después de la clase. A priori, creo que agregar virtual a la definición anterior lo haría funcionar, pero después de pensar un poco (y los errores de mi compilador) me doy cuenta de que no tiene mucho sentido.

Probé una táctica diferente en un caso de prueba, donde todos los miembros de la clase son públicos. Por ejemplo:

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' 

Así que de alguna manera esto es "polimorfismo ido mal" - el operador clase base < < que se llama en lugar del operador de clase derivada. En el ejemplo anterior, ¿cómo hago que se llame al operador correcto para la clase derivada? Y, en términos más generales, si mi clase tiene miembros privados que deseo proteger, ¿cómo puedo corregir la sobrecarga del operador al usar la palabra clave friend?

Answer 1

Puede usar una función de ayudante virtual. Aquí está un ejemplo, no está comprobado, por lo excusa los errores de sintaxis:

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); 
} 

Editar: limpiado por @Omnifarious sugerencias.

Answer 2

Realice operator<< una función gratuita que reenvía la llamada a un método virtual de la clase Foo.

See it in action.

Answer 3

Por lo general, solo crea un método polimórfico print en la clase base que se llama con una única función de amigo libre.

Answer 4

Con las correcciones de código adecuadas en su lugar, su código funciona bien; nada que hacer:

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. Para acceder a los miembros private, puede hacer que esta función sea friend en el class deseado.