Rechner Fenster offen halten mit getch()?



  • Hey Leute,

    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


  • Mod

    Benutz mal ruhig das keep_window_open(). Da hat sich der Herr Stroustrup so viel Mühe gegeben, den Leuten das getch() auszutreiben, du willst ihn doch nicht enttäuschen 😃 . Setz es vor die returns in der main und vor die (hier anscheinend fehlende) Klammer, die die main-Funktion abschließt.



  • 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?


  • Mod

    Golfi1812 schrieb:

    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?



  • 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...



  • Mir fällt grade ein: Es gibt doch so einen Modus, in dem man eine Konsolenanwendung so ausführen kann,dass sie sich nciht schließt (habe das mal gesehen,weiß aber net mehr genau wie das funzt).....

    Kann mir das jemand weiter helfen?



  • for(;;);
    


  • Wie benutzt man dieses "for"?



  • So wie's da steht.


  • Mod

    @Pi: Verwirr ihn doch nicht mit Absicht.

    @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.



  • Du enttäuschst mich, SeppJ.



  • 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...

    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?



  • 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.



  • Ethon schrieb:

    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?



  • Golfi1812 schrieb:

    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.



  • strg+f5 ist ja einfach nur ausführen ohne debug, habe das schon getestet, bringt nix.

    Wie schaffe ich es nun dass die Konsole offen bleibt?



  • Schreib doch einfach

    system("Pause");
    

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


  • Mod

    314159265358979 schrieb:

    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.



  • Also ich habe ihn als Troll angesehen. Liegt wohl daran, dass ich mich verlesen habe. 😃


Anmelden zum Antworten