Läuft auch alles ganz gut soweit. Jetzt habe ich allerdings ein Problem.
Ich habe ganz viele verschachtelte Switchanweisungen.

Um z.B. ein Gebäude zu bauen gibt man einfach eine Zahl von 1-8 an.
Jetzt habe ich aber wie auch vorher immer noch ein Gebäude und noch ein weiteres case dazugenommen. Nämlich das 9te...

Jetzt meine Frage... man kann doch über 8 cases haben ne?
Das Prob. ist das ich wenn ich 9 auswähle das gemacht wird was bei 8 passieren soll.

Liegt wahrscheinlich daran das ich zuviele Klammern da habe wo sie nicht hingehören. Aber bevor ich mich daran mache die zu emfrimeln wollte ich wissen ob es überhaupt was bringt.

mfg
Last-Boyscout

@SG1: Ist das vom Design her sinnvoll?

Hier mal der Code, der ist aber wahrscheinlich sehr unübersichtlich.
Bin noch ein Anfänger.

case 7:{
                                 if (Soldaten >=100)
                                 {

//Angriff starten!                                             
//******************************************************************************

                                              int eingabe2;
                                              int eingabe3;

                                              SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), HELLROT);
                                              cout << "                              Angriffsmen\x81" << endl;
                                              cout << "" << endl;
                                              cout << "                1. Computer angreifen! 2. Men\x81 verlassen" << endl;
                                              cin >> eingabe2;
                                              switch (eingabe2)
                                              {
                                                     case 1:{
                                                          cout << "Computer wird angegriffen!" << endl;
                                                          gegSoldaten = gegSoldaten - Soldaten;
                                                          cout << "Nach dem Kampf besass der Computer noch " << gegSoldaten << " Soldaten!" << endl;
                                                          Sleep(2000);
                                                          if (gegSoldaten <= 0)
                                                          {
                                                                          gegHaus = gegHaus -1;
                                                                          gegMine = gegMine -1;
                                                                          gegKaserne = gegKaserne -1;
                                                                          gegWerkstatt = gegWerkstatt -1;

                                                                          if (gegHaus && gegMine && gegKaserne && gegWerkstatt <= 0)
                                                                             {
                                                                                      cout << "Der Computer hat alles verloren!" << endl;
                                                                             }

                                                          cout << "Der Computer hat Gebäude verloren!" << endl;
                                                          Sleep(2000);
                                                          }

                                                          goto Anfang;

                                                     case 2:{
                                                          cout << "Men\x81 wird verlassen!" << endl;
                                                          Sleep(2000);
                                                          goto Anfang;
                                                          }
                                                          }

                                             }
                                             cout << "Du hast doch keine Soldaten!" << endl;
                                             Sleep(2000);
                                             goto Anfang;
                                             }

}
}
}
//******************************************************************************
//Ende Angriff!
                         }
                         }

                         case 8:{
                              if (Holzspeicher >= 50000)
                                 {
                                               if (Erzspeicher >= 35000)
                                               {

                                                                cout << "Werkstatt wird gebaut!" << endl;
                                                                Werkstatt = Werkstatt + 1;
                                                                Holzspeicher = Holzspeicher - 50000;
                                                                Erzspeicher = Erzspeicher - 35000;
                                                                Sleep(1000);
                                                                goto Anfang;
                                               }
                                 }
                                               cout << "Du hast zuwenig Holz/Erz um eine Werkstatt bauen zu können!" << endl;
                                               Sleep(500);
                                               goto Anfang;
                                 }

                         case 9:{
                              if (Holzspeicher >= 5000)
                              {
                                               if (Erzspeicher >= 4000)
                                               {
                                                               cout << "Farm wird gebaut!" << endl;
                                                               Farm = Farm +1;
                                                               Holzspeicher = Holzspeicher - 5000;
                                                               Erzspeicher = Erzspeicher - 4000;
                                                               Nahrungsende = Nahrungsende + 5;
                                                               Sleep(1000);
                                                               goto Anfang;
                                               }
                              }
                                                               cout << "Dir fehlen die Reccausen!" << endl;
                                                               goto Anfang;
                              }

