ich haba mit Hilfe des Buches: "Einführung in die Programmierung mit C++" von Bjarne Stroustrup einen Taschenrechner fertiggestellt. Er hat zwar noch ein paar Fehler und Probleme ,aber im Grunde funktioniert er.

Doch ich habe ein Problem beim Ausführen:

Das Fesnter blitzt nur kurz auf und schließt sich dann direkt wieder. Bei kleineren Projekten habe ich einfach immer

getch()

oder

keep_window_open()

ans Ende von main gesetzt, aber beim Rechner Funktioniert das nicht. Was muss ich tun,bzw. wo muss ich getch() einstzen, dass die Konsole offen bleibt und ich Eingaben tätigen kann?

Hier der Code:

#include "../../../std_lib_facilities.h"
#include "conio.h" //für das getch()

//------------------------------------------------------------------------------

class Token {
public:
    char kind;       // welche Kategorie von Token
    double value;    // für Zahlen: ein Wert 
    Token(char ch)   // erstelle ein Token aus einem char
        :kind(ch), value(0) { }    
    Token(char ch, double val)     // erstelle ein Token aus einem char und einem double
        :kind(ch), value(val) { }
};

//------------------------------------------------------------------------------

class Token_stream {
public:
   Token_stream();        // erstelle einen Token_stream, der aus cin liest 
   Token get();           // lies ein Token ein (get() ist anderswo definiert)
   void putback(Token t); // lege ein Token zurück 
private:
   bool full;    // befindet sich ein Token im Puffer?
   Token buffer; // hier legen wir ein Token ab, das mit putback() 
                 // zurückgestellt wurde
};

//------------------------------------------------------------------------------

// Der Konstruktor setzt full auf false, um anzuzeigen, dass der Puffer leer ist:
Token_stream::Token_stream()
    :full(false), buffer(0)    // kein Token im Puffer
{
}

//------------------------------------------------------------------------------

// Die Memberfunktion putback() stellt ihr Argument zurück in den Puffer von Token_stream:
void Token_stream::putback(Token t)
{
    if (full) error("putback(): Zurueckstellen nicht moeglich, Puffer voll");
    buffer = t;    // kopiere t in den Puffer
    full = true;   // Puffer ist jetzt voll
}

//------------------------------------------------------------------------------

Token Token_stream::get()
{
    if (full) {    // gibt es bereits ein fertiges Token?
        // Token aus dem Puffer entfernen
        full=false;
        return buffer;
    } 

    char ch;
    cin >> ch;     // beachten Sie, dass >> Whitespace-Zeichen wie 
                   // Leerzeichen, Zeilenumbruch, Tabulatorzeichen, etc. überspringt

    switch (ch) {
    case ';':      // für "Ausgeben"
    case 'q':      // für "Verlassen"
    case '(': case ')': case '+': case '-': case '*': case '/': 
        return Token(ch);        // jedes Zeichen repräsentiert sich selbst 
    case '.':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        {    
            cin.putback(ch);       // lege die Ziffer zurück in den Eingabestream 
            double val;
            cin >> val;            // lies eine Gleitkommazahl 
            return Token('8',val); // '8' repräsentiert "eine Zahl" 
        }
    default:
        error("Ungueltiges Token");
    }
}

//------------------------------------------------------------------------------

Token_stream ts;
double expression();

double primary()
{
    Token t = ts.get();
    switch (t.kind) {
    case '(':    // behandle'(' Ausdruck ')'
        {    
            double d = expression();
            t = ts.get();
            if (t.kind != ')') error("')' erwartet");
            return d;
        }
    case '8':            // wir verwenden '8' zur Repräsentation einer Zahl
        return t.value;  // liefere den Wert der Zahl zurück
    default:
        error("Faktor erwartet");
    }
}

//------------------------------------------------------------------------------

// behandelt *, / und %
double term()
{
    double left = primary();
    Token t = ts.get();        // lies das nächste Token aus dem Token-Stream ein

    while(true) {
        switch (t.kind) {
        case '*':
            left *= primary();
            t = ts.get();
            break;
        case '/':
            {    
                double d = primary();
                if (d == 0) error("Division durch null");
                left /= d; 
                t = ts.get();
                break;
            }
        default: 
            ts.putback(t);     // stelle t wieder zurück in den Token-Stream
            return left;
        }
    }
}

