Cómo escribir una calculadora científica en lenguaje C
Puedes hacerlo usando la pila. . . Esto es muy detallado. Si lz ingresa una expresión a voluntad, se generarán todos los procesos de cálculo en el medio. Si lz prueba dos, sabrá lo que está pasando.
#include lt;stdio.hgt;
#include lt;stdlib.hgt;
#include lt;string.hgt;
#define MAXSIZE 4000;
typedef struct
{
char data[10];
int top // Dirección del encabezado
int base; //Dirección base
int length; //Longitud
}Pila;
void init(Pila *st)//Pila de inicialización
{
st-gt; base=0;
st-gt;
st-gt; 0;
}
int está vacío(Pila *st)
{
int n=0, arriba, base; p>
top =st-gt;top;
base =st-gt;base;
if(top==base)
{
retorno 1;
}
retorno n;
}
int está lleno (Pila * st)
{
int n=0, arriba, base;
arriba =st-gt;
if( topgt; =4000)
{
devolver 1;
}
devolver n; /p >
char getTop(Stack *st)// Devuelve el valor superior sin cambiar la estructura de la pila
{
char n;
if (isEmpty (st))
{
printf("La pila está vacía\n");
return
}
int positon= st-gt; top-1;
n= st-gt; datos[positon] //Obtener datos
return n;
}
char pop(Stack *st)//Abre la pila y regresa
{
char n;
if(isEmpty(st))
{
printf("La pila está vacía\n");
return
}
int positon= st-gt; top-1;
n= st-gt; datos[positon]; >
st-gt;arriba--;
st-gt;longitud--;
st-gt;data[positon]='\0';// Eliminar datos<
/p>
return n;
}
void push(char n, Stack *st)//Empujar a la pila
{
int positon;
if(isFull(st))
{
printf("Pila llena\n");
}
else
{
positon= st-gt;top;//Obtener la posición
st- gt;data [positon]=n; //Guardar datos
st-gt; //Cambiar posición
}
}
void show(Stack *m1)//Salida de los datos en la pila
{
int top, base;
top=m1-gt ;arriba;
base=m1-gt;base;
mientras(topgt;base)
{
printf("c ,", m1-gt;datos[--top]);
}
printf("\n");
}
int isOperate(char temp)//¿Es un operador?
{
if(temp==' '||temp=='-'||temp== '*' ||temp=='/'||temp=='('||temp==')'||temp=='#')
{
return 1 ;
}
return 0;
}
int isValue(char temp)//Si es numérico valor
{
if(tempgt;='0'amp;amp;templt;='9')//
{
devuelve 1;
}
más
{
devuelve 0; >
}
int isAvail(char temp)//¿Es válido el carácter?
{
if(isOperate(temp)||isValue( temp))//Si temp es ambos Si no es un operador o un valor, es ilegal
{
return
}
return 0;
p>
}
int detect(char temp)//Posición de la matriz de búsqueda
{
int i=0;
char oper[7]={' ', '-', '*', '/', '(', ')', '#'}
for(i=0; ilt ;7; i )
{
if(temp==oper[i])
{
> return i;
}
}
}
prioridad de char(temp de char, optr de char)//prioridad de juez< / p>
{
/**//*
- * / ( ) #
1 2 3 4 5 6 7
1 lt; lt; lt; gt;
- 2 lt; lt; gt; gt; lt; lt; gt;
) lt; ; lt; lt; lt; = 0 gt;
# 7 lt; lt; lt; , col;
char prioridad[7][7]={/**//* - * / ( ) # */
{'lt;', 'lt; ', 'lt;', 'lt;', 'gt;', 'gt;', 'gt;'},
{'lt;','lt;','lt;' ,'lt;','gt;','gt;','gt;'},
{' gt;','gt;','lt;','lt;', 'gt;','gt;','gt;'},
{'gt;','gt; ;','lt;','lt;','gt;', 'gt;','gt;'},
{'gt;','gt;','gt; ', 'gt;', 'gt;', '=', 'gt ;'},
{'lt;', 'lt;', 'lt;', 'lt;', '=', '0', 'gt;'},
{'lt;', 'lt;', 'lt;', 'lt;', 'gt;', 'lt; '='},
row = detect(temp); //Encontrar el subíndice de matriz correspondiente;
col = detect (optr);
// printf("d, d" , fila, col);
//La prioridad se almacena en una matriz de 7x7, la relación correspondiente se muestra en la figura anterior
retorno prioridad[fila][col]; ;
}
char evaluar(int a, int b, char oper)<
/p>
{
cambiar(oper)
{
caso ' ': devuelve a b '0';
caso '-': devuelve a-b '0';
caso '*': devuelve a*b '0'
caso '/': devuelve a/b '0'; ;
predeterminado: devolver 0 '0';
}
}
int calcularExpress(char *express)//Calcular expresión Fórmula
{
int resultado=0;
int a, b;
// char oper, resultado
Apilar OPTR, OPND; //Operador de almacenamiento OPTR, valor del operando OPND
init(amp; OPTR);
init(amp; OPND);
push('#', amp; OPTR); //Primer bit predeterminado '#'
////////////////// //- Algoritmo-/////////////////////////////
while(*express!='\0' )
{
char temp;
temp= *(express);
printf("------- -- ------------------------\n");
printf("El símbolo actual es c\n", temp) ;
if(isAvail(temp))//¿Es un carácter válido?
{
if(isOperate(temp))//La entrada es Operador
{
char oper, result;
char optr = getTop(amp; OPTR); //Operador para el bit superior de la pila
p>printf("Bit del operador en la parte superior de la pila: c\n", optr);
char prior = Priority(temp, optr //Juzgar prioridad
{
case 'gt;':
push(temp, amp; OPTR);
printf ("Empuje el bit de signo c en la pila\n", temp);
express;
break;
case 'lt;':
//int a, b;
//char oper, result;
a=pop(amp; OPND)-'0'; //Todos los caracteres almacenados en la pila son caracteres char
b=pop(amp; OPND)-' 0 ';
oper=pop(amp; OPTR);
result=evaluate(b, a, oper); //Saque un operador de la pila y calcule el resultado
//printf("d", result-'0');
push(result, amp; OPND); //El resultado se coloca en OPND
printf("dcd El resultado es: d\n", b, oper, a, result-'0');
break
case '=':
/ /Eliminar corchetes
pop(amp; OPTR);
printf("Eliminar corchetes\n");
express;
break;
}
}
if(isValue(temp))//La entrada es un valor numérico
{
push(temp, amp; OPND); //Empuja el bit de valor en la pila
express
printf(" Inserte el valor c en la pila\n", temp );
//show(amp; OPND);
}
}
>
else //Hay caracteres ilegales en la expresión
{
printf("Hay caracteres ilegales en la expresión\n");
salir (-1); //Salir del programa
}
}
// show(amp; OPND);
// show(amp; OPTR);
return getTop(amp; OPND)-'0';
}
void inputExpress(char *express )// Ingrese la expresión
{
int length=0;
printf("Ingrese una expresión: ");
scanf ("s", express);
int len =strlen(express);
express[len]='#'; el valor predeterminado es '# ';
express[len 1]='\0';
}
salida nula (char *express, int resultado)/ /expresión de salida
{
int i=0;
printf("----------------- --------- --------------------\nExpresión: ");
while(express[i]!= '#')
{
printf("c", expresar[i]);
i; p>
printf( "=d\n", resultado);
}
int main()
{
char express[100]; //Expresión
int resultado =0;
inputExpress(express); //Ingresa expresión
resultado = calcularExpress(express); ); //Expresión de cálculo;
salida(expresión, resultado); //Expresión de salida
//,,,,,,,,,,,,,prueba prioridad.
/**//*
char m='7';
m=Prioridad(' ', '*');
printf("La prioridad es c", m);
int m=evaluate(5, 6, 'm');
printf("d", m ) ;
*/
devuelve 0;
}