diseño de calculadora simple en c++
* Hora: 2007.11.11
* Autor: Yo mismo
* Versión: 1.0
*/
/// Comandos y macros de preprocesamiento
#include "stdio.h"
#include "math.h"
#include "math.h" //incluye una serie de comandos sin(), cos() y cos(). //Incluye una serie de funciones sin(), cos() y otras.
#include "string.h" return 0;
break;
case ' s'：//sin sqrt
case 'c'：//cos cot
case 'p'：//pow
case 't' ：
retorno 5;
descanso;
caso '0':
caso '1':
caso '2 ' :
caso '3':
caso '4':
caso '5':
caso '6':
caso '7':
caso '8':
caso '9':
devuelve 10;
descanso;
caso '.':
Devuelve 11;
descanso;
Valor predeterminado:
Devuelve -1; // Algunos operadores deben procesarse inmediatamente
}
}
// Función para buscar expresiones que no contienen letras combinaciones, por ejemplo, sin cos tan sqrt
Esta es una función que no contiene las letras sin cos tan sqrt. p>
// Esta función devuelve un número de punto flotante, que representa el valor de la expresión aritmética
//p apunta a la primera letra de la expresión
float calcular(char *p)
{
// Declara dos matrices oprt[] y opnd, (usadas para representar dos pilas), una Uno para contener el operador y otro para contener los operandos.
Uno de ellos se usa para almacenar el operando, el otro se usa para almacenar el operando
//Declara dos variables int top1 y top2, top1 es el puntero superior de la pila de operandos, top2 es la pila de el puntero superior de la pila de operandos
char optr[MAX]; //pila del operador
float opnd[MAX] //opnd stack
int top[MAX] ]; / /opnd[MAX]; //opnd pila
int top[MAX]; //operador pila<
int top1=-1; > int top1 =-1; //Puntero superior de la pila del operador
int top2=-1; //Puntero superior de la pila del operador
optr[++top1]='#';
//Las siguientes operaciones se utilizan para analizar expresiones y encontrar valores
Las operaciones que ingresan a la pila están unificadas opnd[++top1] y opnd[++top2]
//Las operaciones de salida de la pila se unifican a otr[top1] y opnd[top2]
for(char *q=p; q { int pre=precedure(*q); //El siguiente es el proceso de resolución de expresiones aritméticas if( pre==10) //Si es un número, primero determine si el número existe al final de la lectura. Si no existe, continúe leyendo y finalmente ingrese a la pila { char a_num[15]; int i=0; float n=0; // Se utiliza para guardar los operandos leídos while( pre==10||pre==11) { a_num[i++]=*q; q++; pre=precedimiento(*q); } n=atof(a_num); for(int i=0;i<15;i++) a_num[i] =0; opnd[++top2]=n; } /* Es hora de lea hasta el final de la expresión. En este momento, simplemente lea los operadores de la pila de operadores en secuencia, luego lea dos números de la pila de operadores, realice operaciones y lea hasta #*
{
while(optr[top1]! = '#')
{
// Recupera dos números de la pila de operandos y realiza la operación. El resultado de la operación se enviará a la pila de operandos. p>
//Lee otro operando de la pila de operandos y repite la operación anterior
char ch=optr[top1--];
float num1,num2.< / p>
num1=opnd[top2--];
num2=opnd[top2--];
opnd[++top2]=calcu_token(num1,ch , num2);
}
q++;
}
else if(pre>=1||pre<=4) / /esto indica que se toma el operador básico
{
if(*q=='(')
{
optr [++top1]=*q;
q++;
}
else if(*q==')')
{
while(optr[top1]! ='(')
{
// Tome dos números de la pila de operandos y realice la operación. El resultado de la operación se envía a la pila de operandos. >
//Leer otro operando de la pila de operandos y repetir la operación anterior
char ch=optr[top1--];
float num1,num2.
num1=opnd[top2--];
num2=opnd[top2--];
opnd[++top2]=calcu_token(num1,ch ,num2 );
}
top1--;
q++;
}
más
{
int pre=precedimiento(*q);
char ch=optr[top1--];
int pre2 =precedimiento(ch);
if(ch=='(')
{
optr[++top1]=ch;
p>optr[++top1]=*q;
}
/* else if(ch=='^')
{
float num1,num2;
num1=opnd [top2--];
num2=opnd[top2--];
opnd[++top2]=calcu_token(num1,ch,num2);
optr[++top1]=*q;
}*/
else // Cuando el operador de la pila Cuando el operador sacado no es '('
{
if(pre>pre2) // si el operador leído tiene un mayor prioridad que la de la pila ir a la pila
{
optr[++top1]=ch;
optr[++top1]=* q;
}
else //si la prioridad es pequeña haz la operación en la pila primero
{
//tomar dos números de la pila de operandos y realiza la operación, el resultado se envía a la pila de operandos, en este punto
//lee otro operador de la pila de operadores y repite la operación anterior
mientras(ch! ='('&& amp;pre<=pre2) //Un paso muy importante, ¡hay un ch al frente! ='('
{
float num1,num2;
num1=opnd[top2--];
num2=opnd [top2--];
opnd[++top2]
=calcu_token(num1,ch,num2);
ch=optr[top1--];
pre2=precedimiento(ch);
}
optr[++top1]=ch;
optr[++top1]=*q;
}
}
q++;
}
}
else if(pre==-1) //Manejo de errores
{
printf("Hubo un error en la expresión de entrada, ¡vuelva a escribirla!\n");
exit(1);
}
}
}
printf("top2=%d\n",top2);
return opnd[top2]; p>
}
// Esta función pasa tres parámetros. El tipo del primer parámetro y el tercer parámetro es punto flotante y el segundo operando es un carácter.
//La función de esta función es encontrar el valor de dos números de punto flotante en función de la operación proporcionada por el segundo operando
//El valor de retorno de la función es el resultado de su operación , que también es un número de punto flotante
float calcu_token(float num1,char optr,float num2)
{
switch(optr)
{
caso '+':
retorno (num1+num2);
descanso;
caso '-' :
Retorno (num2-num1);
descanso;
case '*':
Retorno (num1*num2);
ruptura;
caso '/':
retorno (num2/num1);
ruptura;
case '% ':
return (int)num2%(int)num1;
break;
case '^':
return pow (num2,num1);
break;
}
}
int main(void)
{
Declarar una matriz de caracteres para aceptar el valor de la expresión aritmética de entrada
declaración char[MAX ];
printf("Ingrese una expresión (termine con '#'):\n");
gets(statement);
respuesta flotante ;
p>
respuesta=calcular(sentencia);
printf("El resultado final es:%g\n",respuesta);
devolver 0;
}