Probleme mit den zurückspringen zwischen verschiedene Schleifen



  • Hallo zusammen,

    ich hab leider per such-Funktion noch keine Antwort auf mein Problem gefunden.

    Ich versuche atm das Buch "C++ Programmierung lernen" von André Willms nachzuvollziehen um mich auf meine C++ Klausur vorzubereiten.

    Im Kapitel Klassen gibt es ein Beispielprogramm, indem Kartoffel und Schwein 2 eigene Klassen mit diversen private und public funktionen ist. So weit, so klar.

    Jetzt möchte ich dieses Programm:

    #include <iostream>
    
    using namespace std;
    
    int grund,aktion,kart,schw;
    class Kartoffel
    {
        private:
        int knollendicke;
        int knollenanzahl;
        int groesse;
        int bluetenzahl;
        void calcgroesse(void);
    
        public:
        void wachsen(void);
        void bluehen(void);
        int pfluecken(void);
        Kartoffel(int, int, int, int);
    };
    
    Kartoffel::Kartoffel(int kd, int ka, int gr, int ba)
    {
        knollendicke=kd;
        knollenanzahl=ka;
        groesse=gr;
        bluetenzahl=ba;
    }
    
    void Kartoffel::calcgroesse(void)
    {
        groesse=knollenanzahl*knollendicke;
    }
    
    void Kartoffel::bluehen(void)
    {
        bluetenzahl++;
    }
    
    void Kartoffel::wachsen(void)
    {
        if(!bluetenzahl)
        {
            cout<<"Keine Blueten vorhanden!!!!\n\n";
            return;
        }
        bluetenzahl--;
        if (knollendicke<20)
            knollendicke++;
        knollenanzahl++;
        calcgroesse();
    }
    
    int Kartoffel::pfluecken(void)
    {
        if(!knollenanzahl) return(0);
    
        knollenanzahl--;
        calcgroesse();
        return(knollendicke);
    }
    
    class Schwein
    {
        private:
        int groesse;
        int gewicht;
        int saettigungsgrad;
    
        public:
        void wachsen(void);
        void bewegen(void);
        void fressen(Kartoffel&);
        Schwein(int, int, int);
    };
    
    Schwein::Schwein(int gr, int ge, int sg)
    {
        groesse=gr;
        gewicht=ge;
        saettigungsgrad=sg;
    }
    
    void Schwein::wachsen(void)
    {
        if (saettigungsgrad>=8)
            {
                saettigungsgrad-=8;
                if(groesse<30)
                    groesse++;
                if(gewicht<40)
                    gewicht++;
            }
        else
            cout<<"Schwein ist nicht fett genug zum wachsen!!!!!!"<<endl<<endl;
    }
    
    void Schwein::bewegen(void)
    {
        if(saettigungsgrad>=4)
            {
                saettigungsgrad-=4;
                return;
            }
        if(gewicht>10)
            {
                gewicht--;
                return;
            }
        cout<<"Schwoin hat koine Energie mehr!!!!!!!!\n\n";
    }
    
    void Schwein::fressen(Kartoffel &k)
    {
        int naehrwert=k.pfluecken();
        if(!naehrwert)
            {
                cout<<"Kartoffel besitzt keine Knollen!!!!!\n\n";
            }
        else
            {
                saettigungsgrad+=naehrwert;
                if(saettigungsgrad>100)
                    {
                        gewicht+=(saettigungsgrad-100)/2;
                        saettigungsgrad=100;
                    }
            }
    }
    
    void grundent(void) //Entscheidung, ob ueberhaupt eine Bearbeitung stattfindet
    {
         if (grund==2)
             {
               cout<<"Ende"<<endl;
             }
    };
    
    void aktionent(void) //Entscheidung, welche Aktion getroffen werden soll
    {
          switch (aktion)
                    {
                        case 1:
                                cout<<"Kartoffel wachsen lassen(1),  bluehen   lassen(2), \n";
                                cout<<"Status abfragen(3) oder zurueck(4)?"<<endl;
                                cin>>kart;
                                //kartent();
                                break;
                        case 2: cout<<"Schwein fressen(1), sich bewegen(2), wachsen(3) lassen, \n";
                                cout<<"Status abfragen(4) oder zurueck(5)?"<<endl;
                                cin>>schw;
                                //schwent();
                                break;
                        case 3: cout<<"Wie nur"<<endl;
                        case 4: cout<<"Zum Programmende"<<endl;
                    }
    }
    int main()
    {
            Schwein Schwein1(50,80,20);
            Kartoffel Kartoffel1(10,20,10,5);
    
            cout<<"Etwas bearbeiten (1) oder Programm beenden(2)?"<<endl;
            cin>>grund;
            grundent();
            cout<<"Kartoffel(1), Schwein (2), zurueck (3), Programm beenden (4)"<<endl;
            cin>>aktion;
            aktionent();
    
    }
    

    etwas mit Leben füllen und zwar mit Abfragen, die als Baum in beide Rictungen funktionieren.

    Z.B. etwas bearbeiten(1)->schwein(2)->wachsen lassen(1)->zurück zum menu schwein->zurueck zum menue etwas bearbeiten->kartoffel(1)-> status anzeigen lassen(3)

    den baum runter (etwas bearbeiten->schwein->fressen) ist soweit kein Problem, ich habs nur einfach nicht hinbekommen den Baum wieder hochzu"laufen". Ist es das klügste, alles in Funktionen auszulagern?

    So wie ich das mit den Funktionen grundent,aktionent und den nicht beschriebenen Funktionen Kartent & Schwent versucht habe geht es nämlich leider nicht. Ich vermute mal dass der Weg so total falsch ist, aber habe auch keine Idee, wie ich es anders lösen könnte.

    Vielleicht kann mir jemand von euch helfen 🙂

    Danke schonmal für die Mühe des durchlesens 😉

    Gruß,

    Hans



  • den baum runter (etwas bearbeiten->schwein->fressen) ist soweit kein Problem, ich habs nur einfach nicht hinbekommen den Baum wieder hochzu"laufen". Ist es das klügste, alles in Funktionen auszulagern?

    Was genau ist dein Problem? Das darzustellen oder das im Code zu machen? - Im Code ist das ja eigentlich genau das gleiche, wie runter. Du gibts einfach die Möglichkeit eine Ebene raufzuspringen.


Anmelden zum Antworten