ich will ein Rechenprogramm schreiben, bei dem die Rechnung (beliebig lang) als string eingelesen wird. Also so:
cout << "Geben Sie die Rechnung ein: ";
string rechnung;
getline(cin, rechnung);

Meine Idee ist, dann durch .find zuerst "/" zu suchen. Von dieser Position aus soll dann einmal nach vorne und einmal nach hinten das nächste Rechenzeichen gesucht werden (mit.find_first_of und .find_last_of), damit ich dann die beiden Teile des Strings, wo die Operanden stehen, in einen double umwandeln kann und die Rechnung ausführen kann.
Nahc der Rechnung wird der Teil, der gerade ebrechnet wird gelösch und durch das Ergebnis ersetzt.
Das ganze kommt dann noch mit mal und am Ende mit plus und minus (wegen Punkt vor Strich)

Die Ausgabe sollte dann z.B. so aussehen:

Geben Sie die Rechnung ein: 5+6/3-4+2
5+6/3-4+2=
5+2-4+2=
5

Mein Problem bei dem ganzen ist, dass ich immer noch nciht so mit Zeigern usw. umgehen kann, obwohl ich mir schon bestimmt hundertmal was dazu durchgelesen habe. Das Prinzip verstehe ich schon, nur weiß ich nicht, wie ich es z.B. hier anwenden kann.

Mal so nebenbei, ist es überhaupt möglcih so an die Aufgabe dranzugehen?

Bisher habe ich soetwas z.B.

void Berechnung::division() {
int pos, pos1, pos2;
pos = rechnung.find("/"); //Position Rechenzeichen
pos1 = rechnung.find_last_of("/+-", pos); //Startposition des 1. Operanden
pos2 = rechnung.find_first_of("/+-", pos); //Endposition des 2. Operande
}

int pos, pos1 usw. ist ja wahrscheinlich falsch oder, denn es handelt sihc hier ja um einen string?

Wäre net wenn mir jemand etwas helfen könnte

Sowas macht man mit Lexern und Parsern. Lernst du in Compilerbau, wenn du mal studierst.

Auch wenn du grundsätzlich Recht hast, finde ich, dass du etwas übertreibst. Um simple mathematische Ausdrücke auszuwerten reicht ein Parser bereits aus, z.B. ein Recursive Descent Parser.

Oder soll ich die Operanden und Rechenzeichen einzeln abfragen lassen und in eine Liste schieben?

Ja aber es muss doch auch so gehen?

Oder soll ich die Operanden und Rechenzeichen einzeln abfragen lassen und in eine Liste schieben?

Jein. Das könnte schon gehen. Aber das ist alles andere als sauber oder schön. Was machst du mit verschachtelten Klammern? Da dürfte deine Methode ziemlich schnell scheitern. Ich würde es erst gar nicht damit probieren.

Das geht mit den stringstreams ganz gut, z.B. von string in double umwandeln:

#include <sstream>
#include <string>
using namespace std;

int main()
{
double d;
string s = "3345.5";

stringstream sstr;
sstr << s;
sstr >> d;
}

Vermutlich wirst Du strings in ints und umgekehrt umwandeln müssen,

Das geht mit den stringstreams ganz gut, z.B. von string in double umwandeln:

#include <sstream>
#include <string>
using namespace std;

int main()
{
double d;
string s = "3345.5";

stringstream sstr;
sstr << s;
sstr >> d;
}

Wen interessiert das? Was hat es mit der Frage zu tun?

astir schrieb:

...damit ich dann die beiden Teile des Strings, wo die Operanden stehen, in einen double umwandeln kann...

Einen Lexer halte ich auch für übertrieben. Genauso einen AST. Einfach auswerten während man parst, davor eine Grammatik aufstellen. Dürfte nicht besonders schwer sein.

Naja, aber irgendwo muss der Parser ja erkennen, ob er grad eine Zahl oder einen Operator an der Hand hat, und das macht man am einfachsten mit einem Lexer. Finde ich jetzt nicht weiter schwer oder übertrieben. Ein AST wär hier erstmal wahrscheinlich schon übertrieben, geb ich dir Recht.

Es muss ja nach einer der beiden Methoden gehen, denn das wurde uns als Lösungsansatz gegeben....

astir schrieb:

Ja aber es muss doch auch so gehen?

Oder soll ich die Operanden und Rechenzeichen einzeln abfragen lassen und in eine Liste schieben?

Jein. Das könnte schon gehen. Aber das ist alles andere als sauber oder schön. Was machst du mit verschachtelten Klammern? Da dürfte deine Methode ziemlich schnell scheitern. Ich würde es erst gar nicht damit probieren.

Genau aus dem Grund wollte ich den etwas komplexeren Ansatz mit Strings wählen, komm da aber auch nciht weiter...ich bin ehct zu blöd für sowas...

Die Lösung, die Kellerautomat gepostet hat, ist doch recht brauchbar, darauf kannst du aufbauen. Was ich nicht ganz optimal finde, ist die Verwendung von char *, vielleicht kannst du das besser lösen

