Estoy buscando urgentemente un programa fuente de calculadora. Los requisitos son: completar la entrada de expresiones matemáticas (suma, resta, multiplicación y división de números) y presionar = para mostrar el resultado.
¡Ya sea java o c++ funciona!
//////////////////////////////////// / ///////////////////////////////////////////////// ///// //////////////////////// ////////////////////// //////// ////////
#include
#define N 11 //Longitud de expresión , implementado en forma de matriz de caracteres, hay 19 dígitos válidos
////, debido a que los números no se almacenan en la matriz al mismo tiempo que los operadores, se define de la siguiente manera:
// -11 significa (
// -12 significa)
// -13 significa +
// -14 significa -
// -15 significa *
// -16 significa/
flotar a[N]={3, -13,-11,5 ,-15,4,-13,3,-14,6 ,-12}; //Expresión
int n=10; //La longitud real de la expresión, expresada en forma de variable global
int p=0; //Apunta al paréntesis frontal o al encabezado de la expresión
int at=10;
int m=10 ; //Escanear banderas
///// ///////////////////////////////// ///////////////////// ////////////////////////////// ///////////////////// /// /////////////////////////// //////////////////definición de clase
//definición de clase
p>cálculo de clase
{ public:
void mov(int sign); ////// Después de la operación, o después de eliminar los paréntesis, la expresión permanece
void gover( ); La función escanea "()". Si se escanea "()", se calcula el valor
/No escanea y calcula directamente el valor de la expresión
void jisuan(int &a. ,int &b); //Función de cálculo principal
};//Fin de la definición de clase
//La expresión es: 3 +(5*4+3-6)
//////////////////////////////////// //// ////// /////////////////////////////////////////// /////// //////////////////////////////////////////////// /// //////
//función de movimiento
void calcular:：mov(int símbolo)
{
// Hay algunas situaciones, como (1+5) convirtiéndose en (6)**, nota: ** es el elemento sucesor del elemento original)
para (int j=0;sign+j< =n-2;j++)
a[sign +j]= a[sign+j+2]; //Los elementos avanzan en secuencia
n-=2; /Longitud de la mesa menos 2
at-=2;
}//Fin del movimiento
///////////// /////////////////////////// /////////////////////// //// ////////////////////////////////////////
//////////////////////////////////////////////
//función jisuan
void calcular::jisuan(int &at,int &p)
{
for (int i=at;p!= i; i--) //Ocurren operaciones de multiplicación y división
{
if (a[i]==-15.000000)//Ocurren operaciones de multiplicación
{
a[i-1]=a[i-1]*a[i+1];
mov(i);
} // si sobre
}.//si sobre
if (a[i]==-16.000000) //hay división
{a[ i- 1]=a[i-1]/a[i+1];
mov(i
}// si ha terminado
}/ /for over // Fin de multiplicación y división
for (int j=at;p!=j ; j--) //suma y resta
{
if (a[j]==-13.000000) //Se produce la suma
{
a[j-1]=a[j-1]+a[ j+ 1];
mov(j);
}// si es mayor que
if (a[j]==-14.000000) // división ocurre
{
a[j-1]=a[j-1]-a[ j+1];
mov(j);
}// si excede
}// para exceder el final de la suma y la resta
si (p!=0)
{if (p +2==at) //si ocurre (5), elimina los parentes
{
a[p]=a[p +1];
for (int j=0;p+j<=n-3;j++) //avanzar dos unidades
a[p+j+1]= a[p+j+ 3]; //pagar el valor hacia adelante
n-=2; //longitud de la tabla menos 2
p=0 //Especificar que la aguja regresa a la cabeza y la cola. de la tabla después de quitar los corchetes
at= n; //Quita los corchetes y apunta al final de la tabla
}.
// if (p+2==at) end
}//if (p!=0) end
m=n+1 // Programa 1 para M
}// final de jisuan
///////////////////////////////// / ///////////////////////////////////////////////// ///// ////////////////////////////////////////////// ///////// //////////////////////////////// ///////// //////////// /////////////////////////////////////// //////////////// /////////////////////////////////// //////////////////// //
/ //función de escaneo
void calcular::gover()
{ //m se usa para representar el cambio de subíndice, cada vez que se mueve, el nuevo valor de n se pagará a m, es decir,
for (; m>=0 ; m-- )
{
if (a[ m]==-12.000000 ) //aparición de ")"
{
at=m; //marca el subíndice de ")" con at
}
if (a[m ]==-11.000000) //"(" aparece
{p=m; //Utilice p para conservar el subíndice de "("; //Apariciones continuas de (), calcule el valor de la expresión en ()
jisuan (en, p);
jisuan(en, p)
jisuan(en, p);
jisuan(en, p) p);
}//si finaliza
}/// Fin del escaneo para ( )
//si no hay () entonces llama a jisuan( )
//vuelve los dos punteros al principio y al final de la expresión
jisuan(at,p);
}//overend of cover