Calculadora con más de 3 valores

7

Soy nuevo en c ++ y he estado haciendo la buena Calculadora antigua. He pasado de una calculadora de 2 valores a una calculadora de 3 valores y me he preguntado ... ¿Cómo es posible hacer una calculadora de 10 dígitos (simplemente utilizando +, -, *, /) que no siempre se puede codificar? una declaración if que devuelve lo que sucede si los operadores son + y + o + y - etc .. y si tuviera que ir al valor 4, estaría escribiendo 64 ifs, y el valor 5 sería 256 if declaraciones.

¿Hay una manera de cambiar esto de tal manera que no requiera escribir tantas declaraciones if?

Aquí están mis partes importantes del código:

Calculator.cpp:

#include "stdafx.h"
#include <iostream>
#include "headers.h"
using namespace std;

int main()
{
int nInput1 = GetUserInput();
char chOperation = GetMathematicalOperation();
{
    if (chOperation == '=')
    {
        cout << "The answer is: " << nInput1 << endl;
        return 0;
    }
}
int nInput2 = GetUserInput();
char chOperation2 = GetMathematicalOperation();
{
    if (chOperation2 == '=')
    {
        int nResult = CalculateResult(nInput1, chOperation, nInput2);
        cout << "The answer is: " << nResult << endl;
        return 0;
    }
}

int nInput3 = GetUserInput();

int nResult = CalculateResult2(nInput1, chOperation, nInput2, chOperation2, nInput3);

PrintResult(nResult);
}

CalculateResult.cpp:

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;


int CalculateResult(int nX, char chOperation, int nY)
{
if (chOperation == '+')
    return nX + nY;
if (chOperation == '-')
    return nX - nY;
if (chOperation == '*')
    return nX * nY;
if (chOperation == '/')
    return nX / nY;

return 0;
}

GetMathematicalOperation.cpp:

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

char GetMathematicalOperation()
{
cout << "Please enter an operator (+,-,*,/ or =): ";

char chOperation;
cin >> chOperation;
return chOperation;
}

CalculateResult2.cpp:

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;


int CalculateResult2(int nX, char chOperation, int nY, char chOperation2, int nZ)
{
if (chOperation == '+' && chOperation2 == '+')
    return nX + nY + nZ;
if (chOperation == '+' && chOperation2 == '-')
    return nX + nY - nZ;
if (chOperation == '+' && chOperation2 == '*')
    return nX + nY * nZ;
if (chOperation == '+' && chOperation2 == '/')
    return nX + nY / nZ;

if (chOperation == '-' && chOperation2 == '+')
    return nX - nY + nZ;
if (chOperation == '-' && chOperation2 == '-')
    return nX - nY - nZ;
if (chOperation == '-' && chOperation2 == '*')
    return nX - nY * nZ;
if (chOperation == '-' && chOperation2 == '/')
    return nX - nY / nZ;

if (chOperation == '*' && chOperation2 == '+')
    return nX * nY + nZ;
if (chOperation == '*' && chOperation2 == '-')
    return nX * nY - nZ;
if (chOperation == '*' && chOperation2 == '*')
    return nX * nY * nZ;
if (chOperation == '*' && chOperation2 == '/')
    return nX * nY / nZ;

if (chOperation == '/' && chOperation2 == '+')
    return nX / nY + nZ;
if (chOperation == '/' && chOperation2 == '-')
    return nX / nY - nZ;
if (chOperation == '/' && chOperation2 == '*')
    return nX / nY * nZ;
if (chOperation == '/' && chOperation2 == '/')
    return nX / nY / nZ;
return 0;
}
    
pregunta Matt 27.12.2013 - 15:12

2 respuestas

11

La programación tiene que ver con estructuras de datos y algoritmos. En tus Por ejemplo, no hay una estructura de datos aparente: sus funciones son Trabajar con la entrada del usuario en bruto y proporcionar directamente la respuesta, sin introduciendo cualquier estructura intermedia para representar la lógica de el cálculo.

