Red de conocimiento informático - Consumibles informáticos - Búsqueda de puntuación alta: el código "Diseño e implementación de código de evaluación de expresión" requiere escribir código utilizando el programa VISUAL C

Búsqueda de puntuación alta: el código "Diseño e implementación de código de evaluación de expresión" requiere escribir código utilizando el programa VISUAL C

//Utility.h

#includelt; string.hgt; //operaciones de cadena estándar

#includelt;

#includelt; limits.hgt; //límites numéricos

#includelt;math.hgt; //funciones matemáticas

#includelt;fstream.hgt; //entrada y salida de archivos

#includelt;ctype.hgt; //clasificación de caracteres

#includelt;time.hgt; //función de fecha y hora

>#includelt; conio.hgt; //con entrada y salida

enum Error_code{éxito, error, desbordamiento, desbordamiento};

//enum bool{false, true};

//Lk_stack.H

templatelt; clase Node_entrygt;

struct Node {

// miembros de datos

Entrada de nodo;

Nodelt; *siguiente;

// constructores

Nodo(); elemento, Nodelt; nodo_entrygt; *add_on = NULL);

};

clase Stack_entrygt; public:

// Métodos de pila estándar

Stack();

bool vacío() const

Error_code push(const Stack_entry; amp; elemento);

Error_code pop();

Error_code top(Stack_entry; elemento)

void clear();

// Funciones de seguridad para estructuras vinculadas

~Stack();

Stack(const Stacklt;Stack_entrygt; amp;original);

operador void =(const Stacklt; Stack_entrygt; amp; ori

ginal);

protegido:

Nodelt; *top_node;

}; >

Nodelt;Node_entrygt;::Node()

{

next = NULL;

}

templatelt; Node_entrygt;

Nodelt;

siguiente = add_on;

}

templatelt;clase Stack_entrygt;

Stacklt;Stack_entrygt;: :Pila()

{

top_node=NULL

}

templatelt; clase Stack_entrygt; bool Stacklt; Stack_entrygt; ::empty() const

{

if(top_node==NULL)

devuelve verdadero; else

devuelve falso

}

templatelt;class Stack_entrygt;

Error_code Stacklt;Stack_entrygt;::push(const Stack_entry & item)

/ *

Publicación: el elemento Stack_entry se agrega en la parte superior de

la pila devuelve éxito o devuelve un código

de desbordamiento si la memoria dinámica está agotada.

*/

{

Nodelt; *new_top = new Stack_entrygt; ;

si (new_top == NULL) devuelve desbordamiento;

top_node = new_top;

devuelve éxito;

}

templatelt; class Stack_entrygt;

Error_code Stacklt;Stack_entrygt;::pop()

/*

Publicar: La parte superior de la pila es eliminado Si la pila

está vacía, el método devuelve subdesbordamiento; de lo contrario, devuelve succ.

ess.

*/

{

Nodelt; *old_top = top_node;

if (top_node == NULL) underflow;

top_node = old_top-gt; siguiente;

eliminar old_top;

devolver éxito;

}

templatelt;class Stack_entrygt;

Error_code Stacklt;Stack_entrygt;::top(Stack_entry amp;item) const

{

Resultado del código de error;

if(empty())

devolver desbordamiento insuficiente;

else{

item=top_node-gt;entry;

retorno exitoso

}

}

templatelt; clase Stack_entrygt;

void Stack_entrygt; / clear elememt

/*

Publicación: La pila se borra.

*/

{

while (!empty())

pop();

}

templatelt; clase Stack_entrygt

Stack_entrygt; :~Stack() // Destructor

/*

Publicación: La pila se borra.

*/

{

clear();

}

templatelt;class Stack_entrygt;

Stacklt;Stack_entrygt;::Stack(const Stacklt;Stack_entrygt; amp ; original) // constructor de copia

/*

Publicación: La pila se inicializa como una copia del original de la pila.

*/

