Also mein Wunsch ist es ein simples Konsolenfenster zu machen, dass + - * : rechnen kann.
Wenn man irgendwas falsches eintippt, bekommt man eine Message und jumpt zurück.
Nun das Problem ist, dass er wenn ich bei Zahlen z.B. einen Buchstaben eintippe, gibt er unendlich Fehlertexte aus und springt scheinbar zurück und wieder hin gibt Message aus und dann wieder zurück usw.. Bei den Menus geht's aber
Ich komm einfach net mehr weiter und hoffe das ihr mir helfen könnt.
Also keine eintippfehler machbar und hier ist der Code:

P.S.: Das sind nur 2/10 des Codes also so stark wie möglich reduziert um hier die Fehler korrekt zu schildern..

#include <iostream> 
#include <conio.h> 
#include <windows.h> 
using namespace std; 

void wait() 
{ 
    FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE)); 
    getch(); 
} 

int main () 
{ 
   // Überschrift und Versionsnummer 
   cout << "!Taschenrechner 1.0 von Darthshoot!\n\n"; 
   // Instruktionen zum Bedienen vom Taschenrechner 
   cout << "Addieren '+' Subtrahieren '-' Multiplizieren '*' Dividieren ':'\n\n"; 

   // Einzugebende Zahlen 
   int Zahl1; 
   int Zahl2; 
   int Zahl3; 

   /* Ergebnisse die im INT gespeichert werden.. 
   Dank neuem Verfahren spare ich 
   mir 9 Ergebnisse (+= usw.) */ 
   int Ergebnis; 

   // Speicher von den Zeichen 
   char chZeichen1; 
   char chZeichen2; 

   // Bestimmt ob weiter gemacht wird oder beendet 
   char go_or_end1; 
   char go_or_end2; 

   // Beginn der Eingabe 
Zahlen_Eingabe1: 
   cout << "Zahl1: "; 
   cin  >> Zahl1; 

   /* Ahh da fällt mir noch ein, 
   dass man die Zahlen auf fehlerhafte 
   Eingaben überprüfen muss! */ 
   switch (Zahl1) 
   { 
   case ('a'): 
   case ('b'): 
   case ('c'): 
   case ('d'): 
   case ('e'): 
   case ('f'): 
   case ('g'): 
   case ('h'): 
   case ('i'): 
   case ('j'): 
   case ('k'): 
   case ('l'): 
   case ('m'): 
   case ('n'): 
   case ('o'): 
   case ('p'): 
   case ('q'): 
   case ('r'): 
   case ('s'): 
   case ('t'): 
   case ('u'): 
   case ('v'): 
   case ('w'): 
   case ('x'): 
   case ('y'): 
   case ('z'): 
   // Erweiterte Zeichen bei deutschen Keyboards 
   case ('ö'): 
   case ('ü'): 
   case ('ä'): 
      { 
         cout << "Falsche Eingabe der Zahl!\n"; 
         // Neu eingeben... 
         goto Zahlen_Eingabe1; 
      } break; 
   } 

   /* Hier her wird gesprungen wenn Zahl1 richtig war, 
   oder Zeichen1 falsch..diese Art der Kommentierung 
   sieht ziemlich smart aus :-) */ 
   Zeichen_Pruefung1: 
   cout << "+ - * : --> "; 
   cin  >> chZeichen1; 

   // Prüft jetzt ob die Eingabe falsch war 
   switch (chZeichen1) 
   { 
   case ('+'): 
   case ('-'): 
   case ('*'): 
   case (':'): 
      { 
         // Wenn richtig dann zu Zahl2 gehen 
         goto Zahlen_Eingabe2; 
      } break; 
   default: 
      { 
         /* Er sollte ne Message rausgeben, 
         wenn etwas net gestimmt hat und zurück springen */ 
         cout << "Falsche Eingabe der Rechenzeichen!\n"; 
         goto Zeichen_Pruefung1; 
      } 
   } 

      // Beginn der Eingabe 
Zahlen_Eingabe2: 
   cout << "Zahl2: "; 
   cin  >> Zahl2; 

   /* Ahh da fällt mir noch ein, 
   dass man die Zahlen auf fehlerhafte 
   Eingaben überprüfen muss! */ 
   switch (Zahl2) 
   { 
   case ('a'): 
   case ('b'): 
   case ('c'): 
   case ('d'): 
   case ('e'): 
   case ('f'): 
   case ('g'): 
   case ('h'): 
   case ('i'): 
   case ('j'): 
   case ('k'): 
   case ('l'): 
   case ('m'): 
   case ('n'): 
   case ('o'): 
   case ('p'): 
   case ('q'): 
   case ('r'): 
   case ('s'): 
   case ('t'): 
   case ('u'): 
   case ('v'): 
   case ('w'): 
   case ('x'): 
   case ('y'): 
   case ('z'): 
   // Erweiterte Zeichen bei deutschen Keyboards 
   case ('ö'): 
   case ('ü'): 
   case ('ä'): 
      { 
         cout << "Falsche Eingabe der Zahl!\n"; 
         // Neu eingeben... 
         goto Zahlen_Eingabe2; 
      } break; 
   } 

   // Hier wird bestimmt, ob man + - * oder : genommen hat oder was anderes 
   switch (chZeichen1) 
   { 
      // War es Plus? 
   case ('+'): 
      { 
         // Manmanman... ganz schön klever 
         Ergebnis = Zahl1 + Zahl2; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
      // War es Minus? 
   case ('-'): 
      { 
         // Jetzt wird minus gerechnet 
         Ergebnis = Zahl1 - Zahl2; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
      // War es Plus? 
   case ('*'): 
      { 
         // Hmmm das multiplizieren ist einfach 
         Ergebnis = Zahl1 * Zahl2; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
      // Und jetzt nur noch dividieren 
   case (':'): 
      { 
         // Jetzt wird minus gerechnet 
         Ergebnis = Zahl1 / Zahl2; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
   } 

Menu1: 
   // Mini-Menu mit 2 Optionen 
   cout << "(w)eiter (b)eenden\n"; 
   cin  >> go_or_end1; 

   /* So jetzt kommt der Switch für Beenden oder weiter machen.. 
   Ich hoffe mal, dass es auch klappt! */ 
   switch (go_or_end1) 
   { 
   case ('W'): 
   case ('w'): 
      { 
         goto Zeichen_Pruefung2; 
      } break; 
   case ('B'): 
   case ('b'): 
      { 
         // Hier springt er zum Schluss des Programms 
         goto Beenden_vom_Programm; 
      } 
   default: 
      { 
         // Immer wieder der Mist mit den falschen Eingaben... 
         cout << "Falsche Eingabe bei den Optionen!\n"; 
         goto Menu1; 
      } 
   } 

   /* So hier ist der erste Abschnitt zu ende... 
   Jetzt kommt die dritte Zahl und eine kleine 
   Modifikation vom Script, da es leider mit 
   normalem Kopieren nicht geht... */ 

   /* Hier her wird gesprungen wenn Zahl1 richtig war, 
   oder Zeichen1 falsch..diese Art der Kommentierung 
   sieht ziemlich smart aus :-) */ 
Zeichen_Pruefung2: 
   cout << "+ - * : --> "; 
   cin  >> chZeichen2; 

   // Prüft jetzt ob die Eingabe falsch war 
   switch (chZeichen2) 
   { 
   case ('+'): 
   case ('-'): 
   case ('*'): 
   case (':'): 
      { 
         // Wenn richtig dann zu Zahl2 gehen 
         goto Zahlen_Eingabe3; 
      } break; 
   default: 
      { 
         /* Wenn etwas net gestimmt hat, 
         sollte er ne Message rausgeben und zurück springen */ 
         cout << "Falsche Eingabe der Rechenzeichen!\n"; 
         goto Zeichen_Pruefung2; 
      } 
   } 

   // Beginn der Eingabe 
Zahlen_Eingabe3: 
   cout << "Zahl3: "; 
   cin  >> Zahl3; 

   /* Ahh da fällt mir noch ein, 
   dass man die Zahlen auf fehlerhafte 
   Eingaben überprüfen muss! */ 
   switch (Zahl3) 
   { 
   case ('a'): 
   case ('b'): 
   case ('c'): 
   case ('d'): 
   case ('e'): 
   case ('f'): 
   case ('g'): 
   case ('h'): 
   case ('i'): 
   case ('j'): 
   case ('k'): 
   case ('l'): 
   case ('m'): 
   case ('n'): 
   case ('o'): 
   case ('p'): 
   case ('q'): 
   case ('r'): 
   case ('s'): 
   case ('t'): 
   case ('u'): 
   case ('v'): 
   case ('w'): 
   case ('x'): 
   case ('y'): 
   case ('z'): 
   // Erweiterte Zeichen bei deutschen Keyboards 
   case ('ö'): 
   case ('ü'): 
   case ('ä'): 
      { 
         cout << "Falsche Eingabe der Zahl!\n"; 
         // Neu eingeben... 
         goto Zahlen_Eingabe3; 
      } break; 
   } 

   // Hier wird bestimmt, ob man + - * oder : genommen hat oder was anderes 
   switch (chZeichen2) 
   { 
      // War es Plus? 
   case ('+'): 
      { 
         /* Manmanman... ganz schön klever 
         Hier tritt die modifikation ein! */ 
         Ergebnis += Zahl3; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
      // War es Minus? 
   case ('-'): 
      { 
         // Jetzt wird minus gerechnet 
         Ergebnis -= Zahl3; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
      // War es Plus? 
   case ('*'): 
      { 
         // Hmmm das multiplizieren ist einfach 
         Ergebnis *= Zahl3; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
      // Und jetzt nur noch dividieren 
   case (':'): 
      { 
         // Jetzt wird minus gerechnet 
         Ergebnis /= Zahl3; 
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl; 
      } break; 
   } 

Menu2: 
   // Mini-Menu mit 2 Optionen 
   cout << "(w)eiter (b)eenden\n"; 
   cin  >> go_or_end2; 

   /* So jetzt kommt der Switch für Beenden oder weiter machen.. 
   Ich hoffe mal, dass es auch klappt! */ 
   switch (go_or_end2) 
   { 
   case ('W'): 
   case ('w'): 
      { 
         // goto Zahlen_Eingabe4; (wird gleich aktiviert...) 
         goto Beenden_vom_Programm; 
      } break; 
   case ('B'): 
   case ('b'): 
      { 
         // Hier springt er zum Schluss des Programms 
         goto Beenden_vom_Programm; 
      } 
   default: 
      { 
         // Immer wieder der Mist mit den falschen Eingaben... 
         cout << "Falsche Eingabe bei den Optionen!\n"; 
         goto Menu2; 
      } 
   } 

   /* So hier ist der erste Abschnitt zu ende... 
   Jetzt kommt die dritte Zahl und eine kleine 
   Modifikation vom Script, da es leider mit 
   normalem Kopieren nicht geht... */ 

Beenden_vom_Programm: 

   // Kommandos zum Beenden des Programms 
   wait(); 
   return 0; 
   }

MfG Darthshoot

soviele gotos habe ich selten gesehen.

mach dir einmal die mühe, alle durch for oder whileschleifen zu ersetzen (je nachdem, was sich anbietet).

du wirst sehen, das wirkt wunder ... (und es geht immer )

#include <climits>//für INT_MAX

int main( )
{
    int x;

	while ( !(cin>>x) ) {

		cin.clear();
		cin.ignore(INT_MAX, '\n');
		cout<<"Falscheingabe";
	}
}

switch (Zahl1) 
   { 
   case ('a'): 
   case ('b'): 
   case ('c'): 
   case ('d'): 
   case ('e'): 
   case ('f'): 
   case ('g'): 
   case ('h'): 
   case ('i'): 
   case ('j'): 
   case ('k'): 
   case ('l'): 
   case ('m'): 
   case ('n'): 
   case ('o'): 
   case ('p'): 
   case ('q'): 
   case ('r'): 
   case ('s'): 
   case ('t'): 
   case ('u'): 
   case ('v'): 
   case ('w'): 
   case ('x'): 
   case ('y'): 
   case ('z'): 
   // Erweiterte Zeichen bei deutschen Keyboards 
   case ('ö'): 
   case ('ü'): 
   case ('ä'): 
      { 
         cout << "Falsche Eingabe der Zahl!\n"; 
         // Neu eingeben... 
         goto Zahlen_Eingabe1; 
      } break; 
   }

sowas könnteste auch kürzer schreiben:
if (!isdigit(Zahl1)) goto Zahlen_Eingabe1;

Kann mir einer sagen wie ich das mit Switch hinbekomme?
Das wäre klasse, weil ich denke das ich da noch länger net hinkommen werde..

@Net: He kannste mir diesen Command mal genauer erklären?

Auch habe ich deinen Quellcode jetzt nicht im Detail angeschaut, aber du machst einen logischen Fehler. Erstmal liest du eine Ganzzahl ein:

cin  >> Zahl1;

Das ist ja noch ok. Aber dann vergleichst du diese Eingabe mit Buchstaben. Das funktioniet zwar (Zeichenliterale evaluieren ja letztendlich auch nur zu integralen Werten), ist aber logisch vollkommen falsch. Du liest ja bereits einen integralen Wert ein (Typ int), dh cin sorgt schon selbst dafür, dass auch nur gültige Ziffern für diesen Wert in Betracht gezogen werden. Evtl. Fehler kannst du wie folgt abfragen:

if (!(cin >> Zahl1))
    // Fehler

IIRC gabs da aber noch etwas, was hierdurch nicht abgefangen wird. Ist mir momentan allerdings entfallen. Spielt für deine Anwendunge auch erstmal keine Rolle.

Ausserdem ist dein Programm ein nettes Beispiel für den Einsatz des Strategy Patterns.

case ('+'):
      {
         // Manmanman... ganz schön klever
         Ergebnis = Zahl1 + Zahl2;
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl;
      } break;
      // War es Minus?
   case ('-'):
      {
         // Jetzt wird minus gerechnet
         Ergebnis = Zahl1 - Zahl2;
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl;
      } break;
      // War es Plus?
   case ('*'):
      {
         // Hmmm das multiplizieren ist einfach
         Ergebnis = Zahl1 * Zahl2;
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl;
      } break;
      // Und jetzt nur noch dividieren
   case (':'):
      {
         // Jetzt wird minus gerechnet
         Ergebnis = Zahl1 / Zahl2;
         cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl;
      } break;
   }

Merkst du was? Sehr viel identischer Code. Das ist nicht nur redundant (auch wenn der Compiler da noch ein bisschen optimieren kann, zB die String Literale), sondern führt auch schnell zu Inkonsistenzen. Lagere einfach die unterschiedlichen Sachen in eine Strategy Klasse/Funktion aus und du hast schon mal ein Stückchen zur Vereinfachung des Quellcodes beigetragen, zB

struct calc_strategy
{
    static int make_it_so(char op, int lhs, int rhs)
    {
        switch (op)
        {
            case '+':
                return lhs + rhs;
            case '-':
                return lhs - rhs;
            case '*':
                return lhs * rhs;
            // solltest du nicht besser '/' verwenden?
            case ':':
                return lhs / rhs;
        }
        // Fehler!?
        return 0;
    }
};

Ergebnis = calc_strategy::make_it_so(chZeichen1, Zahl1, Zahl2);
cout << "1. Das Ergebnis lautet --> " << Ergebnis << endl;

Ist natürlich noch relativ einfach gehalten und lässt sich verbessern und mit anderen Teilen deines Programmes verbinden. Soll daher nur das Prinzip verdeutlichen.

Und bitte bitte bitte bitte bitte lass diese Verwendung von goto schnell in der Versenkung verschwinden und benutze für sowas vorgesehene Kontrollstrukturen wie Schleifen.

@Net: He kannste mir diesen Command mal genauer erklären?

vergiss es einfach. das geht nicht bei dir weil du einen 'int' eingibst (hatte groovy schon drauf hingewiesen).

Das Programm was du dort geschrieben hast ist erst eine sehr kleine Applikation. Nun stell dir einfach mal vor, du programmierst an einem großen Projekt und verwendest permanent diese scheußlichen gotos...

Ich habe mich sehr intensiv mit der OOA/D beschäftigt und programmiere schon länger in C++; da muss ich sagen ich habe in einem ernsthafen Programm noch _nie_ gotos verwendet - noch nicht mal ein einziges! Wenn du mein Tipp hören möchtest: Vergiss die gotos einfach. Wenn die in deinem Buch vorkommen, dann überspring das Kapitel einfach oder kauf dir ein anständiges Buch. Du kannst ja mal in ein Programm das dir gefällt reinschauen (ein vorteil von opensource) und mal nach gotos suchen - ich wette du wirst keine oder (je nach Anwendung) nur einige wenige finden.

vermutung2: das strategy pattern wird er nicht verstehen[, weil]

groovy hat's doch gut erklärt da oben

otze schrieb:

vermutung2: das strategy pattern wird er nicht verstehen[, weil]

groovy hat's doch gut erklärt da oben

hast du schonmal ein Haus auf Sand gebaut?

vermutung2: das strategy pattern wird er nicht verstehen[, weil]

Ja, das mag gut sein. Nur wollte ich auch nicht unbedingt, dass er es versteht. Strategy hat ja auch nicht Code Simplification als Hauptziel, das ist eigentlich nur ein schöner Nebeneffekt. Ich wollte dem OP einfach nur eine Möglichkeit zeigen, wie er seinen Code vereinfachen kann, da er doch so einiges unnötig mehrfach macht. Ich kann mich noch recht gut an meine ersten Gehversuche in Pascal erinnern. Mich hat es einfach immer gestört, wenn ich solche Codeduplikate hatte, wo nur 1-2 Unterschiede jeweils drin waren. Dann dieses ganze Copy&Paste, danach die einzelnen Stellen anpassen. Da haben sich schon mal schnell Fehler eingeschlichen. Und all das, nur weil man es nicht besser wusste. Der OP braucht das Strategy Pattern ja gar nicht zu kennen (ist ja auch ein recht umfangreiches Thema - und wie du schon sagst, für einen Anfänger noch zu viel), aber er soll zumindest das Prinzip des Stück Codes verstehen, was ich ihm gepostet habe, um damit problemlos auch die anderen Teile seines Programmes vereinfachen oder flexibler gestalten zu können.

Ich kann mich noch recht gut an meine ersten Gehversuche in Pascal erinnern. Mich hat es einfach immer gestört, wenn ich solche Codeduplikate hatte, wo nur 1-2 Unterschiede jeweils drin waren.

das stört wohl viele aber manchmal geht's nicht anders. angenommen man hat 'nen code der echt schnell sein muss in der ausführung (jeder taktzyklus zählt). der code hat 'ne schleife in derem innern eine bedingung ist. un das ganze schneller zu machen kann man die bedingung aus der schleife rausnehmen und zwei schleifen schreiben die sich sehr ähnlich sind.
also sowas:

while (...)
{
  mach_immer();
  if (dedingung)
    mach_dies();
  else
    mach_das();
}

ist langsamer als

if (bedingung)
  while (...)
  {
    mach_immer();
    mach_dies();
  }
else
  while (...)
  {
    mach_immer();
    mach_das();
  }

otze schrieb:

vermutung2: das strategy pattern wird er nicht verstehen[, weil]

groovy hat's doch gut erklärt da oben

Strategy Pattern? Wo?