int main(int argc, char** argv) { sostituisci(atoi(argv[1]),atoi(argv[2])); }
void main() { bool riesegui = false; do { // Letting the user insert a string cout << "Insert a string down here:\n"; // Catching the string cin.getline(expression, 300); // Rimuovo gli spazi remove_spaces(expression); // Checking expression if (!CheckExpression(expression)) { cout << "\nExpression syntax error..."; getch(); return; } parentesizza(); aggiorna_posizioni(); int max_level = 0; do { // Finding max level max_level = 0; for (int i = 0; i <= max_record_number; i++) { if (par[i].level > max_level) max_level = par[i].level; } //cout << "\nMax reached level: " << max_level; // Itering through the records with the higher level // Questa variabile conterrà il numero di expressioni // trovate in questo livello. int expressionNumber = 0; for (int a = 0; a <= max_record_number; a++) { // Entering here if we are enetering in the max level if (par[a].level == max_level) { // Itering through the number of operators present char tmp_expression[300]; int c = 0; // Copying the string for (int b = (par[a].pos_open + 1); b < par[a].pos_close; b++) { tmp_expression[c++] = expression[b]; } tmp_expression[c] = '\0'; // Showing the string cout << "\nExpression: " << tmp_expression; // Copio la stringa in tmp_expression in splittedExpression for (b = 0; b < DIM_STRINGA_FINALE; b++) { splittedExpression[expressionNumber][b] = tmp_expression[b]; } // Incremento il numero di espressioni estrette dalle parentesi // di livello maggiore nel ciclo corrente expressionNumber++; } } /* A questo punto splittedExpression[][] avrà tutte le espressioni contenute nelle parentesi più interne della prima espressione che devo risolvere. Il numero di espressioni estratte è determinato da (expressionNumber - 1). */ // Risolvo tutte le espressioni // ============================ // Ciclo su tutte le expressioni for (a = 0; a <= expressionNumber; a++) { // Ciclo su tutti gli elementi dell'array // Prima controlla la presenza di radici for (int b = 0; splittedExpression[a][b] != '\0';) { double secondoOperatore, risultato; // Se c'è scritta la r e dopo la r c'è un numero allora svolgo la raltrimenti lascio che prima venga svolto il resto if (splittedExpression[a][b] == 'r' && ((int)splittedExpression[a][b + 1] < 48 || (int)splittedExpression[a][b + 1] > 57) && splittedExpression[a][b + 1] != '+' && splittedExpression[a][b + 1] != '-') { riesegui = true; break; } if (splittedExpression[a][b] == 'r' && (((int)splittedExpression[a][b + 1] >= 48 && (int)splittedExpression[a][b + 1] <= 57) || splittedExpression[a][b + 1] == '+' || splittedExpression[a][b + 1] == '-')) { // Ho trovato una radice //find_first_second_operator(splittedExpression[a], b, //primoOperatore, secondoOperatore); secondoOperatore = find_argument(splittedExpression[a], b); risultato = sqrt(secondoOperatore); if (risultato < 0) { cout << "\nNo number to the power of 2 is negative.\nThe program is not yet able to handle complex number.\n"; return; } substitute_result(splittedExpression[a], b, risultato); //b = 0; cout << '\n' << splittedExpression[a]; continue; } b++; } // Controllo la presenza di funzione trigonometriche nell'espressione for (b = 0; splittedExpression[a][b] != '\0';) { double risultato; switch((char)splittedExpression[a][b]) { // Se c'è scritta una di queste lettere controllo se è una funzione trigonometrica case 's': case 'c': case 't': case 'a': { double argomento = find_argument(splittedExpression[a], b); short int tipo_trigonometrica = istrigonometric(b, splittedExpression[a]); // So che è una trigonometrica, prima sapevo solamente che era una // parola che cominciava per quella lettera. if (tipo_trigonometrica) { switch(tipo_trigonometrica) { case 1: {risultato = sin(argomento); break;} case 2: {risultato = cos(argomento); break;} case 3: {risultato = tan(argomento); break;} case 4: {risultato = asin(argomento); break;} case 5: {risultato = acos(argomento); break;} case 6: {risultato = atan(argomento); break;} case 7: {risultato = 1/tan(argomento); break;} case 8: {risultato = 1/cos(argomento); break;} case 9: {risultato = 1/sin(argomento); break;} } substitute_result(splittedExpression[a], b, risultato); b = 0; //cout << '\n' << splittedExpression[a]; continue; } else { cout << "\nError! Not recognised symbol."; getch(); return; } } } b++; } // e successivamente di potenze for (b = 0; splittedExpression[a][b] != '\0';) { double primoOperatore, secondoOperatore, risultato; if (splittedExpression[a][b] == '^') { // Ho trovato una potenza find_first_second_operator(splittedExpression[a], b, primoOperatore, secondoOperatore); risultato = pow(primoOperatore, secondoOperatore); sostituisci(a, b, risultato); b = 0; cout << '\n' << splittedExpression[a]; break; } b++; } for (b = 0; splittedExpression[a][b] != '\0';) { double primoOperatore, secondoOperatore, risultato; switch((char)splittedExpression[a][b]) { case '*': { find_first_second_operator(splittedExpression[a], b, primoOperatore, secondoOperatore); risultato = primoOperatore * secondoOperatore; sostituisci(a, b, risultato); b = 0; cout << '\n' << splittedExpression[a]; break; } case '/': { find_first_second_operator(splittedExpression[a], b, primoOperatore, secondoOperatore); risultato = primoOperatore / secondoOperatore; sostituisci(a, b, risultato); b = 0; cout << '\n' << splittedExpression[a]; break; } default: b++; } } for (b = 0; splittedExpression[a][b] != '\0';) { /* 1. Trovo la posizione del simbolo 2. Trovo i valori che stanno prima e dopo NOTA: Se non c'è ne sono allora visualizzo un msg d'errore 3. Eseguo l'operazione determinata dal simbolo tra le due variabili contenenti i due valori. 4. Sostituisco il risultato al posto dell'operazione. 5. Continua il ciclo */ double primoOperatore, secondoOperatore, risultato; // Se trovo un simbolo presente tra quelli consentiti switch((char)splittedExpression[a][b]) { // In caso il simbolo sia + ... case '+': { // Trovo valore prima e dopo find_first_second_operator(splittedExpression[a], b /* posizione dell'operatore */, primoOperatore, secondoOperatore /*Passo l'indirizzo della variabile*/); // Eseguo l'operazione risultato = primoOperatore + secondoOperatore; // Sostituisco il risultato al posto dell'operazione sostituisci(a /* indice */, b /* posizione dell'operatore*/, risultato); // Azzero b per ricominciare da capo l'itering della stringa b = 0; // Showing the result cout << '\n' << splittedExpression[a]; // breaking della case break; } case '-': { // Devo controllare che il segno sia inteso come operando if (b == 0) {b++; break;} // Controllo che prima ci sia un numero if (splittedExpression[a][b - 1] < 48 || splittedExpression[a][b - 1] > 57) {b++; break;} find_first_second_operator(splittedExpression[a], b, primoOperatore, secondoOperatore); risultato = primoOperatore - secondoOperatore; sostituisci(a, b, risultato); b = 0; cout << '\n' << splittedExpression[a]; break; } default: b++; } } if (riesegui == true) {a = -1; riesegui = false;} } // Dovrei aver ottenuto un numero di valori senza operatori pari a (expressionNumber - 1) // Visualizzo i risultati di tutte le parentesi (quelle con il lvello più alto /*for (int a = 0; a < expressionNumber; a++) { cout << splittedExpression[expressionNumber]; }*/ // Risolvo tutte le espressioni // Riciclo sull'espressione iniziale (expression[]) // Quando incontro una parentesi di livello massimo // sostituisco il contenuto con il suo risultato. /* NOTA: Se c'è un simbolo prima della parentesi allora lo lascio, altrimenti metto il * */ /* Vado a sostituire i valori risolti delle parentesi più interne all'interno dell'espressione intera e ricomincia il ciclo. max_record_number = numero di parentesi; max_level = livello massimo; splittedExpression[] = espressioni da sostituire; expressionNumber = numero di espressioni da sostituire; expression[] = espressione intera da risolvere;3.30 */ int numero_parentesi = max_record_number; int b = 0; for (a = 0; a <= numero_parentesi; a++) { if (par[a].level == max_level) { double numero = atof(splittedExpression[b++]); sostituisci_parentesi(par[a].pos_open, par[a].pos_close, numero); a = 0; } } } while(max_level > 1); cout << "\n\n"; } while(1); cout << '\n'; return; }