¡Buenas!

Cuando quieres sobrecargar un operador de entrada/salida lo haces de forma exterior a una clase, ya que el primer operando (cin/cout/fstream/ifstream/ofstream...) va a ser una clase de entrada/salida y el segundo la clase sobre la que quieras que actúe (mira algo sobre sobrecarga de operadores).

En las condiciones anteriores el primer parámetro en la lista de variables que recibe el operador tiene que ser del tipo ajeno a la clase (en este caso un operador de entrada/salida) y si es binario (como lo son los de tipo entrada/salida) el siguiente parámetro tiene que ser del tipo de la clase sobre la que quieres actuar (declarar el operador como friend o no ya es cosa tuya). De hecho el primer parámetro será una referencia a la la clase de entrada/salida, para asegurarte de que los parametrizadores de flujo actúan sobre el, y una vez que acabes de realizar la entrada/salida de la clase tendrás que devolver la referencia al objeto de de entrada/salida que has recibido en la lista de parámetros para poder encadenar entradas/salidas:

#include <iostream>
 
using namespace std;
 
class UnaClase
{
    public:
        char getVal();
        void setVal(char a);
    private:
        char val;
};
 
char UnaClase::getVal()
{
    return a;
}
 
void UnaClase::setVal(char a)
{
    val = a;
}
 
istream& operator>>(istream &in, UnaClase objeto)
{
    char a;
 
    in >> a; //leemos un caracter desde el flujo de entrada que recibimos
    objeto.setVal(a);
 
    return in; //devolvemos el flujo de entrada que hemos recibido para poder encadenar entradas
}
 
ostream& operator<<(ostream &out, UnaClase objeto)
{
    out << objeto.getVal(); //realizamos la salida sobre el objeto ostream que hemos recibido
    return out; //devolvemos el objeto recibido para poder encadenar salidas
}
 
int main()
{
    UnaClase obj1,obj2;
 
    cin >> obj1 >> obj2;
    //lo anterior implica:
    //cin.>>(obj1) y es lo que hemos sobrecargada como >>(cin,obj1) que devuelve una refecencia a cin
    //utilizamos la referencia que hemos devuelto a cin para ejecutar cin.>>(obj2) = >>(cin,obj2)
 
    cout << obj1 << obj2;
    //el razonamiento es como antes pero sobre cout
 
    return 0;
}
 

¡Saludos!

Cuanta razón tienes, hace mucho que no toco C++ y se me ha olvidado poner la palabra clave operator. El código correcto sería:

Edit: En lugar de volver a escribir todo el código en este post he corregido el anterior. (Tiene más lógica)

¡Saludos!

La cuestión es que cuando quieras sobrecargar un operador tienes que tener clara una (dos) cosa(s):

1. Si el primer operando (el que está más a la izquierda) es de la clase o no.
1.1 Si no es de la clase sobre la que estás trabajando el operador no puede ser un miembro de la clase:

class MiEntero
{
    public:
        //...
    private:
        int x;
};
 
/* si queremos sumar un entero y un elemento de mi clase, como el entero no es un objeto de mi clase, tendré que declarar el operador suma fuera de la clase.
 
 La suma es un operador binario y el elemento más a la izquierda es de clase entero, luego a la hora de sobrecargarlo la lista de parámetros tendrá dos valores, 
un entero y un elemento de la clase y devolveré un elemento de mi clase, que engloba a los enteros y así mantengo las reglas de promoción:*/
//...
 
MiEntero operator+ (int op1, MiEntero &op2) //pasamos una referencia al objeto de la clase para evitar sobrecargar la pila
{
    //me las arreglo para generar un elemento MiEntero que almacene el valor suma y devuelvo este objeto
}
 
/*a la hora de llamar al operador, x+y con x entero e y un objeto de mi clase, se genera una llamada operator+(x,y)*/
 

1.2 Si el objeto más a la izquierda es de la clase tenemos dos opciones:
1.2.1. Declarar el operador fuera de la clase con una lista de dos parámetros, ambos de la clase con la que estamos trabajando (igual que antes).
1.2.2. Declarar el operador como miembro de la clase, con un solo parámetro de la clase. La llamada a operador suma, x + y con los dos operandos objetos de mi clase, generará una llamada x.operator+(y), así que para hacer referencia a x dentro de la definición del operador tendrás que utilizar el puntero this:

class MiEntero
{
    public:
        //...
        MiEntero operator+(MiEntero &op2); //como la lista de parámetros es distinta a la la del operador exterior no incumplo las reglas de sobrecarga de funciones/operadores
    private:
        int x;
};
 
MiEntero MiEntero::operator+(MiEntero &op2)
{
    MiEntero res;
 
    res.x = this->x + op2.x;
 
    return res;
}
 
/* si queremos sumar un entero y un elemento de mi clase, como el entero no es un objeto de mi clase, tendré que declarar el operador suma fuera de la clase.
 
 La suma es un operador binario y el elemento más a la izquierda es de clase entero, luego a la hora de sobrecargarlo la lista de parámetros tendrá dos valores, 
un entero y un elemento de la clase y devolveré un elemento de mi clase, que engloba a los enteros y así mantengo las reglas de promoción:*/
//...
 
MiEntero& operator+ (int op1, MiEntero &op2) //pasamos una referencia al objeto de la clase para evitar sobrecargar la pila
{
    //me las arreglo para generar un elemento MiEntero que almacene el valor suma y devuelvo este objeto
}
 

La segunda opción sería declarar los operadores exteriores a la clase como friend para poder tener un acceso inmediato a sus miembros privados.

¡Saludos!

De hecho, acabo de ponerlo en práctica para ver si lo entendí, y todo bien. Muy buenas tus respuestas