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
*/
{
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);
}
}