{

Nodelt; Stack_entrygt; *new_copy, *original_node = original.top_node;

if (original_node == NULL) top_node = NULL; { // Duplica los nodos vinculados.

top_node = new_copy = new Nodelt;

_node-gt; entrada);

while (original_node-gt; next != NULL) {

original_node = original_node-gt

new_copy- gt; siguiente = nuevo Nodelt; Stack_entrygt; (original_node-gt; entrada);

new_copy = new_copy-gt; p> p>

}

templatelt; class Stack_entrygt;

void Stacklt; Stack_entrygt;:: operador = (const Stacklt; Stack_entrygt; amp; original) // Asignación de sobrecarga

/*

Publicación: La pila se restablece como una copia del original de la pila.

*/

{

Nodelt; Stack_entrygt; *new_top, *new_copy, *original_node = original.top_node;

if (original_node == NULL) new_top = NULL

else { // Duplicar los nodos vinculados

new_copy = new_top = new Nodelt; (original_node-gt; entrada);

while (original_node-gt; next != NULL) {

original_node = original_node-gt;

new_copy-gt; siguiente = nuevo Nodelt; (original_node-gt; entrada); next;

}

}

while (!empty()) // Limpiar entradas antiguas de la pila

pop();

p>

top_node = new_top; // y reemplácelos con nuevas entradas.

}

//Calculator.h

templatelt ; class Data_elementgt;

clase Calculadora{

público:

void Run(); //Ejecutar expresión

privado:

Stacklt;Da

ta_elementgt; OPND; //pila de operandos

Stacklt; OPTR; //pila de operadores

int isp(char op); //número de prioridad en la pila

int icp(char op); //Número de precedencia fuera de la pila

bool Get2Operands(double amp; x, double amp; y //Tomar dos operandos de la pila

); p>

bool DoOperator(char op); //Forma instrucciones de operación y realiza operaciones

void GetChar(char amp; ch); //Obtiene un carácter ch del flujo de entrada y omite espacios y retorno de carro

bool IsOperator(char ch); //Determina si ch es un operador

};

templatelt;

void Calculatorlt;Data_elementgt;::Run()

{

OPND.clear(); OPTR.clear();

char ch, OPTR_top , prior_char, op; double operand;

OPTR.push('=');

prior_char='=' //prior_char representa el carácter anterior ingresado, si es un número, luego deje que su valor sea '0'

GetChar(ch);

OPTR.top(OPTR_top);

if(OPTR.top(OPTR_top); ) ==underflow)

{

coutlt;lt;"¡La expresión es incorrecta!"lt;lt;endl;

return

};

mientras(OPTR_top!='='||ch!='=')

{

if(isdigit(ch) |ch=='.')

{

cin.putback(ch

cingt; > OPND.push(operando);

prior_char='0';

GetChar(ch);

}

más si ( !IsOperator(ch))

{

coutlt;lt;"¡Aparecen caracteres no válidos en la expresión!"lt;lt;endl

while(cingt; ;gt;ch,ch!='=');

return;

}

else

{

if((prior_char=='='||prior_char=='(')amp;amp;(ch==' '||ch=='-

'))OPND.push(0);

if(isp(OPTR_top)lt;icp(ch))

{

OPTR.push(ch

prior_char=ch

GetChar(ch

}

else if(isp(OPTR_top)gt; icp); (ch))

{

OPTR.top(op); OPTR.pop();

if(!DoOperator(op))return;

}

else if(isp(OPTR_top)==icp(ch)amp;amp;ch==')')

{

OPTR.pop();

prior_char=')';

GetChar(ch

}; };

if(OPTR.top(OPTR_top)==underflow)

{

coutlt;lt;"¡La expresión es incorrecta!"lt;lt ; endl;

retorno

};

}

if(OPND.top(operando)==desbordamiento)

{

coutlt;lt;"¡La expresión es incorrecta!"lt;lt;endl;

return

}

else

{

coutlt;lt;operandlt;lt;endl;

return

}

};

templatelt; class Data_elementgt;

int Calculatorlt; Data_elementgt;::isp(char op)

{

int resultado;

switch(op)

{

case '=":

resultado=0;

ruptura;

caso '(':

resultado=1;

ruptura;

caso '^':

resultado=7;

ruptura

caso '*':

caso '/':

caso '':

resultado=5

descanso;

caso ' ':

caso '-': p>

resultado=3;

descanso;

caso ')':

resultado=8; }

resultado de retorno;

};

templatelt; clase Data_elementgt

int Calculat;

orlt;Data_elementgt;::icp(char op)

{

int resultado;

switch(op)

{

case '=":

resultado=0;

break;

case '(':

resultado =8;

ruptura;

caso '^':

resultado=6

ruptura; > caso '*':

caso '/':

caso '':

resultado=4

descanso; /p>

caso ' ':

caso '-':

resultado=2

ruptura

caso; ')':

resultado=1

}

devolver resultado

}; ;clase Data_elementgt;

bool Calculatorlt;Data_elementgt;::Get2Operands(doble amp;x,doble amp;y)

{

if(OPND.empty ())

{

coutlt;lt;"¡La expresión es incorrecta!"lt;lt;endl;

return false;

}

OPND.top(y); OPND.pop();

if(OPND.empty())

{

coutlt;lt;"¡La expresión es incorrecta!"lt;lt;endl;

return false;

}

OPND.top(x ); OPND.pop();

devuelve verdadero;

};

templatelt; clase Data_elementgt

bool Calculatorlt; ;::DoOperator(char op)

Data_element x, y

bool result=Get2Operands(x, y

<); p> if(resultado==true)

{

cambiar(op)

{

caso ' ':

OPND.push(x y);

romper;

caso '-':

OPND.push(x-y);

ruptura;

caso '*':

OPND.push(x*y);

ruptura; '/':

if(y==0)

{

coutlt;lt

;"¡El divisor es cero!"lt;lt;endl;

return false;

}

OPND.push(x/y);

descanso;

caso '':

if((long)y==0)

{

coutlt ;lt; "¡El divisor es cero!"lt;lt;endl;

return false;

}

OPND.push((long)x (largo )y);

descanso

caso '^':

OPND.push(pow(x, y));

}

devuelve verdadero;

}

de lo contrario devuelve falso

}; ; clase Data_elementgt;

void Calculatorlt;Data_elementgt;::GetChar(char amp;ch)

{

cingt;gt;ch;

while(ch==' '||ch=='\n')

cingt;

}; ; clase Data_elementgt;

bool Calculatorlt;Data_elementgt;::IsOperator(char ch)

{

if(ch=='='||ch= =' ('||ch=='^'||ch=='*'||

ch=='/'||ch==''||ch==' '| |ch =='-'||ch==')')

devuelve verdadero;

else

devuelve falso

} ;

//Calculator.cpp

#include "Utility.h"

#include "Lk_stack.h"

#include "Calculator.h"

main()

{

Calculadoralt;

char iscontinue='Y ';

int i;

while(iscontinue=='Y')

{

coutlt;lt;"Ingresar expresión ( Terminando con un signo igual "="):"lt;lt;endl;

s.Run();

coutlt;lt;"¿Continuar (Y/N)? " ;

cingt;gt;iscontinue;

iscontinue=toupper(iscontinue);

}

}