Utilice lenguaje C simple para implementar cuatro operaciones aritméticas entre paréntesis

#include /*El archivo de biblioteca incluye*/

#include /*Usado para operaciones de cadenas*/

#include /*Para función de salida*/

/************************** ** ********************************************

int check(char *c)

Parámetros de entrada:

char *c: cadena de entrada

Parámetros de retorno:

0: Hay caracteres que no cumplen la normativa en la cadena

1: Los caracteres de la cadena cumplen la normativa y no hay caracteres que no cumplen la normativa.

Función:

Comprobar si hay otros caracteres en la cadena excepto 0-9, +,-,*,/,(,),

Si es así, devuelve 0 , indicando un error.

Si no, se devuelve 1 y la cadena de la tabla cumple con las regulaciones.

********************************************* ***** *******************************/

int check(char *c )

{

int k=0;

while(*c!='\0')

{

if ((*c>='0' && *c<='9') || *c=='+' ||

*c=='-' || *c==' *' || *c=='/' ||

*c=='.' )

{

}

else

{

printf("error de entrada, tiene el carácter no la expresión matemática char !\n");

return 0;

}

if(*c=='(')

k++;

si(*c==')')

k--;

c++;

}

if(k!=0)

{

printf("error de entrada, no hay un corchete correcto '()'!\n" );

devuelve 0;

}

devuelve 1;

}

/**** ************************************************* ***** ****************

movimiento vacío(char *f, double *s,int p)

Parámetros de entrada :

char *f: matriz de operadores

double *s: matriz numérica

int p: posición actual de la matriz de operadores.

Parámetros de retorno:

Ninguno

Función:

Elimina el operador actualmente completado y cambia la posición de la matriz numérica Ajustar para el siguiente operación.

Si el valor entrante p es 3

entonces la posición de la matriz del símbolo actual es 3.

f[3]=f[3+1] .. .....f[len-2]=f[len-1] f[len-1]='\0';

s[i]=s[i+1] .. .....s[len-1]=s[len] porque hay un valor numérico más que operador.

********************************************* *** *************************************/

movimiento nulo( char *f, double *s ,int p)

