Foro de elhacker.net

Hola, muy buenas. En mi rato libre, quise mirar un poco el standard de C++. Una cosa de las que he mirado es los operadores definidos para los streams definidos en este (lo he mirado tanto en cplusplus como en el propio archivo de mi compilador MinGW.

Un ejemplo de lo que encontré en el archivo "ostream" es el siguiente:

__ostream_type& operator<<(long __n);

La duda es: ¿No necesita una clase o estructura en los parámetros del operador para ser correcto?

Bueno. Para intentar no tener que preguntar, he hecho el siguiente ejemplo:

#include <cstdio>
 
struct stream {
    int null;
};
 
stream& operator<< (int val);
 
int main() {
    stream ostream = {0};
 
    ostream << 123 << 5;
 
    return 0;
}
 
 
stream& operator<< (int val) {
    printf("%i", val);
}

Pero en las definiciones del operador he tenido que poner esto, porque si no me daba error:

stream& operator<< (stream& ostream, int val);

Esto no esclarece nada :S Gracias por su ayuda!

¡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!

He entendido por qué se debe retornar el objeto de flujo, pero no entiendo como tu respuesta resuelve mi duda :S Aun así, gracias por tu rápida respuesta :D

Por cierto, a lo mejor es que no entiendo/sé suficiente C++, pero ¿y esta estructura?

istream& >>(istream &in, UnaClase objeto)

Parece la estructura de sobrecarga de un operador, pero no tiene la keyword 'operator'. ¿Significa otra cosa?

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!

Jajaja. Un error lo tiene cualquiera :D Pero no he llegado a entender tu explicación D: No digo que esté mal explicada, solo digo que no sé como resuelve mi duda!

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!

Ahhhh. Creo que ya lo entiendo!!! Muchísimas gracias por tus respuestas :DD

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

De nada hombre, da gusto contar con gente como tu.

¡Saludos!