¿Cómo hacer una calculadora sencilla en lenguaje C?
#Include
#Include
#include // malloc(), etc.
#include // INT_MAX, etc.
# include//eof (= z o F6), NULL.
#include // atoi()
#include // eof()
#include // piso(), techo(), abs()
#Include //Exit()
#Include //CIN cout
//Código de estado del resultado de la función
#Define true 1
#Definición falsa 0
#Definición OK 1
#Definición error 0
#Definición no factible-1
// #define OVERFLOW -2 Debido a que el valor de OVERFLOW se ha definido como 3 en math.h, esta línea se elimina.
typedef int status; // El estado es el tipo de función y su valor es el código de estado del resultado de la función, como OK, etc.
typedef int Boolean// Boolean es un tipo booleano cuyo valor es VERDADERO o FALSO.
#Definir STACK_INIT_SIZE 100
#Definir incremento de pila 10
//****************** ************************************************* ***** ********
//Estructura de almacenamiento de pila
Estructura typedef {
//Pila de operador
char * base
char * top
int stacksize
} sqstack 1;
estructura typedef {
//pila de operandos
float * base
float *top;
int tamaño de pila
} SqStack2
//********************************************* ** ******************************
//Las siguientes son las funciones de operación básicas del pila de operadores
status init stack(sqstack 1&S){
//Pila de inicialización
s . * sizeof(char));
Si (!S.base) sale (desbordamiento);
s . tamaño de pila = STACK _ INIT _ TAMAÑO
Regresar OK;
}//Pila de inicialización
Estado destruir pila (sqstack 1 amp; S){
>//Destruir pila s
Gratis (s. top);
Gratis (s. base);
Devolver OK;
}//DestroyStack
char GetTop(SqStack1 S){
//Si la pila no está vacía, devuelve el elemento superior de S y devuelve OK; devolver un error.
if(S.top==S.base) devuelve un error;
return *(s . top-1);
}//Gettop
status push(sqstack 1 amp; s, char e) {
//Inserte el elemento E como el nuevo elemento superior de la pila.
if(s . top-s . base gt;=S.stacksize){
//La pila está llena, espacio de almacenamiento adicional
S. =(char *)realloc(S.base, (s. incremento de pila del tamaño de la pila)* sizeof(char));
Si (!S.base) sale (desbordamiento);
s . top = s . base s . tamaño de la pila;
s . tamaño de la pila = incremento de la pila;
}
* s . ;
Volver OK;
}//Push
Ventana emergente de estado (sqstack 1 amp; s, char ampe) {
/ /Si la pila no está vacía, elimina el elemento superior de S, devuelve su valor con E y devuelve ok; de lo contrario, devuelve un error;
si(S.top==S.base) devuelve un error;
e = *(-s . top);
Devuelve OK;
e = *(-s . top);
Volver OK;
p>
}//Pop-up
//********************************* **************** ****************************
//Las siguientes son las funciones operativas básicas de la pila de operandos
Pila de inicialización de estado (SqStack2 ampS){
//Pila de inicialización
s . ));
Si (!S.base) sale (desbordamiento);
s . top = s
S.stacksize = STACK _. INIT _ TAMAÑO
Regresar OK;
}//Inicializar pila
Pila de destrucción de estado (SqStack2 ampS){
//Destruir pila s
Gratis (s . top);
Gratis (s . base
Devolver OK;
}// DestroyStack
float GetTop(SqStack2 S){
// Si la pila no está vacía, devuelve el elemento superior de S, devuelve OK; de lo contrario, se devuelve un error.
if(S.top==S.base) devuelve un error;
return *(s . top-1);
}//Gettop
State push(SqStack2 amps, float e){
//Inserte el elemento E como el nuevo elemento superior de la pila.
if(s . top-s . base gt;=S.stacksize){
//La pila está llena, espacio de almacenamiento adicional
S. =(float *)realloc(S.base, (s. incremento de pila del tamaño de la pila)* sizeof(float));
Si (!S.base) sale (desbordamiento);
s . top = s . base s . tamaño de la pila;
s . tamaño de la pila = incremento de la pila;
}
* s . ;
Regresar OK;
}//Push
Ventana emergente de estado (SqStack2 amp S&P, Float ampe) {
/ /If la pila no está vacía, elimine el elemento superior de S, devuelva su valor con E y devuelva ok;
si(S.top==S.base) devuelve un error;
e = *(-s . top);
Devuelve OK;
e = *(-s . top);
Volver OK;
p>
}//Pop-up
//********************************* **************** **************************
// Las siguientes son funciones de juicio del operador relacionadas.
char precede(char A, char B){
//La relación de precedencia entre los operadores de comparación A y B, y el rango de A y B está limitado a " ", " -" , "*", "/", "(",")", "="
//Return ' >', 'lt', '='
Cambiar (A){
Caso ' ': cambiar (B){
Caso " ": return ">;"
Caso '-': Devuelve '>'
Caso '*': devuelve 'lt'
Caso '/': devuelve 'lt'
Caso '^': devuelve ' lt;';
case "(": return "lt";
case ')': return ' >;';
case '= ' : return '>;';
Valor predeterminado: printf("¡Error de expresión! \n ");
}
p>Caso '-': cambiar (B){
Caso " ": devolver ">;"
Caso '-': devolver ' >;
Caso '*': devuelve 'lt';
Caso '/': devuelve 'lt';
Caso '^': devuelve 'lt;';
case "(": return "lt";
case ')': return '>';
case ' = ': Return' >;';
Valor predeterminado: printf("¡Error de expresión!\n"); exit(0);
}
Caso ' * ': cambiar (B){
Caso " ": devolver ">;"
Caso '-': devolver ' >;'
p>Caso "*": devolver " >";
Caso "/": retorno ">;";
Caso '^': retorno ' lt; ';
caso "(" : return "lt";
case ')': return ' >;';
case '= ': return '>;';
Predeterminado valor: printf("¡Error de expresión!\n"); exit(0);
}
Caso '/': cambiar (B) {
Caso " ": devolver ">;";
Caso '-': devolver ' >;'
Caso "*": devolver ">"; p> Caso "/": devolver ">";
Caso '^': devolver 'lt;'
p>caso "(": devolver "lt";
case ')': return '>';
case '=': return '>' ;
Valor predeterminado: printf("¡Error de expresión! \n "); salir(0);
}
Keith·'^': cambiar(b){
Caso " ": regresar "> ;";
Caso '-': devolver '>';
Caso "*": devolver ">";
Caso " /": devolver ">;";
Caso '^': retorno">";
caso "(": retorno "lt";
caso ')' : return '>';
case '=': return '>';
Valor predeterminado: printf("¡Error de expresión! \n ") ;Salir(0);
}
Caso '('
: cambiar (B){
Caso " ": devolver "lt";
Caso '-': devolver 'lt'; : devolver 'lt';
caso '/': devolver 'lt';
caso '^': devolver 'lt;'
caso "( ": return "lt";
case ")": return "=";
Case '=': printf("¡Error de expresión!\n "); exit(0 );
Valor predeterminado: printf("¡Error de expresión! \n "); salida (0); B){
Caso " ": devolver ">;"
Caso '-': devolver ' >;'; devolver ">";
Caso "/": devolver ">";
Caso '^': devolver ">"; : printf("¡Error de expresión! \n "); salir
case ')': return '>;';
case '= ': return '> ';
Valor predeterminado: printf("¡Error de expresión!\n"); salida (0);
}
case '= ': switch ( B){
Caso " ": devolver "lt"
Caso '-': devolver 'lt' ;
caso '*': devolver ' lt';
caso '/': devuelve 'lt';
caso '^': devuelve 'lt;';
caso "(": return "lt";
Caso ')': printf("¡Error de expresión!\n"); exit(0) ;
Caso "=": return "=";
Valor predeterminado: printf("¡Error de expresión! \n "); Salir (0);
}
Valor predeterminado: printf("¡Error de expresión! \n "); salir (0);
}
}//antes del estado del conjunto
no funciona (carácter c){
// Determine si C es un operador; de ser así, devuelva VERDADERO; de lo contrario, devuelva FALSO.
Cambio (c){
Caso " ": devuelve VERDADERO
Caso '-': devuelve VERDADERO
caso" *" : devuelve VERDADERO
Caso "/": devuelve VERDADERO
Caso '^': devuelve verdadero;
caso "(": devuelve VERDADERO
p>case ")": devuelve VERDADERO
case "=": devuelve VERDADERO
Valor predeterminado: devuelve FALSO
}
}//No funciona
//********************************* *** *******************************************
Operación flotante (flotante a, char theta, flotante b) {
Cambiar (θ){
caso ' ': devolver a b;
Caso ' -': Devuelve a-b;
caso '* ': devuelve a * b;
Caso "/":
if(b==0){
Printf("¡El denominador no puede ser 0!\n ");
Salir (0);
}
De lo contrario, return a/b;
Keith·'^':
if(a = = 0 amp; ampb lt=0){
printf("El ¡el exponente de 0 debe ser mayor que 0!\n ");
Salir(0);
}
De lo contrario, devolver (punto flotante) pow(a , b);
Valor predeterminado: printf("¡Error de expresión! \n "); salida
}
}//Operación<); /p>
Estado EvaluateExpression(){
//Evaluación de expresión aritmética
char c, x, theta, prec
//c es se lee cada vez que se escribe un carácter, x es el paréntesis adicional después del paréntesis, theta es el operador y prec es el carácter antes de c.
Coma flotante a, b, resultado; // a y B son los números que se operarán desde la pila de operandos cada vez, y el resultado almacena el resultado final.
float cc, flag, ii, MINUS = 1;
//cc almacena el número de coma flotante convertido de la cadena y flag se usa para marcar si se ha introducido el punto decimal. leer.
//iiAlmacene el múltiplo de la parte decimal que debe restarse y use un signo menos para registrar si hay un signo negativo antes de este número.
sqstack 1 OPTR;
SqStack2 OPND
pila de inicio(OPTR); ' = ');
prec = ' =scanf("c ", ampc);
Y (c!='='||GetTop(OPTR)!='= '){
cc = 0; bandera = 0; ii = 10;
if(c = = '-' amp; amp(prec = = ' = ' | | prec = = '('){ MINUS =-1; prec = c; scanf("c ", ampc);}
//Si un "-" está precedido por "=" (el primer símbolo) es "-") o "("), es un signo menos, no un signo negativo.
else if(! no funciona (c)){
mientras (! no funciona (c)){
if(c gt; = 48 amperios ampc lt=57){
if(flag = = 0)cc = cc * 10 c-48; //Antes del punto decimal
else if(flag = = 1) { cc = cc (c-48)/ii; ii * = 10; }//Después del punto decimal
Else {printf("¡Punto decimal incorrecto!\n "); }//Punto decimal incorrecto
}
else if(c== ' . ')flag; //Leer en punto decimal
Else {printf( "¡Error de expresión!\ n "); exit(0);}
prec = c; scanf("c ", ampc);
}
cc * = minus minus = 1;
Push (OPND, cc);
}// Si no es un operador, ingrese a la pila OPND.
Otro
switch(precend(GetTop(OPTR), c)){
Caso 'lt': Push(OPTR, c); ; scanf("c ", ampc); break; //El elemento superior de la pila tiene baja prioridad.
case '=": Pop(OPTR, x); prec = c; scanf("c ", ampc); //Elimina los corchetes y recibe el siguiente carácter
Pop(OPTR, theta);
Pop(OPND, b); Pop(OPND, a);
Push(OPND, Operar(a,); theta, b));
Romper
}
}
resultado = GetTop(OPND); p>printf("f\n ", resultado);
//destruir pila(OPTR);
//destruir pila(OPND);
Return OK;
}//Evaluar expresión
void main(){
printf(" * * * * * * * * * * * * * * * * * * * \ n ");
Printf(" *¡Bienvenido a la calculadora!* \ n ");
printf(" * * * * * * * * * * * * * * * * * * * \ n ");
Printf("Ingrese una expresión que termine con " = ":\n));
Printf ("(Admite suma ( ), resta (-), multiplicación (*), división (/), exponenciación () y resta monocular (-)) entre números reales)\ n "); expresión();
Salir(0);
}