{

int i=0,len=strlen(f);

for(i=p ; i

{ /*Es decir, rellena las posiciones de los signos de multiplicación y división con los siguientes signos de suma y menos*/

f[i]=f[i+1];

s[i]=s[i+1];

}

s[i]=s[i+1];

f[len-1]='\0';

}

/ ******************************************* ********* *************************

doble convnum(char *c)

Parámetros de entrada:

char *c: Carácter compuesto de números y puntos decimales, utilizado para convertir en un valor doble.

Parámetros de retorno:

num: Devuelve el valor convertido.

Función:

Copia la parte antes del punto decimal de la cadena de entrada a la matriz temp[].

Si hay un punto decimal, entonces The valor posterior, es decir, la parte decimal se calcula primero y el valor se almacena en num

Una vez completado el cálculo, se calcula la parte entera y el valor más la parte decimal se almacena en num .

********************************************* *** *************************************/

doble convnum( char *c)

{

doble num=0.0;

doble a=1.0;

int i=0,p= 0,len=0;

char temp[100];

int tempi=0;

int start=0;

int f=1; /* Indicador de signo positivo y negativo, si es 1, es un número positivo, si es -1, este número es un número negativo*/

len=strlen?0 ?8;

if(c[ 0]=='-')

{

inicio=1;

f= -1;

}

for(i=inicio; i

{

si(c[i ]=='.')

{

p=i;

romper;

}

temp[tempi++]=c[i]; /*Convierte el número entero Copiado parcialmente a temp[]*/

}

temp[tempi]='\0';

if(p!=0)

{

for(i=p+1;i

{

if(c[i]=='.') /*Si hay puntos decimales adicionales, significa un error de entrada*/

{

printf("¡hay más de un punto '.' en el número!error!\n");

exit(0);

}

a=a*0.1;

num+=(a*(c[i]-48));

}

}

a=1.0;

len=strlen(temp); /*Calcular la parte entera*/

for(i=len-1; i>=0; i--)

{

num=num+(a*(temp[i]-48));

a*= 10;

}

num =num*f;

devuelve num;

}

/* ********************** ******************************* ********************** *****

doble bien(char *c)

Parámetros de entrada :

char *c: expresión matemática de cadena sobre la que se va a operar.

Por ejemplo, 3.5+(2*3/5)

Parámetros de retorno:

s[0]: el resultado del cálculo se colocará en s[0]

Función:

Llame a la función convnum(char *c) para realizar la conversión numérica de los números en la cadena de entrada y luego guárdelos en doble s[i] en secuencia.

Almacene los operadores de suma, resta, multiplicación y división en la matriz de símbolos de cadena char f[i] en secuencia,

Luego, si se encuentra un corchete, almacene la cadena entre corchetes en otra matriz de caracteres, y luego use esta función recursiva

good(char *c) para realizar operaciones recursivas. Luego, de acuerdo con el orden de multiplicación y división primero, luego suma y resta, los valores almacenados en la matriz se operan de acuerdo con los operadores almacenados en la matriz de símbolos de cadena. El resultado se almacena en s[0].

Devuelve el resultado final.

********************************************* *** *************************************/

doble bien( char *c) /*Sí Función recursiva*/

{ /*Obtener la cadena numérica y llamar a convnum para convertirla a doble*/

char g[100],number[ 30]; /*g, save La cadena de expresión actual, número guarda todos los caracteres de un número*/

char f[80];

int fi=0; /*Guardar el puntero de ubicación del símbolo*/

double s[80] /*Guardar una pila de todos los números actuales*/

int si=0; /*Guardar el número Puntero de posición*/

int k=0; /* Si k=1, significa que hay un par de corchetes*/

int num=0,i=0; /*num guarda el nuevo número de caracteres entre paréntesis, i guarda la posición del carácter en número*/

int cc=0; signos*/

int jj=0; /*suma y resta Número de símbolos*/

while(*c!='\0')/*Cuando p==1 y k==0, significa que todo el contenido entre paréntesis se ha copiado a g[100] Won*/

{

k=0;

num=0;

switch(*c)

{

case '+': /*Cuando el carácter actual es +- multiplicación y división , significa */

case '-':

case ' *':

case'/':

f[ fi++]=*c;

if(*c=='*' || *c =='/')

cc++;

else

jj++;

if(*(c-1)!=' )')

{

número[i]=' \0';

i=0;/* Completa la copia de un número, su puntero de posición i=0*/

s[si++]=convnum(number);

}

break;

case'(' : /*Si hay corchetes, todos los caracteres dentro del alcance de los corchetes actuales se guardarán como */

k++; /*Se calculará una nueva expresión de carácter de forma recursiva llamando a la función buena.

*/

while(k>0)

{

c++;

g[num]=*c;

num++;

if(*c==')')

{

k--;

}

else if(*c=='(')

{

k++;

}

}

g[num-1]='\0';

num=0;/* Completar la copia del contenido de un corchete, su puntero de posición num=0* /

s[si++]=good(g);

descanso;

predeterminado:

número[i++]=*c ;

if(*(c+1)=='\0')

{ número[i]='\0';

s[ si++]= convnum(número);

}

break;

}

c++;

}

f[fi]='\0';

i=0;

while(cc>0)

{

cambiar(f[i])

{

caso '*': cc--;

s[i+1] =s[ i]*s[i+1];

mover(f,s,i);

romper;

caso '/': cc-- ;

s[i+1]=s[i]/(float)s[i+1];

mover(f,s,i);

descanso;

predeterminado:

i++;

descanso;

}

}

i=0;

mientras(jj>0)

{

cambiar(f[i])

{

caso '+': s[i+1]=s[i]+s[i+1];

jj--;

mover(f,s,i);

romper;

caso '-': s[i+1]=s[i]-s[i+ 1];

jj--;

mover(f,s,i);

romper;

predeterminado:

printf("¡error del operador!");

break;

}

}

return s[0 ];

}

void main()

{

char str[100];

doble suma=0 ;

int p=1;

while(1)

{

printf("ingrese expresión: ingrese ' salir' fin del programa\n");

sca

nf("%s",str);

p=strcmp(str,"exit");

if(p==0)

romper ;

p=check(str);

si(p==0)

continuar;

suma=good(str );

printf("%s=%f",str,sum);

printf("\n");

}

printf("¡adiós!\n");

}