Nur case 7-9... die anderen habe ich rausgelassen.

Wieso nicht?
Was wäre besser?

Z. B. Polymorphismus.

un vorallem keine GOTOs....

hehe, ich kanns noch nicht anders lösen.
Ist halt Rundenbasiert.
Und nach jedeweder Aktion springt man nunmal wieder zum Anfang.^^

Was ist denn Polymorphismus. mhm muss ich mal suchen.

Aber thx an alle Antworten!

1310-Logik schrieb:

Wieso nicht?
Was wäre besser?

Z. B. Polymorphismus.

Wie sähe so ein switch mit Polymorhpismus denn aus? Ich kann mir das irgentwie kaum vorstellen. Ich hab das so programmiert:

#include <iostream>
#include <map>

class MegaSwitch {
    public:
        void Add(int key, void (*neueFunktion)()) {
            funktionen_.insert(std::pair<int, void (*)()>(key, neueFunktion));
        }
        void Default(void (*f)()) {
            default_ = f;
        }
        void Switch(int key) {
            if(funktionen_.find(key) == funktionen_.end()) {
                default_();
                return;
            }
            funktionen_[key]();
        }
    private:
        std::map<int, void (*)()> funktionen_;
        void (*default_)();
};

void BaueGebaeude() {
    std::cout << "Baue Gebaeude..." << std::endl;
}

void BaueSoldat() {
    std::cout << "Baue Soldat..." << std::endl;
}

void Beenden() {
    std::cout << "Tschuess!" << std::endl;
    exit(0);
}

void FalscheEingabe() {
    std::cout << "Bitte?" << std::endl;
}

void ZeigeMenue() {
    std::cout << "\n0 - Gebaeude bauen\n";
    std::cout << "1 - Soldat bauen\n";
    std::cout << "2 - Beenden\n";
    std::cout << "Was willst du tun?" << std::endl;
}

int main() {
    MegaSwitch mySwitch;
    mySwitch.Default(FalscheEingabe);
    mySwitch.Add(0, BaueGebaeude);
    mySwitch.Add(1, BaueSoldat);
    mySwitch.Add(2, Beenden);
    while(true) {
        ZeigeMenue();
        int Eingabe;
        std::cin >> Eingabe;
        mySwitch.Switch(Eingabe);
    }
}

Doch den Vorteil erkenn ich jetzt noch nicht. (Und ist das überhaupt Polymorphismus?) Könnte man noch was mit Klassen einbauen oder wie wär es besser??

mfg.

Danke nochmal für eure Vorschläge.
Immoment, werde ich noch ein wenig noobisch weiterproggen.
Sobald ich dann ein neues Projekt starte werde ich mir hier mal das Beispiel ansehen.

Hier nochmal der Fehler:

