Este artículo presentará cómo escribir una calculadora simple usando C++. Cubriremos operaciones básicas, entrada y salida, manejo de errores y algunas características interesantes. Presentaremos de manera integral el proceso de desarrollo de la calculadora desde los aspectos de las ideas de diseño, la implementación del código, las pruebas y la depuración.
1. Ideas de diseño
Antes de comenzar a escribir código, debemos pensar en cómo está diseñada la calculadora. Necesitamos considerar los siguientes aspectos:
1. Operaciones básicas: suma, resta, multiplicación, división, resto, etc.
2. Entrada y salida: cómo obtener los resultados de la operación de entrada y salida del usuario.
3. Manejo de errores: cómo tratar los caracteres ilegales y las excepciones ingresadas por los usuarios.
4. Funciones avanzadas: cómo implementar funciones avanzadas como corchetes, notación científica, raíz cuadrada y factorial.
Necesitamos diseñar el marco general y los módulos funcionales de la calculadora en función de los aspectos anteriores. Podemos usar un enfoque orientado a objetos para encapsular cada módulo funcional en una clase. Al implementar el código, primero podemos implementar las funciones de operación básicas, luego agregar gradualmente funciones avanzadas y finalmente probar y depurar.
2. Implementación del código
1. Operación básica
Necesitamos definir una clase Calculadora, que incluya operaciones básicas como suma, resta, multiplicación, división y resto. Podemos usar la instrucción switch para implementar la selección de operaciones básicas y usar cin y cout para entrada y salida. el código se muestra a continuación:
```c++
class Calculator { public: void add(doble a, doble b) { cout << a + b << endl; } void sub(doble a, doble b) { cout << a - b << endl; } void mul(doble a, doble b) { cout << a * b << endl; } void div(doble a, doble b) { if (b == 0) { cout << "Error: ¡El divisor no puede ser cero!" << finl; devolver; } cout << a / b << endl; } void mod(doble a, doble b) { if (b == 0) {
cout << "Error: ¡El divisor no puede ser cero!" << finl;
devolver;
}
cout << fmod(a, b) << endl;
}
};
```
2. Entrada y salida
Necesitamos definir una clase de entrada y una clase de salida, que se utilizan para obtener los resultados de la operación de entrada y salida del usuario, respectivamente. Podemos usar cin y cout para implementar funciones de entrada y salida. el código se muestra a continuación:
```c++
entrada de clase { public: double getNumber() { double number; cin >> número; número de retorno; } }; class Output { public: void printResult(doble resultado) { cout << "Resultado: " << resultado << endl; } }; ```
3. Manejo de errores
Necesitamos agregar una función de manejo de errores a la clase Calculadora para manejar los caracteres ilegales y las excepciones ingresadas por el usuario. Por ejemplo, cuando el divisor ingresado por el usuario es 0, debemos generar un mensaje de error y regresar. el código se muestra a continuación:
```c++
void div(doble a, doble b) { if (b == 0) { cout << "Error: ¡El divisor no puede ser cero!" << finl; devolver; } cout << a / b << endl; } ```
4. Funciones avanzadas
Podemos usar estructuras de datos como recursión y pilas para implementar funciones avanzadas como paréntesis, notación científica, raíces cuadradas, factoriales, etc. Por ejemplo, cuando el usuario ingresa una expresión, podemos usar la pila para procesar los paréntesis y usar la recursividad para procesar la expresión dentro de los paréntesis. el código se muestra a continuación:
```c++
void calcular(string str) { stack<char> s; int len = str.size(); for (int i = 0; i < len; i++) { if (str[i] == '(') { s.push(str[i]); } else if (str[i] == ')' ) { if (s.empty()) { cout << "Error: Entrada no válida!" << finl; devolver; } s.pop(); } } if (!s.empty()) { cout << "Error: ¡Entrada no válida!" << finl; devolver; } resultado doble = calcular_ayudante (str, 0, len - 1);
cout << "Resultado: " << resultado << endl;
}
double calcule_helper(string str, int start, int end) { int flag = 0; for (int i = fin; i >= inicio; i--) { if (str[i] == ')') { flag++; } else if (str[i] == '(') { flag--; } if (flag == 0 && (str[i] == '+' || str[i] == '-')) { doble izquierda = calcular_ayudante(cadena, inicio, i - 1); doble derecha = calcular_auxiliar(cadena, i + 1, fin); if (cadena[i] == '+') { volver izquierda + derecha;
volver izquierda - derecha;
}
}
}
bandera = 0;
for (int i = fin; i >= inicio; i--) { if (str[i] == ')') { flag++; } else if (str[i] == '(') { flag--; } if (flag == 0 && (str[i] == '*' || str[i] == '/')) { doble izquierda = calcular_ayudante(cadena, inicio, i - 1); doble derecha = calcular_auxiliar(cadena, i + 1, fin); if (cadena[i] == '*') { volver izquierda * derecha;
cout << "Error: ¡El divisor no puede ser cero!" << finl;
salir(0);
}
volver izquierda/derecha;
}
}
}
bandera = 0;
for (int i = fin; i >= inicio; i--) { if (str[i] == ')') { flag++; } else if (str[i] == '(') { flag--; } if (flag == 0 && str[i] == '%') { double left = calcule_helper(str, start, i - 1 ); doble derecha = calcular_ayudante(str, i + 1, end); if (derecha == 0) {
cout << "Error: ¡El divisor no puede ser cero!" << finl;
salir(0);
}
return fmod(izquierda, derecha);
} }
if
(str[inicio] == '(' && str[end] == ')') { return compute_helper(str, start + 1, end - 1); } if (str[inicio] == '-') { return -calculate_helper(str, start + 1, end); } resultado doble = 0; base doble = 10; índice int = 0; for (int i = inicio; i <= final; i++) { if (str[i] == '.') { index = i + 1; romper; }
else if (isdigit(str[i])) { resultado = resultado * base + (str[i] - '0'); } } doble factor = 0.1; for (int i = índice; i <= end; i++) { if (isdigit(str[i])) { result = result + (str[i] - '0') * factor; factor = factor * 0,1; } } devuelve el resultado; } ```
3. Pruebas y depuración
Después de completar la implementación del código, necesitamos probar y depurar. Podemos escribir algunos casos de prueba para probar varias funciones de la calculadora. Por ejemplo, podemos probar operaciones básicas como suma, resta, multiplicación, división y resto, así como funciones avanzadas como paréntesis, notación científica, raíz cuadrada y factorial. Si la prueba encuentra un problema, debemos depurar para averiguar qué salió mal y solucionarlo.
Cuatro Resumen
A través de la introducción de este artículo, podemos entender cómo usar C++ para escribir una calculadora simple. Necesitamos considerar las ideas de diseño de la calculadora e implementar módulos como operaciones básicas, entrada y salida, manejo de errores y funciones avanzadas. Al implementar código, podemos usar métodos orientados a objetos para encapsular cada módulo en una clase y usar estructuras de datos como recursividad y pilas para lograr funciones avanzadas. Al probar y depurar, necesitamos escribir algunos casos de prueba, probar varias funciones de la calculadora y depurar y solucionar problemas.