Operaciones aritméticas con fracciones usando Constructor en C++

1. Operaciones aritméticas con fracciones usando Constructor en C++
2. Declarar un constructor e inicializar sus miembros de datos en C++
3. Implementar los métodos de miembros para realizar operaciones en C++

Este artículo discutirá cómo crear fracciones usando constructores, encontrar GCD para reducir múltiplos de fracciones y realizar cálculos sobre ellos.

Operaciones aritméticas con fracciones usando Constructor en C++

El lector debe comprender los requisitos previos del programa. Para crear una fracción usando constructor,

1. el denominador no debe ser cero;
2. si el numerador y el denominador son ambos divisibles entre sí, entonces debe reducirse a su múltiplo más bajo;
3. El programa debe diseñarse de modo que el resultado se almacene y muestre a través de un nuevo miembro de datos, mientras que las variables preexistentes no deben cambiar.

Estas condiciones harán que el programa sea factible y capaz de calcular fracciones correctamente.

Declarar un constructor e inicializar sus miembros de datos en C++

El constructor interactúa con diferentes métodos miembro y se pasa valores entre sí. El primer paso para cualquier programa constructor es cargar los paquetes de importación y declarar constructores predeterminados y constructores parametrizados.

• Paquete de importación.

  #include <iostream>
  

• Se utilizará el método de los miembros reduce() para reducir la fracción a su múltiplo más bajo.

  int reduce(int m, int n);
  

• El namespace std se utiliza para el paquete iostream.

  using namespace std;
  

• El nombre de la clase debe tener el mismo nombre que los métodos miembro.

  class computefraction
  

• El constructor predeterminado private: tiene dos miembros de datos para el numerador y el denominador de la fracción.

  {
   private:
    int topline;
    int bottomline;
  

• El constructor parametrizado public: se declara después de eso. Los miembros de datos del constructor predeterminado se inicializan aquí con dos nuevas variables con el mismo tipo de datos (int tl = 0, int bl = 1).

La clase constructora tiene métodos de cinco miembros. El primero. computefraction(), comparte el mismo nombre que el nombre de la clase y almacena los valores de las fracciones antes y después de la reducción.

La reducción de fracciones debe ocurrir antes de que los valores se pasen a otros métodos miembro. Se declaran métodos de cuatro miembros para cálculos de 4 operadores: suma, resta, multiplicación y división.

Otros dos métodos miembro declarados leen las fracciones y las imprimen.

public:
computefraction(int tl = 0, int bl = 1);
computefraction sum(computefraction b2) const;
computefraction minus(computefraction b2) const;
computefraction mult(computefraction b2) const;
computefraction rem(computefraction b2) const;
void show() const;
void see();

A continuación se muestra la representación de la primera parte del programa.

#include <iostream>

int reduce(int m, int n);
using namespace std;
class computefraction {
 private:
  int topline;
  int bottomline;

 public:
  computefraction(int tl = 0, int bl = 1);
  computefraction sum(computefraction b2) const;
  computefraction minus(computefraction b2) const;
  computefraction mult(computefraction b2) const;
  computefraction rem(computefraction b2) const;
  void show() const;
  void see();
};

Implementar los métodos de miembros para realizar operaciones en C++

Los métodos miembro que realizan operaciones aritméticas con fracciones en C++ se implementan en esta parte del artículo.

Sobrecarga del operador de clase de fracción en C++

En este programa, los operadores están sobrecargados en cada método miembro para ajustar los valores de dos fracciones en un solo objeto. La sobrecarga se realiza cuando se usa un tipo de datos definido por el usuario en lugar de un tipo de datos incorporado, y es necesario cambiar su tipo de retorno.

Esto se logra mediante el operador de resolución de alcance ::. Accede a las variables locales de un constructor de una clase particular.

Los valores de las fracciones se almacenan en el constructor computefraction. El programa pasará estos valores a los otros métodos miembros para realizar operaciones aritméticas con ellos, pero primero, la fracción debe reducirse antes de que pueda pasarse a otros métodos miembros.

La sintaxis computefraction::computefraction(int tl, int bl) se utiliza para acceder a las variables locales del constructor computefraction.

computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl)

De manera similar, en el método de miembros para sumar dos fracciones, el operador sum está sobrecargado para ajustar los valores de dos fracciones.

Sintaxis:

return_method class_name::operator(argument)

Esta sintaxis accede al operador sum desde la clase computefraction, lo sobrecarga con el objeto de copia b2 y devuelve el resultado final al constructor computefraction.

computefraction computefraction::sum(computefraction b2) const

Método miembro para encontrar el MCD de la fracción en C++