Como consecuencia práctica de la conocida ecuación

programs = data structures + algorithms

la ausencia de estructura de datos adecuada te obliga a representar la lógica del cálculo en la parte algoritmos , es decir, en su codigo Por eso su código parece tan complicado, con eso gran número de if s. Y tu instinto es correcto, siempre que tu el código parece complicado, sonará una campana gritando que hay algo mal y ese algo es típicamente lo que estás usando la estructura de datos incorrecta.

La abstracción que te falta aquí es lo que se llama un algebraico expresión, que puede considerarse como una expresión no evaluada. Asi que Ahora, responderé a tu pregunta sobre cómo escribir tu calculadora, pero Te sugiero que cambies el problema y escribas otra. tipo de calculadora.

Aquí están los pasos para escribir una calculadora que admita arbitrariamente expresiones complicadas:

  1. Implemente árboles de expresiones binarias como una clase abstracta Expression que tiene dos descendientes concretos, uno Leaf para el Números (hojas) y otro Node para las operaciones (nodos).

  2. Siga el llamado Patrón de visitante para escribir un evaluador para tus expresiones Quieres escribir un evaluador tomando un Expression y evaluándolo, el Patrón de visitante es el común forma de saber si el Expression es en realidad un Leaf o un Node .

  3. Escriba un analizador para transformar la entrada del usuario en una expresión. Esta es una tarea tediosa, pero hay herramientas automáticas para te ayudará allí, como Bison .

Si eres un principiante, estos tres pasos son desafiantes porque Te expondré a muchos nuevos conceptos de programación simultáneamente: Estructuras de datos abstractos, entrada / salida y analizadores. Un ejercicio mucho más manejable. es escribir una calculadora de notación de pulido inverso (RPN): con tal calculadora, en lugar de decirle al computadora para calcular 3 + 4 * 5 le dice que calcule 4 5 * 3 + lo que simplifica enormemente la lógica del programa:

  1. En lugar de trabajar con árboles de expresiones binarias y por lo tanto con Clases abstractas y concretas, solo trabajas con un stack de Números: la estructura de datos utilizada es mucho más simple.

  2. Debido a 1., no es necesario utilizar el visitante contorsionado patrón.

  3. Leer entrada y evaluar es mucho más fácil en RPN que en la notación de infijo habitual, porque no hay necesidad prestar atención a las reglas de prioridad.

Una vez que esté satisfecho con su ejemplo, puede buscar el programa bc(1) en una caja de Linux, es una notación completa de pulido inverso calculadora, es posible que desee estudiar sus características o su código (en C) para ¡Encuentra más desafíos!

    
respondido por el user40989 27.12.2013 - 16:04
7

Probablemente lo primero que quieras probar es una calculadora de RPN . Con RPN, usted empuja los números en una pila y luego los saca cuando alguien ingresa a un operador. Es más fácil de implementar que una calculadora de infijo, pero te permite escribir expresiones largas y arbitrarias y evaluarlas a medida que avanzas.

El siguiente paso sería utilizar el algoritmo de desviación de yardas para convertir una expresión de infijo en una expresión RPN. Es demasiado largo para incluir los detalles aquí, pero es un algoritmo conocido.

El siguiente paso sería escribir una expresión completa parser , que es un tema bastante avanzado, pero extremadamente Flexible y útil. Hay muchas herramientas disponibles para ayudarte a hacer esto.

De cualquier manera, es probable que desee investigar un poco sobre pilas, colas y árboles, y tal vez probar un par de programas de prueba usando una pila antes de volver a abordar una calculadora. C ++ tiene una implementación de stack en su biblioteca estándar que sería un buen punto de partida para aprender.

    
respondido por el Karl Bielefeldt 27.12.2013 - 15:37

Lea otras preguntas en las etiquetas