//------------------------------------------------------------------------------

// behandelt + und –
double expression()
{
    double left = term();      // liest einen Token ein und wertet ihn aus
    Token t = ts.get();        // lies das nächste Token aus dem Token-Stream ein

    while(true) {    
        switch(t.kind) {
        case '+':
            left += term();    // werte Term aus und addiere
            t = ts.get();
            break;
        case '-':
            left -= term();    // werte Term aus und subtrahiere 
            t = ts.get();
            break;
        default: 
            ts.putback(t);     // stelle t wieder zurück in den Token-Stream
            return left;       // keine weiteren + oder –; Antwort zurückliefern
        }
    }
}

//------------------------------------------------------------------------------

int main(){
try
{
    Token_stream ts;
    Token t(')');
    ts.putback(t);
    Token u = ts.get();

    if (u.kind != t.kind || u.value != t.value)
        error("Fehler in Token-Stream-Logik");
}
catch (exception& e) {
    cerr << "Fehler: " << e.what() << '\n'; 
    return 1;
}
catch (...) {
    cerr << "Hoppla: unbekannte Ausnahme!\n"; 
    return 2;
}

//------------------------------------------------------------------------------

Danke schonmal im Vorraus

"Please enter a Character to Exit:"

Was läuft da schief?

Das scheint nicht ganz zu funzen, wenn ich keep_window_open(); so einsetzte wie du es gesagt hast und dann debugge, bekomme ich nur:

"Please enter a Character to Exit:"

Was läuft da schief?

Ist das nicht genau das was passieren sollte?

Kann mir das jemand weiter helfen?

@Threadersteller: Normalerweise geht das am besten, indem du das Konsolenprogramm, nun ja, in einer Konsole ausführst. Dann macht das Betriebssystem für dein Programm keine eigene Konsole auf, die mit ihm stirbt. Und viele IDEs bieten vergleichbares an.

Ja schon ,aber der Benutzer soll ja auch die möglichkeit haben den Rechner zu Benutzen. Hier kann er ja nichts machen ausser i-ein charakter eingeben und dann schließt sich die konsole...

Kommt dein Programm überhaupt bei Zeile 57/58 vorbei? Da sollte es nämlich warten.

Edit:
Nein, kommt es nicht. Das eine Token, was du dem Konstruktor übergibst wird anscheinend verarbeitet. Das Programm macht halt keine Ausgabe und wartet auch auf keine Eingabe. (Habe mir jetzt nicht alles im Detail durchgelesen, aber so sollte es sein.)

Also was erwartest du was passieren soll?

Ja schon ,aber der Benutzer soll ja auch die möglichkeit haben den Rechner zu Benutzen. Hier kann er ja nichts machen ausser i-ein charakter eingeben und dann schließt sich die konsole...

Müsst ihr Windowsjungs mal lernen, Konsolenprogramme auch über die Konsole zu öffnen.

Golfi1812 schrieb:

Ja schon ,aber der Benutzer soll ja auch die möglichkeit haben den Rechner zu Benutzen. Hier kann er ja nichts machen ausser i-ein charakter eingeben und dann schließt sich die konsole...

Müsst ihr Windowsjungs mal lernen, Konsolenprogramme auch über die Konsole zu öffnen.

+1

Ich habe mal gesehen, wie das mit einer einfach tastenkombination gemacht wurde.
Anstatt f5 in Visual Studio zu drücken wurde da eine andere Tastenkombination benutzt. Kennt die jemand?

Müsste Strg+F5 sein.

Wie schaffe ich es nun dass die Konsole offen bleibt?

system("Pause");

Das ist zwar verpönt, aber für die Entwicklungszeit imho absolut okay.

Du enttäuschst mich, SeppJ.

Fiese Antworten gebe ich nur bei dummen Fragen. Hier war wirklich mal eine sauber gestellte Frage, das will belohnt werden.