La función gcd encuentra el MCD para reducir múltiplos de fracciones. El numerador y el denominador son los dos miembros de datos int m e int n.

La función primero comprueba si el valor es negativo o positivo. Si el numerador o el denominador tiene un valor negativo, se vuelve positivo usando m = (m < 0) ? -m : m;.

La función compara el valor más alto entre las variables m y n para encontrar MCD para reducir múltiplos de fracciones. Si el valor mayor se almacena en la variable n, se intercambia con m.

La función está diseñada para que el valor más alto siempre se almacene en la variable m. La función resta el valor más bajo del valor más alto hasta que m se reduce a cero.

Por último, el valor que queda en la variable n es el MCD y se devuelve.

int gcd(int m, int n) {
  m = (m < 0) ? -m : m;
  n = (n < 0) ? -n : n;

  while (m > 0) {
    if (m < n) {
      int bin = m;
      m = n;
      n = bin;
    }

    m -= n;
  }
  return n;
}

Método miembro para reducir el numerador y el denominador de una fracción en C++

Las fracciones se reducen dividiendo numerador y denominador por su MCD.

Aquí se inicializan dos variables, topline para el numerador y bottomline para el denominador.

Una condición if-else comprueba los valores bottomline de la variable. Si los valores son cero, el programa sale con un mensaje de error.

Se inicializa una variable entera reduce para almacenar el GCD de los dos números devueltos por el método gcd.

Luego, el valor almacenado en reduce se divide de ambos topline y bottomline, y el resultado se almacena de nuevo en las mismas variables.

computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl) {
  if (bl == 0) {
    cout << "You cannot put 0 as a denominator" << endl;
    exit(0);  // program gets terminated
  } else
    bottomline = bl;
  int reduce = gcd(topline, bottomline);
  topline /= reduce;
  bottomline /= reduce;
}

Crear método miembro para sumar dos fracciones en C++

Todos los métodos utilizados para las operaciones de cálculo crean un objeto de copia como un constructor de copias. Eso se hace mediante la sintaxis computefraction computefraction::sum(bounty b2) const.

La palabra clave bounty b2 crea un objeto de copia b2. Hacer un objeto de copia es reutilizar objetos para la segunda fracción sin inicializar variables adicionales.

La ecuación para sumar dos fracciones a/b y c/d es,

La variable int tl almacena el resultado del numerador, mientras que int bl almacena el resultado del denominador. Finalmente, se pasan tl y bl.

computefraction computefraction::sum(bounty b2) const {
  int tl = topline * b2.bottomline + b2.topline * bottomline;
  int bl = bottomline * b2.bottomline;

  return computefraction(tl, bl);
}

Los otros métodos miembro se crean de la misma manera. Para comprobarlo, el lector puede ir al programa final de este artículo.

Cómo implementar la función principal usando Constructor en C++

Una vez que se crean todos los métodos miembro, se debe escribir la función main() para que el programa pueda devolver los valores pasados ​​y mostrarlos.

Este programa debe estar escrito de manera que el usuario final tenga opciones y respuestas en este orden:

• Opción para elegir el operador, es decir, suma, resta, etc.
• Lanzar una excepción si la elección está fuera de orden y el programa se recarga.
• Cuando se da una opción correcta, se le pide al usuario que ingrese el numerador y el denominador de la primera fracción, seguido por la segunda fracción.
• Lanza una excepción de error si se inserta un cero en el denominador y sale.
• Si las entradas son correctas, el programa da el resultado como respuesta final.
• El programa vuelve a cargar al paso 1.

Inicialización de variables locales y objetos constructores para la función principal

Como programa dirigido por el menú, se declara una variable char ch. Se declaran tres objetos: up para pasar y almacenar la primera fracción, down para mantener la segunda fracción, y final para mostrar el resultado de las dos fracciones.

int main() {
  char ch;
  computefraction up;
  computefraction down;
  computefraction final;
}

Implementar condiciones impulsadas por menús utilizando un bucle Do While

El programa utiliza 5 casos controlados por menús y un caso predeterminado en un bucle do-while. Los primeros cuatro casos realizan operaciones de cómputo, mientras que el quinto está reservado para una opción de salida.

El default se definirá para las opciones fuera del alcance. El programa se ejecuta en un bucle hasta que el usuario elige el quinto caso para salir y finalizar el programa.

do {
  switch (ch) {
    case '1':
      cout << "first fraction: ";
      up.see();
      cout << "Second fraction: ";
      down.see();
      final = up.sum(down);
      final.show();
      break;
    ... case '5':
      break;
      default : cerr << "Choice is out of scope" << ch << endl;
      break;
  }
} while (ch != '5');

