Ultima modifica:
Salve inforgiani! Oggi vi posto questo codice sorgente, scritto per la risoluzione di semplici espressioni matematiche del tipo (4+1)-(5*(4-1))+(5*10/2)+10
Il codice è meno di un alpha! Consideratelo una condivisione fra amici! @St3ve mi ha messo il picchio in testa in una delle ultime discussioni in sezione ed io ho tirato fuori una mia rustica versione prima che Lui tirasse fuori la sua (la quale utilizza un algoritmo molto differente, molto più semplice e molto più efficace).
Qui il codice sorgente, vi prego di correggermi ove necessario ricordando che questo è stato, e aveva l'obiettivo di essere, solamente un buon esercizio!
Saluti!
Il codice è meno di un alpha! Consideratelo una condivisione fra amici! @St3ve mi ha messo il picchio in testa in una delle ultime discussioni in sezione ed io ho tirato fuori una mia rustica versione prima che Lui tirasse fuori la sua (la quale utilizza un algoritmo molto differente, molto più semplice e molto più efficace).
Qui il codice sorgente, vi prego di correggermi ove necessario ricordando che questo è stato, e aveva l'obiettivo di essere, solamente un buon esercizio!
Saluti!
PHP:
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
using namespace std;
float resolve_cast(string);
float conv_str(string);
string Rcast_clean(string);
bool check_cast(string);
template <class T>
string to_string(const T& t)
{
stringstream ss;
ss << t;
return ss.str();
}
string res_cicle(string);
void banner();
int main()
{
string esp;
banner();
cout<<"inserisci espressione aritmetica\n(inserisci 'help' per le istruzioni): "; cin>>esp;
if(esp=="help")
{
cout<<"\nDevi inserire l'espressione esplicitando le parentesi\nanche quando non necessarie.\n"
<<"anzi che scrivere 3+1*4 devi scrivere (3+1)*4 ;\ncioè includendo nelle parentesi operazioni di pari\n"
<<"priorità.\nNon inserire ((4*1-5)/3) ma inserisci ((4*1)-5)/3\n"
<<"Le operazioni supportate sono +, -, *, /\r\n";
return 0;
}
cout<<res_cicle(esp)<<endl;
while(1)
{
if(check_cast(esp)==false)
{
cout<<"risultato: "<<resolve_cast(esp)<<endl;
return 0;
}
else
{
esp=res_cicle(esp);
cout<<res_cicle(esp)<<endl;
}
}
return 0;
}
float resolve_cast(string esp)
{
string tmp=esp;
vector<char> op;
vector<float> vals;
float ris;
int plus=0;
for(int i=0; i<esp.size(); i++)
{
if(esp[i]=='+' || esp[i]=='-' || esp[i]=='*' || esp[i]=='/')
op.push_back(esp[i]);
}
if(op[0]=='+' || op[0]=='-')
{
op.resize(0);
for(int i=0; i<tmp.size(); i++)
{
if(tmp[i]=='+' || tmp[i]=='-')
{
vals.push_back(conv_str(tmp.substr(0, i)));
tmp=tmp.substr(i+1, (tmp.size()-1));
i=0;
}
}
vals.push_back(conv_str(tmp));
for(int i=0; i<esp.size(); i++)
{
if(esp[i]=='+' || esp[i]=='-')
op.push_back(esp[i]);
}
if(op[0]=='+')
ris=vals[0]+vals[1];
else if(op[0]=='-')
ris=vals[0]-vals[1];
if(vals.size()==2)
return ris;
for(int i=1; i<op.size(); i++)
{
if(op[i]=='+')
ris=ris+vals[i+1];
else if(op[i]=='-')
ris=ris-vals[i+1];
}
return ris;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
else if(op[0]=='*' || op[0]=='/')
{
op.resize(0);
for(int i=0; i<tmp.size(); i++)
{
if(tmp[i]=='*' || tmp[i]=='/')
{
vals.push_back(conv_str(tmp.substr(0, i)));
tmp=tmp.substr(i+1, (tmp.size()-1));
i=0;
}
}
vals.push_back(conv_str(tmp));
for(int i=0; i<esp.size(); i++)
{
if(esp[i]=='*' || esp[i]=='/')
op.push_back(esp[i]);
}
if(op[0]=='*')
ris=vals[0]*vals[1];
else if(op[0]=='/')
ris=vals[0]/vals[1];
if(vals.size()==2)
return ris;
for(int i=1; i<op.size(); i++)
{
if(op[i]=='*')
ris=ris*vals[i+1];
else if(op[i]=='/')
ris=ris/vals[i+1];
}
return ris;
}
}
float conv_str(string s)
{
float num = 0;
for(size_t it = 0; it < s.length(); it++)
{
num *= 10;
num += s[it] - '0';
}
return num;
}
string Rcast_clean(string s)
{
string cls;
for(int i=0; i<s.length(); i++)
{
if(s[i]==')' || s[i]=='(')
{
cls=s.substr(0, i);
return cls;
}
}
cls=s;
return cls;
}
bool check_cast(string str)
{
bool casts=false;
for(int i=0; i<str.length(); i++)
{
if(str[i]==')' || str[i]=='(')
return true;
}
return false;
}
string res_cicle(string esp)
{
float res, sol;
string tmp;
vector<char> cast;
vector<int> Pcast;
if(check_cast(esp)==false) //controllo parentesi
{
res=resolve_cast(esp);
esp=to_string(res);
return esp;
}
else
{
for(int i=0; i<esp.length(); i++)
{
if(esp[i]==')' || esp[i]=='(')
{
cast.push_back(esp[i]);
Pcast.push_back(i);
}
}
}
for(int i=0; i<cast.size(); i++)
{
if(cast[i]=='(' && cast[i+1]==')')
{
tmp=esp.substr(Pcast[i]+1, Pcast[i+1]); //estraggo il contenuto della parentesi più esterna
tmp=Rcast_clean(tmp); //eventuali correzioni di parentesi finali residue;
res=resolve_cast(tmp); //risolvo l'interno della parentesi
int len=tmp.length(); //salvo la lunghezza dell'espressione appena risolta
tmp=to_string(res); //converto il float in str
esp=esp.replace(Pcast[i], len+2, tmp); //sostituisco alla parentesi una parentesi contenente il risultato
return esp;
}
}
}
void banner()
{
cout<<"###################################\n"
<<"# Simur Birkoff #\n"
<<"# #\n"
<<"# #\n"
<<"# www.inforge.net #\n"
<<"###################################\r\n\n";
}![:\](/forum/data/assets/smilies/mhhae.gif "Mhhae :\")
(forse mi sto sbagliando)
Non metto in dubbio che i caratteri numerici vanno convertiti in numero (intero, float, o qualsiasi altro tipo ti serve), ma quella funzione ignora ogni altro tipo di carattere, cioè lo salta proprio. Cioè alla fine i segni vanno a farsi benedire.