case 7:{
                                 if (Soldaten >=100)
                                 {

//Angriff starten!                                            
//******************************************************************************

                                              int eingabe2;
                                              int eingabe3;

                                              SetConsoleTextAttribute(::GetStdHandle(STD_OUTPUT_HANDLE), HELLROT);
                                              cout << "                              Angriffsmen\x81" << endl;
                                              cout << "" << endl;
                                              cout << "                1. Computer angreifen! 2. Men\x81 verlassen" << endl;
                                              cin >> eingabe2;
                                              switch (eingabe2)
                                              {
                                                     case 1:{
                                                          cout << "Computer wird angegriffen!" << endl;
                                                          gegSoldaten = gegSoldaten - Soldaten;
                                                          cout << "Nach dem Kampf besass der Computer noch " << gegSoldaten << " Soldaten!" << endl;
                                                          Sleep(2000);
                                                          if (gegSoldaten <= 0)
                                                          {
                                                                          gegHaus = gegHaus -1;
                                                                          gegMine = gegMine -1;
                                                                          gegKaserne = gegKaserne -1;
                                                                          gegWerkstatt = gegWerkstatt -1;

                                                                          if (gegHaus && gegMine && gegKaserne && gegWerkstatt <= 0)
                                                                             {
                                                                                      cout << "Der Computer hat alles verloren!" << endl;
                                                                             }

                                                          cout << "Der Computer hat Gebäude verloren!" << endl;
                                                          Sleep(2000);
                                                          }

                                                          goto Anfang;

                                                     case 2:{
                                                          cout << "Men\x81 wird verlassen!" << endl;
                                                          Sleep(2000);
                                                          goto Anfang;
                                                          }
                                                          }

                                             }
                                             cout << "Du hast doch keine Soldaten!" << endl;
                                             Sleep(2000);
                                             goto Anfang;
                                             }

}     // <----- Die gehören nach unten sonst endet die obere Switchanweisung.
}     // <-----
}     // <-----
//******************************************************************************
//Ende Angriff!
                         }
                         }

                         case 8:{
                              if (Holzspeicher >= 50000)
                                 {
                                               if (Erzspeicher >= 35000)
                                               {

                                                                cout << "Werkstatt wird gebaut!" << endl;
                                                                Werkstatt = Werkstatt + 1;
                                                                Holzspeicher = Holzspeicher - 50000;
                                                                Erzspeicher = Erzspeicher - 35000;
                                                                Sleep(1000);
                                                                goto Anfang;
                                               }
                                 }
                                               cout << "Du hast zuwenig Holz/Erz um eine Werkstatt bauen zu können!" << endl;
                                               Sleep(500);
                                               goto Anfang;
                                 }

                         case 9:{
                              if (Holzspeicher >= 5000)
                              {
                                               if (Erzspeicher >= 4000)
                                               {
                                                               cout << "Farm wird gebaut!" << endl;
                                                               Farm = Farm +1;
                                                               Holzspeicher = Holzspeicher - 5000;
                                                               Erzspeicher = Erzspeicher - 4000;
                                                               Nahrungsende = Nahrungsende + 5;
                                                               Sleep(1000);
                                                               goto Anfang;
                                               }
                              }
                                                               cout << "Dir fehlen die Reccausen!" << endl;
                                                               goto Anfang;
                              }

Teste doch einfach mal den Case 8, wenn dein 'Holzspeicher' 10000 enthält.

/edit:

Reccausen!

Wohl eher Ressourcen.

schau dir doch mal schleifen an (while, for, do...)

Trotzdem musst du deine case-Anweisungen noch mit einem 'break;' beenden. Sonst werden die nachfolgenden Sachen ausgeführt.

Teste doch einfach mal den Case 8, wenn dein 'Holzspeicher' 10000 enthält.

/edit:

Reccausen!

Wohl eher Ressourcen.

durchs goto funktioniert es trozdem.
Aber danke für die Info, ich habe mich bei einem anderen Beispiel schonmal gewundert was ich falsch mache!

mach einfach ne grosse schleife um alles (ist hübscher)

while( quit == false )
{
//    hier dein ganzes Programm ab "Anfang"
//    und anstatt "goto Anfang;" machst du einfach "break;"
//    und im block wo du "Programm beenden" abfragst ein "quit = true;"
//    um die schleife zu beenden
}

bye

hey

mach einfach ne grosse schleife um alles (ist hübscher)

while( quit == false )
{
//    hier dein ganzes Programm ab "Anfang"
//    und anstatt "goto Anfang;" machst du einfach "break;"
//    und im block wo du "Programm beenden" abfragst ein "quit = true;"
//    um die schleife zu beenden
}

bye

ja wäre besser gewesen^^

mfg
Last-Boyscout