Código completo para calcular fracciones usando Constructor en C++

// import package
#include <iostream>

// member method to find gcd, with two data members
int gcd(int m, int n);
using namespace std;
class computefraction {
  // Default constructor
 private:
  int topline;
  int bottomline;
  // Parameterized Constructor
 public:
  computefraction(int tl = 0, int bl = 1);
  computefraction sum(computefraction b2) const;
  computefraction minus(computefraction b2) const;
  computefraction mult(computefraction b2) const;
  computefraction rem(computefraction b2) const;
  void show() const;
  void see();
};

// Member methods of class type bounty.
// In constructors, the class and constructor names must be the same.

computefraction::computefraction(int tl, int bl) : topline(tl), bottomline(bl) {
  if (bl == 0) {
    cout << "You cannot put 0 as a denominator" << endl;
    exit(0);  // program gets terminated
  } else
    bottomline = bl;
  // Below codes reduce the fractions using gcd
  int reduce = gcd(topline, bottomline);
  topline /= multiple;
  bottomline /= multiple;
}

// Constructor to add fractions
computefraction computefraction::sum(computefraction b2) const {
  int tl = topline * b2.bottomline + b2.topline * bottomline;
  int bl = bottomline * b2.bottomline;

  return computefraction(tl, bl);
}

// Constructor to subtract fractions
computefraction computefraction::minus(computefraction b2) const {
  int tl = topline * b2.bottomline - b2.topline * bottomline;
  int bl = bottomline * b2.bottomline;

  return computefraction(tl, bl);
}

// Constructor to multiply fractions
computefraction computefraction::mult(computefraction b2) const {
  int tl = topline * b2.topline;
  int bl = bottomline * b2.bottomline;

  return computefraction(tl, bl);
}

// Constructor to divide fractions
computefraction computefraction::rem(computefraction b2) const {
  int tl = topline * b2.bottomline;
  int bl = bottomline * b2.topline;

  return computefraction(tl, bl);
}

// Method to print output
void computefraction::show() const {
  cout << endl << topline << "/" << bottomline << endl;
}

// Method to read input
void computefraction::see() {
  cout << "Type the Numerator ";
  cin >> topline;
  cout << "Type the denominator ";
  cin >> bottomline;
}

// GCD is calculated in this method
int gcd(int m, int n) {
  m = (m < 0) ? -m : m;
  n = (n < 0) ? -n : n;

  while (m > 0) {
    if (m < n) {
      int bin = m;
      m = n;
      n = bin;
    }

    m -= n;
  }
  return n;
}

// Main Function
int main() {
  char ch;
  computefraction up;
  computefraction down;
  computefraction final;

  do {
    cout << " Choice 1\t Sum\n";
    cout << " Choice 2\t Minus\n";
    cout << " Choice 3\t multiply\n";
    cout << " Choice 4\t Divide\n";
    cout << " Choice 5\t Close\n";

    cout << " \nEnter your choice: ";
    cin >> ch;
    cin.ignore();

    switch (ch) {
      case '1':
        cout << "first fraction: ";
        up.see();
        cout << "Second fraction: ";
        down.see();
        final = up.sum(down);
        final.show();
        break;

      case '2':
        cout << "first fraction: ";
        up.see();
        cout << "Second fraction: ";
        down.see();
        final = up.minus(down);
        final.show();
        break;

      case '3':
        cout << "first fraction: ";
        up.see();
        cout << "Second fraction: ";
        down.see();
        final = up.sum(down);
        final.show();
        break;

      case '4':
        cout << "first fraction: ";
        up.see();
        cout << "Second fraction: ";
        down.see();
        final = up.mult(down);
        final.show();
        break;

      case '5':
        break;  // exits program.
      default:
        cerr << "Choice is out of scope" << ch << endl;
        break;
    }
  } while (ch != '5');  // program stops reloading when choice 5 is selected

  return 0;
}

Producción :

 Choice 1        Sum
 Choice 2        Minus
 Choice 3        multiply
 Choice 4        Divide
 Choice 5        Close

Enter your choice: 2
first fraction: Type the Numerator 15
Type the denominator 3
Second fraction: Type the Numerator 14
Type the denominator 7

3/1
 Choice 1        Sum
 Choice 2        Minus
 Choice 3        multiply
 Choice 4        Divide
 Choice 5        Close

Enter your choice: 3
first fraction: Type the Numerator 5
Type the denominator 0
Second fraction: Type the Numerator 6
Type the denominator 8
You cannot put 0 as a denominator

--------------------------------
Process exited after 47.24 seconds with return value 0
Press any key to continue . . .