No se puede sobrecargar el operador << como miembro función

Question

Estoy tratando de sobrecargar operator<< como una función miembro. Funciona si simplemente hacer esto:

friend ostream& operator<<(ostream& os, const MyClass& myClass); en mi archivo de cabecera y en mi archivo MyClass.cc:

ostream& operator<<(ostream& os, const MyClass& myClass) 
{ 
    return myClass.print(os); 
} 

Sin embargo, si trato de tomar la friend fuera y que sea una función miembro, entonces se queja de que operator<< solo puede tomar un argumento. ¿Por qué?

ostream& MyClass::operator<<(ostream& os, const MyClass& myClass) 
{ 
    return myClass.print(os); 
} 

leí en this question que no puede ser una función miembro, pero no sabe por qué?

Answer 1

Cuando se sobrecarga como una función miembro, a << b se interpreta como a.operator<<(b), por lo que solo toma un parámetro explícito (con this como parámetro oculto).

Dado que esto requiere que la sobrecarga sea parte de la clase utilizada como el operando de la izquierda, no es útil con ostream s normales y tal. Requeriría que su sobrecarga sea parte de la clase ostream, no es parte de su clase. Como no puede modificar ostream, no puede hacer eso. Eso deja solo la sobrecarga global como alternativa.

Hay, sin embargo, un patrón bastante ampliamente utilizada en el que sobrecargar el operador a nivel mundial, pero tienen que llamar a una función miembro:

class whatever { 
    // make this public, or the global overload a friend. 
    std::ostream &write(std::ostream &dest) const { 
     // write self to dest 
    } 
}; 

std::ostream &operator<<(std::ostream &os, whatever const &w) { 
    return w.write(os); 
} 

Esto es particularmente útil cuando/si quieres comportamiento polimórfico. No puedes hacer que el operador sobrecargado sea polimórfico, pero haces que la función miembro llame al virtual, por lo que actúa polimórficamente de todos modos.

Editar: a (espero) aclarar la situación, puede hacerlo de diferentes maneras.El primero y probablemente el más obvio es hacer público nuestro miembro write y hacer que el operador global lo llame. Dado que es pública, no tenemos que hacer nada especial para que el operador lo utilizan:

class myClass { 
public: 
    std::ostream &write(std::ostream &os) const { 
     // write stuff to stream 
     return os; 
    } 
}; 

std::ostream &operator<<(std::ostream &os, myClas const &m) { 
    // since `write` is public, we can call it without any problem. 
    return m.write(os); 
} 

Una segunda alternativa es hacer write privada, y declarar operator<< un amigo para darle acceso:

class myClass { 
    // Note this is private: 
    std::ostream &write(std::ostream &os) const { 
     // write stuff to stream 
     return os; 
    } 

    // since `write` is private, we declare `operator<<` a friend to give it access: 
    friend std::ostream &operator<<(std::ostream &, myClass const &); 
}; 

std::ostream &operator<<(std::ostream &os, myClas const &m) { 
    return m.write(os); 
} 

Hay una tercera posibilidad que es casi igual que el segundo:

class myClass { 
    // Note this is private: 
    std::ostream &write(std::ostream &os) const { 
     // write stuff to stream 
     return os; 
    } 

    // since `write` is private, we declare `operator<<` a friend to give it access. 
    // We also implement it right here inside the class definition though: 
    friend std::ostream &operator<<(std::ostream &os, myClas const &m) { 
     return m.write(os); 
    } 
}; 

Este tercer caso utiliza una regla bastante extraño (y poco conocido) en C + + llamado "inyección de nombre". El compilador sabe que una función friend no puede ser parte de la clase, por lo que en lugar de definir una función miembro, esto "inyecta" el nombre de esa función en el ámbito circundante (el alcance global, en este caso). Aunque operator<< se define dentro de la definición de clase, es no una función miembro en absoluto: es una función global.

Answer 2

Puede sobrecargar operator<< como una función miembro. Pero no puede escribir a un miembro operator<< que lleva un ostream en el lado izquierdo, y su clase en el lado derecho.

Cuando hace que algo sea una función miembro (no estática), hay un primer argumento implícito, el objeto que llama. operator<< es binario, por lo que solo se necesitan 2 argumentos. Si lo hace una función miembro, solo puede asignarle un parámetro, porque ya tiene uno (el objeto que llama). Y dado que ese objeto llamante es siempre el primer argumento, no es posible escribir el operador de salida como un miembro (no estático) (al menos, no en el formulario estándar para esa función en particular), porque para ese caso, el ostream necesita ser el primer argumento.

Answer 3

Piense en ello como esto: cuando se quiere transmitir a ostream, que está llamando la < < operador en el objeto de secuencia. Y no está permitido modificar directamente el método 'privado' de ostream. Entonces debes crear una versión sobrecargada y convertirla en un amigo.

Al crear su propio operador < < método en su clase, que está creando un método < < que operará en su clase, no un objeto ostream. Supongo que puede mantener un ostream internamente en su clase y transmitirlo, pero tendrá dificultades para escribir declaraciones encadenadas como esta: a << b << c.