• Viernes 29 de Marzo de 2024, 07:02

Autor Tema:  Sobrecarga de operadores con fracciones  (Leído 5335 veces)

saudiaz

  • Miembro activo
  • **
  • Mensajes: 51
  • Nacionalidad: sv
    • Ver Perfil
Sobrecarga de operadores con fracciones
« en: Miércoles 10 de Marzo de 2010, 00:48 »
0
ente programa tiene que sumar decrementar y dividir una serie de fracciones con sobrecarga de operadore y ya lo hice consientemente el declarar dentro de la clase  la funciones de sobrecarga.


#include<stdlib.h>
#include<iostream>
#include<math.h>
using namespace std;
     class Fraccion{
           int numerador;
           int denominador;
        public:
               Fraccion(int a, int b){
               if(b==0) exit(-1);
               else    {
                       numerador=a;
                       denominador=b;
                       }
           
                       }  
                       
Fraccion operator+(Fraccion objeto){
         
         Fraccion temporal;
         temporal.denominador=((this->numerador*objeto.denominador)+(this->denominador*objeto.numerador));        
         temporal.numerador=(this->denominador*objeto.denominador);
         return temporal;
         }
         
Fraccion operator/(Fraccion objeto){
         Fraccion temporal2;
         temporal2.numerador=(this->numerador*objeto.denominador);
         temporal2.denominador=(this->denominador*objeto.numerador);
         return temporal2;
         }
         
Fraccion operator--(int notused){
         numerador--;
         denominador--;
         return *this;
                     
         
         }
                       
                       
                       
                       
                       
                         
               void mostrar()
                   {
                   cout<<numerador<<"/"<<denominador;
                   }
           
           
           
                    };
     
     int main()
     {
     Fraccion fraccion01(5,3),fraccion02(17,5),fraccion03(0,1);
     fraccion03=fraccion01+fraccion02;
     fraccion03.mostrar();
     fraccion01/=fraccion02;
     fraccion01.mostrar();
     fraccion01--;
     fraccion01.mostrar();
     getchar();
     }

herzdark

  • Miembro activo
  • **
  • Mensajes: 38
  • Nacionalidad: ar
    • Ver Perfil
Re: Sobrecarga de operadores con fracciones
« Respuesta #1 en: Domingo 14 de Marzo de 2010, 02:28 »
0
con mi poco c++ en mis espaldas creo que estas delvolviendo algo mal si me equivoco este es pos-decremento, el return debería ser otro objeto no el *this
entonces es -- quedaria asi:
Código: C++
  1. Fraccion operator--(int)
  2. {Fraccion aux(*this);
  3.  numerador--;
  4.  denominador--;
  5.  return aux;
  6. }
  7.  
  8.  
viendo bien creo que te falto hacer el constructor de copia, el = y nada mas.
y para que sea un poco mas prolijo el desarrollo de los metodos hacelo en otra hoja no en el mismo lugar donde declaras la clase

jormar arellano

  • Nuevo Miembro
  • *
  • Mensajes: 10
  • Nacionalidad: ve
    • Ver Perfil
Re: Sobrecarga de operadores con fracciones
« Respuesta #2 en: Domingo 14 de Marzo de 2010, 20:33 »
0
En el problema original:

Dentro de las funciones de sobrecarga de operador (por ejemplo, en Fraccion operator+ ), te declarabas una variable "Fraccion temporal" que te daba un problema:
Cuando escribes el constructor de una clase, ya no dispones de los constructores por defecto que te da el lenguaje (salvo el constructor copia, pero eso es otro rollo). En tu caso, la clase Fraccion sólo tiene UN constructor, y toma dos argumentos. Cuando tratas de hacer algo como:
Código: C++
  1. Fraccion temporal;
  2.  
...el compilador te dice que no sabe como crear el objeto, y es lógico, no se lo has dicho.

Otra cosa, no sobrecargaste el operador /= como para poder usarlo en tu función main de prueba.

Como recomendación, y consiente de que no sé lo que tienes que hacer en detalle, tu clase de Fracciones podría ser mejorada en funcionalidad; por ejemplo, no me gusta la idea de abortar el programa si el denominador de una fracción se vuelve cero... considera conservar su valor y, a la hora de imprimirlo por pantalla, escribe algo asi como "infinity", ó "indeterminado (denominador 0)", revisando siempre este detalle antes de realizar cálculos (porque, ¿Cuánto da una fracción por otra que esta indeterminada? ). Una ultima cosa, calculas mal la suma (no se las otras operaciones, no revisé), pero esto ya lo verás tu.

Aca te dejo el codigo que funciona (modificado el constructor):
Código: C++
  1.  
  2. #include<stdlib.h>
  3. #include<iostream>
  4. #include<math.h>
  5.  
  6. using namespace std;
  7.  
  8. class Fraccion{
  9.     int numerador;
  10.     int denominador;
  11.  
  12.     public:
  13.     /*
  14.      * Cambiamos le constructor para usar inicializacion de miembros
  15.      */
  16.     Fraccion(int a=0, int b=1): numerador(a), denominador(b)
  17.     {
  18.         if (b==0)
  19.         {
  20.             // Si realmente quieres terminar el programa por esto
  21.             cerr << "Error: fraccion con denominador 0)" << endl;
  22.             exit(-1);
  23.         }
  24.     }
  25.  
  26.     Fraccion operator+(Fraccion objeto){
  27.  
  28.         Fraccion temporal;
  29.         temporal.denominador=((this->numerador*objeto.denominador)+(this->denominador*objeto.numerador));
  30.         temporal.numerador=(this->denominador*objeto.denominador);
  31.         return temporal;
  32.     }
  33.  
  34.     Fraccion operator/(Fraccion objeto){
  35.         Fraccion temporal2;
  36.         temporal2.numerador=(this->numerador*objeto.denominador);
  37.         temporal2.denominador=(this->denominador*objeto.numerador);
  38.         return temporal2;
  39.     }
  40.  
  41.     Fraccion operator--(int notused){
  42.         numerador--;
  43.         denominador--;
  44.         return *this;
  45.  
  46.  
  47.     }
  48.  
  49.     /*
  50.      * Ahora imprime con un salto de linea al final del  archivo
  51.      */
  52.     void mostrar()
  53.     {
  54.         cout << numerador << "/" << denominador << endl;
  55.     }
  56. };
  57.  
  58. int main()
  59. {
  60.     char aux;
  61.  
  62.     Fraccion fraccion01(5,3),fraccion02(17,5),fraccion03(0,1);
  63.     fraccion03=fraccion01+fraccion02;
  64.     fraccion03.mostrar();
  65.     fraccion01 = fraccion01/fraccion02;
  66.     fraccion01.mostrar();
  67.     fraccion01--;
  68.     fraccion01.mostrar();
  69.  
  70.     cin >> aux;
  71.     // getchar();
  72. }
  73.  
  74.