Sobrecarga del operador + en C++

Ok, estoy trabajando en un libro y tratando de aprender la sobrecarga del operador C++. Creé una clase BigInt que toma una sola int (inicialmente establecida en 0) para el constructor. Sobrecargué el + = método y funciona muy bien en el siguiente código:Sobrecarga del operador + en C++

BigInt x = BigInt(2); 
x += x; 
x.print(cout);

El código es la salida 4. Así, entonces yo estaba trabajando en la sobrecarga del operador global + usando el siguiente código:

BigInt operator+(const BigInt lhs, const BigInt rhs) 
{ 
    BigInt returnValue(lhs); 
    returnValue += rhs; 
    return returnValue; 
}

Esto también funciona muy bien para el siguiente código:

BigInt x = BigInt(1); 
BigInt y = BigInt(5); 
BigInt z = x + y; 
z.print();

Esto muestra 6. sin embargo, cuando trato de ejecutar el código siguiente, simplemente no funciona. El libro no explica muy bien e implica que simplemente debería funcionar.

BigInt x = BigInt(1); 
BigInt z = x + 5; 
z.print();

Esto muestra 1. No estoy seguro de por qué z es 1 cuando debería ser 6. Busqué en Google en línea y en stackoverflow, pero no pude encontrar a nadie más que estaba teniendo un problema exactamente como esta. algunos estaban cerca, pero las respuestas no encajaban. ¡Cualquier ayuda es muy apreciada!

Fuente

2010-02-28 Anonymous

No creo que esto esté relacionado con su problema, pero por razones de eficiencia (y también porque es idiomático en C++) los argumentos para 'operator +' deben tomarse por referencia constante, no por valor, p. 'Operador BigInt + (const BigInt & lhs, const BigInt & rhs)' –

Una cosa que me pregunto: ¿Por qué se escribe '= BigInt (1)' en lugar de simplemente '= 1'? Creo que si nos mostró su definición completa de clase, podemos ayudarlo mejor :) –

Estoy de acuerdo con Tyler. También más idiomático para inicializar como 'BigInt x (1);' La forma en que lo hace crea un temporal y luego llama al copiador (aunque probablemente se optimizaría). – Dan

problema más probable es en += operador. Código postal para ello

Fuente

2010-02-28 23:42:04 Anycorn

Bueno, @Johannes Schaub estaba en lo cierto cuando dijo que se estaba convirtiendo por medio de un casting implícito (muchos puntos de quiebre y rastreo de código encontraron eso para mí). El problema estaba realmente en el operador + =. No podría haberlo descifrado sin la ayuda de comentarios anteriores y @aaa. ¡Gracias a ambos! –

Necesita una sobrecarga para agregar un int a BigInt; la constante 5 en su ejemplo es de tipo int, no BigInt. Algo como esto debería funcionar:

BigInt operator+(const BigInt lhs, const int rhs) 
{ 
    BigInt returnValue(rhs); 
    returnValue += lhs; 
    return returnValue; 
}

Es posible que desee una para operator+(const int lhs, const BigInt rhs) también.

Fuente

2010-02-28 23:38:53 kevingessner

Que el código compilado implica que la conversión a 'BigInt' funcionó (a modo de conversión implícita). ¿Por qué debería el código compilar e imprimir '1'? Eso no tiene sentido para mí. –

Sí, a menos que haya un constructor no 'explícito' que tome' int', es decir, que proporcione la conversión de 'int' a' BigInt', necesita tres sobrecargas de 'operator +'. @kevingessner, 'const' before' int' es algo inútil en la lista de parámetros. Por otro lado, el tipo de retorno probablemente sea 'const BigInt' para evitar tonterías como' a + b = c; '. –

He intentado con la solución anterior, y todavía tengo la misma respuesta. –

El código que ha publicado se ve bien y debería funcionar. Los problemas que está viendo se deben casi con certeza al constructor de copias o al operador de asignación de su clase BigInt.

Fuente

2010-02-28 23:57:22

El siguiente código de super simplificado (el mínimo que puedo añadir a incluir todo el código y convertirlo en un programa ejecutable independiente válida):

#include <iostream> 

class BigInt 
{ 
    public: 
    BigInt(int i): _i(i) {} 
    void print() { std::cout << "BigInt(" << _i << ")\n"; } 
    void operator +=(const BigInt rhs) { _i += rhs._i; } 
    private: 
    int _i; 
}; 

BigInt operator+(const BigInt lhs, const BigInt rhs) 
{ 
    BigInt returnValue(lhs); 
    returnValue += rhs; 
    return returnValue; 
} 

int main() { 
    BigInt x = BigInt(1); 
    BigInt y = BigInt(5); 
    BigInt z = x + y; 
    z.print(); 

    BigInt ax = BigInt(1); 
    BigInt az = ax + 5; 
    az.print(); 

    return 0; 
}

emite, tan predecible:

BigInt(6) 
BigInt(6)

Realice las modificaciones mínimas posibles en este código de funcionamiento para reproducir el error que observa; eso, por supuesto, mostrará dónde se encuentra exactamente su error.

Fuente

2010-03-01 00:55:06

Respuesta

Cuestiones relacionadas