Ja - alle sind irgendwie ganz verliebt in diese Bereiche, die schon im Memory liegen und vorne zeigt ein Pointer (char*) drauf. Auch der TE hätte die Zeichen gerne in einem string vorliegen, um sich dann mit find und find_first_of an das Zerlegen desselben zu begeben.
Dabei geht es hier doch ganz klar um einen Input.
Was viele nicht wissen: für den Input haben die Götter des C++ den std::istream erfunden. Und dessen Lexer-Qualitäten kann man sich in diesem Fall zu Nutze machen, indem man einfach abfragt ob das nächste Zeichen, was daher kommt, ein Operator, also ein Zeichen aus einem begrenzten Vorrat "+-*/" ist. Da kann man auch noch auf Klammer abfragen, aber viel mehr wird es dann nicht mehr und alles andere sollte eine Zahl sein. Und wenn ein Lesefehler auftritt, dann ist halt die Eingabe fehlerhaft. Da braucht man auch keine Exception, sondern nur den std::istream auf fail abfragen.

Und das ganze sieht dann so aus, wie bei diesem Taschenrechnerprogramm. Das ist dann fast der gleiche Code, den Kellerautomat schon vorgelegt hat, nur mit dem Unterschied, dass man dann 'Zahl' auch zu 'irgendeine Größe' abstrahieren kann, und dann werden auch Dinge wie dies hier möglich.

Gruß
Werner

Sorry Werner, aber meinen Ansatz finde ich da viel schöner.

Der eigene Code ist immer schöner - da bin ich ganz Deiner Meinung
Oder gibt es noch ein Argument für char* statt std::istream?

Gruß
Werner

Sorry Werner, aber meinen Ansatz finde ich da viel schöner.

Doch, den Code von Werner finde ich schon sehr schick. Aber ich denke, das wird für den TE auch etwas schwer zu verdauen sein...

Kellerautomat schrieb:

Sorry Werner, aber meinen Ansatz finde ich da viel schöner.

Doch, den Code von Werner finde ich schon sehr schick. Aber ich denke, das wird für den TE auch etwas schwer zu verdauen sein...

Ja, da hast Du Recht. Das mit Templates kann man natürlich auch weglassen, mir ging es eben eher darum, auf die Verwendung von std::istream statt char* hinzuweisen.

Kellerautomat schrieb:

Der Hauptgrund ist wohl, dass ich ctest nicht verstehe.

Ja - und genau das ist auch einer der Knackpunkte.
Nur - es fragt kein Mensch hier im Forum, wie man das nächste Zeichen aus einem std::istream abfragt, ohne es 'zu lesen'. Aber jeden Monat kommt jemand mit der Frage wie man einen mathematischen Ausdruck aus einem String heraus holt, und mehr als zwei pro Woche fragen wie man aus einem (meist kurz vorher mit getline gelesenen) String Zahlen oder andere Werte heraus bekommt.
Und die Antwortenden gehen meist auch immer drauf ein. Sie geben auch i.A. die passenden Antworten in Richtung Parser, und entsprechend Algorithmen, nur der Hinweis auf den std::istream, der für den Input gebaut wurde, das kommt selten. Wobei der std::istream weder alles kann, noch einfach zu handeln ist.

Bei std::istream ist wohl einiges beim Marketing schief gelaufen.

Gruß
Werner

.. Aber ich denke, das wird für den TE auch etwas schwer zu verdauen sein...

Ok - hier noch mal eine einfacherer Fassung:

#include <iostream>

struct Term // Produkt oder Ausdruck mit Division
{
    Term( int& target ) : target_( &target ) {}
    int* target_;
};
struct Expression // der ganze Ausdruck, hier: Summe oder Differenz
{
    Expression( int& target ) : target_( &target ) {}
    int* target_;
};

std::istream& operator>>( std::istream& in, Term t )
{
    typedef int Wert;
    Wert x1;
    in >> x1;
    for( char op; in >> op; )
    {
        switch( op )
        {
        case '*':
            {
                Wert x2;
                if( in >> x2 )
                    x1 *= x2;
            }
            break;
        case '/':
            {
                Wert x2;
                if( in >> x2 )
                    x1 /= x2;
            }
            break;
        default:
            in.putback( op );
            *t.target_ = x1;
            return in;
        }
    }
    return in;
}

std::istream& operator>>( std::istream& in, Expression e )
{
    typedef int Wert;
    Wert x1;
    in >> Term( x1 );
    for( char op; in >> op; )
    {
        switch( op )
        {
        case '+':
            {
                Wert x2;
                if( in >> Term( x2 ) )
                    x1 += x2;
            }
            break;
        case '-':
            {
                Wert x2;
                if( in >> Term( x2 ) )
                    x1 -= x2;
            }
            break;
        default:
            in.putback( op ); // kein Operator '+' '-', dann Zeichen zurück in den stream
            *e.target_ = x1;
            return in; // fertig
        }
    }
    return in;
}

int main()
{
    using namespace std;
    for( int x; cout << "\nGeben Sie die Rechnung ein (Beenden mit ';'): ", cin >> Expression( x); cin.ignore( 1, '\n' ) )
        cout << "= " << x<< endl;
    return 0;
}

hallo astir,
ist das verständlich?

@Edit: Tippfehler '/n' -> '\n'

danke, aber glaub erklären könnte ich das nicht....wir haben auch soetwas noch gar nicht gemacht.

Ich hab grad ganz andere Probleme. Erst funktioniert alles schön und dann kommt auf einmal beim Debuggen folgendes: "Das aufgerufene Projekt wurde von den Clients getrennt".
Kann mir jemand sagen was da heißt, bzw. was ich evtl. falsch gemacht habe?

Ist egrade echt alles deprimierend