Nun habe ich jedoch ein Problem bei dem ich die Welt nichtmehr verstehe.

Hier ist grade mal ein Codeausschnitt zuerst vom Berreich wo der Fehler auftritt.

string wie_gehts_weiter = "" ;
	    cin  >> wie_gehts_weiter;
int iCondition = 0;
	while (iCondition == 0)

	{

		if(wie_gehts_weiter == "Neu"||"neu"||"NEU")
	{
		cout << "Warum wird dieses If aufgerufen obwohl man alt eingibt \n";
	}

	else if(wie_gehts_weiter == "alt"||"Alt"||"ALT") // RECHNE MIT ALTEN ZAHLEN WEITER
	{

	if (which_numbers == "ganz" || "Ganz"||"GANZ")
	{

	cout << ergebniss_ganzzahlen ;
	}  

	else if (which_numbers == "komma" || "Komma"||"KOMMA" )
	{
	cout << ergebniss_komma ;
	}

	else
	{
	cerr << " Fehler Falsche eingabe bitte komma oder ganz eingeben .\n";
	}

	} // Ende  elseif wiegehtsweiter == alt

	else
	{
	cout << "Falsche Eingabe nitte alt oder neu eingeben\n";

	}

	}//Ende der while(iCondition == 0) Schleife

Das Problem ist , dass auch wenn ich in den string wie_gehts_weiter "alt" per cin einlese wird dennoch folgende Anweisung ausgeführt

if(wie_gehts_weiter == "Neu"||"neu"||"NEU")
	{
		cout << "Warum wird dieses If aufgerufen obwohl man alt eingibt \n";
	}

Habt ihr eine Idee wo das das Problem sein könnte?
Er müsste doch theoretisch sobald ich "alt" ,"ALT", oder "Alt" einlese die else if Anweisungen ausführen wieso ruft er immer das erste if auf?

Falls es jemand zum verständnis braucht ist hier der bisherige Code ( Er ist noch unvollständig , daher werden manche Dinge vlt noch nicht klar sein wieso ich etwas mache dann einfach nachfragen bitte).

#include <iostream>
#include <string>
using namespace std;

 long rechen_function_ganzzahlen( long first_number, long second_number ,char rechenzeichen)
{   
	long result   ; 
	switch(rechenzeichen)  
	{
	case '+' :       result = first_number+second_number ; break;
	case '-' :       result = first_number-second_number ; break;
	case '*' :       result =  first_number*second_number ; break;
	case '/' :       result = first_number/second_number;  break;
	default: cout << "unbekanntes Rechenzeichen...\n"; return 1;
	}

	return result;
}

 float rechen_function_kommazahlen( float first_number, float second_number ,char rechenzeichen )
{   float result ;
	switch(rechenzeichen)  
	{
	case '+' :       result =  first_number+second_number; break;
	case '-' :       result =  first_number-second_number; break;
	case '*' :       result =  first_number*second_number; break;
	case '/' :       result =  first_number/second_number; break;
	default: cout << "unbekanntes Rechenzeichen...\n"; return 1;
	}
	return result ;

}

int main()
{   

	long  ergebniss_ganzzahlen = 0;
	float ergebniss_komma = 0;
	cout  <<"\t\t\t############################\n"
		<<  "\t\t\t#     Taschenrechner       #\n"
		<<  "\t\t\t#     von    Mir :)       #\n"
		<<  "\t\t\t#     -------------        #\n"                  
		<<  "\t\t\t############################\n";

	int global_condition = 0 ;
	while (global_condition == 0) 
	{ //ANFANG WHILE (global_condition)

	cout << "Wollen sie mit vollen Zahlen , oder Gleitkommazahlen rechnen? \n "
	     << "Geben sie nun entweder ganz ,oder komma ein\n";
	string which_numbers = "";
	cin >> which_numbers ;
	if (which_numbers == "ganz" || "Ganz"||"GANZ")
	{
	// Wenn mit Ganzzahlen gerechnet werden soll kommt dieser Part 
    cout << " Geben sie bitte ihre Rechnung ein und bestätigen sie mit die Eingabe jeweils \n mit Enter\n"
	     << " Die Rechnung muss 2 Zahlen , und ein Rechenzeichen beinhalten \n";

	long  number_one = 0, number_two = 0 ;
	char rechenzeichen_auswahl = '\0';

	cout << "Erste Zahl\n";
	cin >> number_one ;
	cout << "Rechenzeichen(+  -  *   /  ) \n";
	cin >> rechenzeichen_auswahl;
	cout <<"Zweite Zahl\n";
	cin >> number_two ;

	ergebniss_ganzzahlen =  rechen_function_ganzzahlen(number_one ,number_two ,rechenzeichen_auswahl);

	cout << "Das Ergebnis ihrer Rechnung beträgt : " << ergebniss_ganzzahlen << endl ; 
  // Bis hier mit ganzzahlen 
	}
	// Ab hier mit Komma Zahlen 
	else if(which_numbers == "komma" || "Komma"||"KOMMA" )
	{

    cout << " Geben sie bitte ihre Rechnung ein und bestätigen sie mit die Eingabe jeweils \n mit Enter\n"
	     << " Die Rechnung muss 2 Zahlen , und ein Rechenzeichen beinhalten \n";

	float  number_1 = 0, number_2 = 0;
	char rechenzeichen_auswahl = '\0';

	cout << "Erste Zahl\n";
	cin >> number_1 ;
	cout << "Rechenzeichen(+  -  *   /  ) \n";
	cin >> rechenzeichen_auswahl;
	cout <<"Zweite Zahl\n";
	cin >> number_2 ;

	ergebniss_komma =  rechen_function_kommazahlen(number_1 ,number_2 ,rechenzeichen_auswahl);
	cout << "Das Ergebnis ihrer Rechnung beträgt : " << ergebniss_komma << endl ; 
	// Bis hierhin mit Kommazahlen
	}
	cout <<"Moechten sie noch eine Zahl zu ihrem Ergebnis dazu Rechnen , oder wollen sie wieder mit neuen Zahlen Rechnen\n"
	     <<"Wenn sie mit neuen Zahlen rechnen wollen geben sie \' neu in die Konsole ein \n"
		 <<"Möchten sie mit dem alten Ergebnis weiterrechnen geben sie \'alt ein \n";
	string wie_gehts_weiter = "" ;
	    cin  >> wie_gehts_weiter;
	int iCondition = 0;
	while (iCondition == 0)

	{

		if(wie_gehts_weiter == "Neu"||"neu"||"NEU")
	{
		cout << "Warum wird dieses If aufgerufen obwohl man alt eingibt \n";
	}

	else if(wie_gehts_weiter == "alt"||"Alt"||"ALT") // RECHNE MIT ALTEN ZAHLEN WEITER
	{

	if (which_numbers == "ganz" || "Ganz"||"GANZ")
	{

	cout << ergebniss_ganzzahlen ;
	}  

	else if (which_numbers == "komma" || "Komma"||"KOMMA" )
	{
	cout << ergebniss_komma ;
	}

	else
	{
	cerr << " Fehler Falsche eingabe bitte komma oder ganz eingeben .\n";
	}

	} // Ende  elseif wiegehtsweiter == alt

	else
	{
	cout << "Falsche Eingabe nitte alt oder neu eingeben\n";

	}

	}//Ende der while(iCondition == 0) Schleife

	}//ENDE WHILE (global_condition)
return 0 ;
}

Würde mich über hilfreiche Antworten sehr freuen .

if(wie_gehts_weiter == "Neu"||"neu"||"NEU")

->

if (wie_gehts_weiter == "Neu" || wie_gehts_weiter == "neu" || ... == "NEU")

if (wie_gehts_weiter == "Neu"||"neu"||"NEU")

Du meinst

if (wie_gehts_weiter == "Neu" || wie_gehts_weiter == "neu"|| wie_gehts_weiter == "NEU")

Ebenso an all den anderen Stellen, die so ähnlich aussehen. Damit du dich nicht tot tippst, bietet es sich an, dass du eine Funktion zum Stringvergleich schreibst, die dann auch automatisch alle Groß- und Kleinschreibvarianten testet.

(Oder du nimmst die fertige Funktion dafür aus der Boost Bibliothek)

DerNoob1993 schrieb:

if(wie_gehts_weiter == "Neu"||"neu"||"NEU")

->

if (wie_gehts_weiter == "Neu" || wie_gehts_weiter == "neu" || ... == "NEU")

Ach ich danke dir vielmals daß hab ich bei ganz vielen anderen ifs auch falsch gemacht .
War echt verzweifelt , und habe einfach nicht verstanden wieso er immer nur das erste if aufruft ^^.

@SEPP ja das ist ne sehr gute Idee mir ne Funktionen zum vergleichen von strings zu schreiben.Werde ich mich gleich dranbegeben :).

Was ist denn, wenn der Nutzer "NEu" oder "neU" eintippt?

if (wie_gehts_weiter == "Neu"||"neu"||"NEU")

Du meinst

if (wie_gehts_weiter == "Neu" || wie_gehts_weiter == "neu"|| wie_gehts_weiter == "NEU")

Ebenso an all den anderen Stellen, die so ähnlich aussehen. Damit du dich nicht tot tippst, bietet es sich an, dass du eine Funktion zum Stringvergleich schreibst, die dann auch automatisch alle Groß- und Kleinschreibvarianten testet.

(Oder du nimmst die fertige Funktion dafür aus der Boost Bibliothek)

Bevor du ihn lange im Dunkeln tappen lässt:
http://en.cppreference.com/w/cpp/algorithm/transform
http://de.cppreference.com/w/cpp/algorithm/transform

transform(to_modify.begin(), to_modify.end(), to_modify.begin(), tolower );

Header + namespace suchst du dir selber raus.

SeppJ schrieb:

Was ist denn, wenn der Nutzer "NEu" oder "neU" eintippt?

if (wie_gehts_weiter == "Neu"||"neu"||"NEU")

Du meinst

if (wie_gehts_weiter == "Neu" || wie_gehts_weiter == "neu"|| wie_gehts_weiter == "NEU")

Ebenso an all den anderen Stellen, die so ähnlich aussehen. Damit du dich nicht tot tippst, bietet es sich an, dass du eine Funktion zum Stringvergleich schreibst, die dann auch automatisch alle Groß- und Kleinschreibvarianten testet.

(Oder du nimmst die fertige Funktion dafür aus der Boost Bibliothek)

Bevor du ihn lange im Dunkeln tappen lässt:
http://en.cppreference.com/w/cpp/algorithm/transform
http://de.cppreference.com/w/cpp/algorithm/transform

transform(to_modify.begin(), to_modify.end(), to_modify.begin(), tolower );

Header + namespace suchst du dir selber raus.

Danke , aber ich werde nachdem ich das gröbste vom Taschenrechner fertig habe mich mal selbst dransetzen ,und versuchen eine Funktion zu schreiben welche alle Groß/Kleinschreibvarianten durchgeht,da ich nur dabei etwas lerne.
Ich schreibe einfach eine Funktion welche jedes Zeichen in einem String durchgeht , und jedes Zeichen mit der tolower() Funktion in einen Kleinbuchstaben umwandelt , dann brauch ich beim if nurnoch eine Bedingung in kleinschrift schreiben .

-> N3337 §25.3.4/5

Sone, Du nervst!

Entspann dich, hab mich versehen.

Was mich noch interessieren würde grade.
Kann man einer switch() anweisung auch irgendwie einen string oder ein char array übergeben?
Habe beides probiert mein Compiler sagt allerdings " Der Ausdruck muss einen Integralen Typ oder einen Enumerationstyp aufweisen". Gibt es da garkeine möglichkeit? Denn die case Fälle sind wesentlich übersichtlicher , und ich muss noch wesentlich mehr verschachtelte if fälle mit strings einfügen da wäre das mit cases deutlich übersichtlicher finde ich .

Nein, das geht nicht direkt. Das solltest du auch gar nicht brauchen. switch ist zwar bei Anfängern recht beliebt, kommt meiner Erfahrung nach praktisch aber so gut wie nie vor. Technisch geht es bei der switch-Anweisung eher um schnelle Sprünge im Maschinencode. Wenn es jedoch darum geht, massive if-Kaskaden zu vermeiden, so sind andere Techniken meistens viel besser geeignet. Was genau hast du vor? Vielleicht wäre eine map<string, irgendwas> das richtige. Nein, das ist wahrscheinlich noch weit über dem, was du derzeit kennst. Ein guter Anfang sind, wie schon gesagt, Funktionen. Vielleicht kannst du das, was du vor hast, in schöne Funktionen, mit jeweils klar umrissenen Aufgaben, fassen. Erfahrungsgemäß vereinfachen sich dadurch viele Probleme so weit, dass sie sich praktisch von alleine lösen.

EDIT: Da war ich wohl anderthalb Minuten zu langsam.

DerNoob1993 schrieb:

Was mich noch interessieren würde grade.
Kann man einer switch() anweisung auch irgendwie einen string oder ein char array übergeben?
Habe beides probiert mein Compiler sagt allerdings " Der Ausdruck muss einen Integralen Typ oder einen Enumerationstyp aufweisen". Gibt es da garkeine möglichkeit? Denn die case Fälle sind wesentlich übersichtlicher , und ich muss noch wesentlich mehr verschachtelte if fälle mit strings einfügen da wäre das mit cases deutlich übersichtlicher finde ich .

Nein, das geht nicht direkt. Das solltest du auch gar nicht brauchen. switch ist zwar bei Anfängern recht beliebt, kommt meiner Erfahrung nach praktisch aber so gut wie nie vor. Technisch geht es bei der switch-Anweisung eher um schnelle Sprünge im Maschinencode. Wenn es jedoch darum geht, massive if-Kaskaden zu vermeiden, so sind andere Techniken meistens viel besser geeignet. Was genau hast du vor? Vielleicht wäre eine map<string, irgendwas> das richtige. Nein, das ist wahrscheinlich noch weit über dem, was du derzeit kennst. Ein guter Anfang sind, wie schon gesagt, Funktionen. Vielleicht kannst du das, was du vor hast, in schöne Funktionen, mit jeweils klar umrissenen Aufgaben, fassen. Erfahrungsgemäß vereinfachen sich dadurch viele Probleme so weit, dass sie sich praktisch von alleine lösen.

Ok ich danke dir für die Antwort.
Dann werd ichs einfach in Funktionen packen um es übersichtlich zu halten.

Nein, nur einen int (wobei enum gewissermaßen auch ein int ist) integrale Typen, Aufzählungstypen, oder Klassen mit einem eindeutigen Umwandlungsoperator hin zu einem integralen oder Aufzählungstyp.

FTFY .
http://www.c-plusplus.net/forum/194356

EOP schrieb:

Nein, nur einen int (wobei enum gewissermaßen auch ein int ist) integrale Typen, Aufzählungstypen, oder Klassen mit einem eindeutigen Umwandlungsoperator hin zu einem integralen oder Aufzählungstyp.

FTFY .
http://www.c-plusplus.net/forum/194356

TY.
Fehlen noch Funktionen, die einen integralen- oder Aufzählungstypen zurückgeben.

Hatte aber eigentlich nicht vor einen offensichtlichen Anfänger mit zu detaillierten Infos eher zu verwirren als ihm eine einfache Antwort zu geben.

Das passiert hier schon viel zu oft, daß auf einfache Fragen manche Leute meinen mit "Kuck mal was ich Tolles kenne, was du garantiert nicht verstehst" antworten zu müssen.

Wobei ich sicher nicht dich damit meine.

mfg

Sind Aufzählungstypen gleichbedeutend mit Charakteren, also "char" ?

Nein. Aufzählungstypen sind enum s.

EDIT: ...und kein pointer ist (wobei ich das noch nicht versucht habe).

Fehlen noch Funktionen, die einen integralen- oder Aufzählungstypen zurückgeben.

Das sind aber keine Typen, sondern Ausdrücke.

Das passiert hier schon viel zu oft, daß auf einfache Fragen manche Leute meinen mit "Kuck mal was ich Tolles kenne, was du garantiert nicht verstehst" antworten zu müssen.

Das ist eher so als Klarstellung/Ausblick gemeint. Wenn du gleich mit meiner Antwort gekommen wärst, hätte ich wohl im Gegenteil eine Antwort wie deine darunter geschrieben, damit der TE es auch versteht.

EOP schrieb:

Ach ja, bool und char geht auch noch.
Im Prinzip wohl alles, was in einem einzigen Register übergeben werden kann.

Nein, das ist nicht das Kriterium. Es geht um die Ganzzahligkeit. Fließkommazahlen gehen z.B. nicht.

EOP schrieb:

Das passiert hier schon viel zu oft, daß auf einfache Fragen manche Leute meinen mit "Kuck mal was ich Tolles kenne, was du garantiert nicht verstehst" antworten zu müssen.

Das ist eher so als Klarstellung/Ausblick gemeint. Wenn du gleich mit meiner Antwort gekommen wärst, hätte ich wohl im Gegenteil eine Antwort wie deine darunter geschrieben, damit der TE es auch versteht.

Hahaha, das ist mal cool.

switch ist zwar bei Anfängern recht beliebt, kommt meiner Erfahrung nach praktisch aber so gut wie nie vor.

cout << "Erste Zahl\n";
	cin >> number_one ;
	cout << "Rechenzeichen(+  -  *   /  ) \n";
	cin >> rechenzeichen_auswahl;
	cout <<"Zweite Zahl\n";
	cin >> number_two ;

Man kann alle cins auf einmal einlesen sprich 5+6 direkt nach dem allersten cout eingeben. Und dann werden alle anderen cout der Reihe nach ausgegeben,und die anderen cins übergangen ( das ergebniss ist sogar richtig) ,aber wieso kann ich in das erste cin die gesamte Rechnung einlesen verstehe das grade nicht. http://epvpimg.com/EZnbe hier ist ein Bild wie ich das ganze meine.Er liest ja zuerst nur den int wert ein wie kann ich in diesen denn die Rechnung einlesen?
Hier ist mein Code falls ihr den noch zum Verständniss braucht.

include <iostream>
#include <string>
using namespace std;

 long rechen_function_ganzzahlen( long first_number, long second_number ,char rechenzeichen)
{   
	long result = 0  ; 
	switch(rechenzeichen)  
	{
	case '+' :       result = first_number+second_number ; break;
	case '-' :       result = first_number-second_number ; break;
	case '*' :       result =  first_number*second_number ; break;
	case '/' :       result = first_number/second_number;  break;
	default: cout << "unbekanntes Rechenzeichen.\n"; break;
	}

	return result;
}

 float rechen_function_kommazahlen( float first_number, float second_number ,char rechenzeichen )
{   float result = 0  ;
	switch(rechenzeichen)  
	{
	case '+' :       result =  first_number+second_number; break;
	case '-' :       result =  first_number-second_number; break;
	case '*' :       result =  first_number*second_number; break;
	case '/' :       result =  first_number/second_number; break;
	default: cout << "unbekanntes Rechenzeichen.\n"; break;
	}
	return result ;

}

int main()
{   

	long  ergebniss_ganzzahlen = 0;
	float ergebniss_komma = 0;
	cout  <<"\t\t\t############################\n"
		<<  "\t\t\t#     Taschenrechner       #\n"
		<<  "\t\t\t#     von    Mir :)        #\n"
		<<  "\t\t\t#     -------------        #\n"                  
		<<  "\t\t\t############################\n";

	int global_condition = 0 ;
	while (global_condition == 0) 
	{ //ANFANG WHILE (global_condition)

	string which_numbers = "";

	int first_while_condition = 0;
	while(first_while_condition == 0)

	{    //ANFANG while first_while_Condition 
            cout << "Wollen sie mit vollen Zahlen , oder Gleitkommazahlen rechnen? \n "
	     << "Geben sie nun entweder ganz ,oder komma ein\n";
        cin >> which_numbers ;
	if (which_numbers == "ganz" || which_numbers == "Ganz"|| which_numbers == "GANZ")
	{
	// Wenn mit Ganzzahlen gerechnet werden soll kommt dieser Part 
    cout << " Geben sie bitte ihre Rechnung ein und bestätigen sie mit die Eingabe jeweils \n mit Enter\n"
	     << " Die Rechnung muss 2 Zahlen , und ein Rechenzeichen beinhalten \n";

	long  number_one = 0, number_two = 0 ;
	char rechenzeichen_auswahl = '\0';

	cout << "Erste Zahl\n";
	cin >> number_one ;
	cout << "Rechenzeichen(+  -  *   /  ) \n";
	cin >> rechenzeichen_auswahl;
	cout <<"Zweite Zahl\n";
	cin >> number_two ;

	ergebniss_ganzzahlen =  rechen_function_ganzzahlen(number_one ,number_two ,rechenzeichen_auswahl);

	cout << "Das Ergebnis ihrer Rechnung beträgt : " << ergebniss_ganzzahlen << endl ; 

	 ++first_while_condition; //Verlasse die while first_while_Condition Schleife
	// Bis hier mit ganzzahlen 
	}
	// Ab hier mit Komma Zahlen 
	else if(which_numbers == "komma" ||which_numbers == "Komma"||which_numbers =="KOMMA" )
	{

    cout << " Geben sie bitte ihre Rechnung ein und bestätigen sie mit die Eingabe jeweils \n mit Enter\n"
	     << " Die Rechnung muss 2 Zahlen , und ein Rechenzeichen beinhalten \n";

	float  number_1 = 0, number_2 = 0;
	char rechenzeichen_auswahl = '\0';

	cout << "Erste Zahl\n";
	cin >> number_1 ;
	cout << "Rechenzeichen(+  -  *   /  ) \n";
	cin >> rechenzeichen_auswahl;
	cout <<"Zweite Zahl\n";
	cin >> number_2 ;

	ergebniss_komma =  rechen_function_kommazahlen(number_1 ,number_2 ,rechenzeichen_auswahl);
	cout << "Das Ergebnis ihrer Rechnung beträgt : " << ergebniss_komma << endl ; 

	++first_while_condition ; // Verlassse die first_while_condition  Schleife

	// Bis hierhin mit Kommazahlen

	}

	else
	{
	cout << "Falsche Eingabe bitte erneut ganz oder komma ein \n";

	//Wiederhole die first_while_condition Schleife
	}

	}//Ende while first_while_Condition 
    cout <<"Moechten sie noch eine Zahl zu ihrem Ergebnis dazu Rechnen , oder wollen sie wieder mit neuen Zahlen Rechnen\n"
	     <<"Wenn sie mit neuen Zahlen rechnen wollen geben sie  neu in die Konsole ein \n"
		 <<"Möchten sie mit dem alten Ergebnis weiterrechnen geben sie alt ein \n";

	string wie_gehts_weiter = "" ;
	cin  >> wie_gehts_weiter;

	int next_condition = 0;
	while (next_condition == 0)
	{   //ANFANG WHILE next_condition zum prüfen ob alt oder neu eingegeben wurde.
	if(wie_gehts_weiter == "Neu" || wie_gehts_weiter == "neu" || wie_gehts_weiter == "NEU")

	{
		cout << "Taschenrechner wird neugestartet\n" ;        
		++next_condition ;
	//Wiederhole die Hauptschleife (while global_condition)

	}

	else if(wie_gehts_weiter == "alt"||wie_gehts_weiter == "Alt"|| wie_gehts_weiter ==  "ALT") // RECHNE MIT ALTEN ZAHLEN WEITER
	{
		int iCondition = 0;
		while (iCondition == 0) // while , weil man bei Eingabe von alt endlos weiterrechnen will bis der nutzer es stoppt.

	{ //Anfang while iCondition == 0

	if (which_numbers == "ganz" || which_numbers =="Ganz"||which_numbers == "GANZ")//Wenn das alte Ergebnis eine Ganzzahl war .....
    {
	char rechen_zeichen = '\0';
	long zahl = 0, ergebnis = 0;
    cout << "Welche Art von Rechnung wollen sie vornehmen an dem alten Ergebniss vornehmen(+  -  *   /  ) ? \n";
	cin >> rechen_zeichen ;
	cout <<"Welche Zahl wollen sie zu ihrem alten Ergebniss dazu rechnen?\n";
	cin >> zahl ;
    ergebnis =  rechen_function_ganzzahlen(ergebniss_ganzzahlen,zahl,rechen_zeichen);  
	ergebniss_ganzzahlen = ergebnis ; //Damit das aktuelle Ergebniss immer übernommen wird und nicht mit dem ersten Ergebniss gerechnet wird.
	//Ganzzahlen dran denken immernoch in der Endlosschleife
	cout << "Ergebniss = "<< ergebnis << endl;
	}  

    else if (which_numbers == "komma" || which_numbers =="Komma"||which_numbers == "KOMMA")  //Wenn das alte Ergebnis eine Kommazahl war .....
    {
    char rechen_zeichen = '\0';
	float zahl = 0, ergebnis = 0;
    cout << "Welche Art von Rechnung wollen sie vornehmen an dem alten Ergebniss vornehmen(+  -  *   /  ) ? \n";
	cin >> rechen_zeichen ;
	cout <<"Welche Zahl wollen sie zu ihrem alten Ergebniss dazu rechnen?\n";
	cin >> zahl ;
    ergebnis =  rechen_function_kommazahlen(ergebniss_komma,zahl,rechen_zeichen);  
	ergebniss_komma = ergebnis ; //Damit das aktuelle Ergebniss immer übernommen wird und nicht mit dem ersten Ergebniss gerechnet wird.
	//Ganzzahlen dran denken immernoch in der Endlosschleife
	cout << "Ergebniss = "<< ergebnis << endl;
    }

	int condition_while = 0;

	while (condition_while == 0)
	{  //ANFANG WHILE condition_while == 0
	cout << "Wollen sie mit dem alten Ergebniss weiterrechnen oder nicht\n"
	     << " Antworten sie bitte nur mit ja oder nein \n";
	string yes_or_no ;
	cin >> yes_or_no ;

	if (yes_or_no == "ja" )
	{

	++condition_while ;//Springe nur aus der condition_while schleife NICHT aber aus der iCondition schleife
	}

	else if(yes_or_no == "nein")
	{
	++condition_while;
	++iCondition; // Springe aus der while(iCondition == 0) Schleife
	}

	else 
	{
	cout << "Falsche Eingabe bitte erneut ja oder nein eingeben\n"; 
	}

	} //ENDE WHILE condition_while == 0

    }//Ende der while(iCondition == 0) Schleife

    } // Ende  else if wiegehtsweiter == alt

    else
    {
    cout << "Falsche Eingabe bitte alt oder neu eingeben\n";

    }

	} //ENDE WHILE next_condition zum prüfen ob alt oder neu eingegeben wurde.

    }//ENDE WHILE (global_condition)
return 0 ;
}

Man kann alle cins auf einmal einlesen sprich 5+6 direkt nach dem allersten cout eingeben. Und dann werden alle anderen cout der Reihe nach ausgegeben,und die anderen cins übergangen ( das ergebniss ist sogar richtig) ,aber wieso kann ich in das erste cin die gesamte Rechnung einlesen verstehe das grade nicht. http://epvpimg.com/EZnbe hier ist ein Bild wie ich das ganze meine.Er liest ja zuerst nur den int wert ein wie kann ich in diesen denn die Rechnung einlesen?

Falsches Verständnis, was cin ist. cin ist nicht "lese etwas von der Tastatur ein". cin ist ein Streamobjekt, welches an den Zeichenstrom stdin gekoppelt ist. Ein Konsolenprogramm ist wie eine schwarze Kiste, da geht ein Lochstreifen^* rein, da stehen Zeichen drauf (stdin) und es gehen zwei Lochstreifen raus (stdout und stderr). Das cin-Objekt sitzt in dieser schwarzen Kiste und sieht nur diesen Lochstreifen. Es weiß nicht, wo er her kommt oder wie lang er ist. Es kann sich nur die Zeichen auf diesem Lochstreifen angucken. Das passiert, wenn du irgendwelche Lesefunktionen auf cin aufrufst. Dann gucken diese Funktionen sich den Lochstreifen an, fahren ihn dabei ggf. weiter und warten eventuell auch auf weitere Zeichen, falls die aktuelle Funktion noch nicht fertig ist. Dieses Warten erweckt bei Anfängern oft den Eindruck, dass die Lesefunktionen irgendwie aktiv Eingaben von der Tastatur einlesen würden. Dabei warten sie bloß darauf, dass über den Zeichenstrom stdin weitere Zeichen erscheinen.

Wie kommen diese Zeichen nun nach stdin? Dies kann sehr verschieden sein (und das ist auch gut so). Ich nehme mal an, dass du dein Programm von irgendeiner Konsole startest und dabei keine weitere Aktion unternimmst, um stdin irgendwie umzuleiten. Die Konsole wird dann einfach ihr eigenes stdin an dein Programm weiterleiten. Aber wo kommt das stdin der Konsole her? Die Konsole läuft in einem Terminal (heutzutage meistens ein Terminalemulator). Eventuell läuft der Terminal(emulator) auch nochmal in irgendetwas anderem. Aber irgendwann kommt man an der untersten Schicht an und diese Programmschicht fragt tatsächlich irgendwie Zeichen von der Tastatur ab, die dann weitergeleitet werden. Diese Eingaben werden dann mehr oder weniger unverändert an dein Programm weitergeleitet, ohne jede Information darüber, wo sie herkommen, wann sie entstanden sind oder sonst etwas. Einfach bloß ein langer Bytestrom. Ich sage fast unverändert, denn direkt die Tastendrücke weiterzuleiten wäre eher unpraktisch. Irgendeine Ebene zwischen der Tastatur und deinem Programm sorgt auch noch dafür, dass die Sondertasten so funktionieren, wie man es kennt. Also dass man Mit Delete und Backspace die Eingabe verändern kann und erst mit Druck der Entertaste wird die Eingabe tatsächlich an die nächste Ebene weitergeleitet. Wieder sieht es so aus, als hätte die cin-Lesefunktion auf die Entertaste gewartet. Dabei hat sie bloß auf weitere Zeichen auf stdin gewartet, während eine ganz andere Ebene auf den Abschluss der Eingabe mittels Entertaste gewartet hat und erst dann die von ihr gesammelte Eingabe an die stdins der weiteren Ebenen weitergeleitet hat, bis sie letztendlich bei deiner cin-Lesefunktion angekommen sind.

Nun sollte auch verständlich sein, warum es egal ist, wann und wie du deine Eingabe für das Programm durchführst. Dein Programm sieht sowieso nur einen Zeichenstrom und es ist ihm egal, wie dieser Zustande kommt.

^*: Für die Jüngeren:
http://en.wikipedia.org/wiki/Punched_tape

DerNoob1993 schrieb:

Man kann alle cins auf einmal einlesen sprich 5+6 direkt nach dem allersten cout eingeben. Und dann werden alle anderen cout der Reihe nach ausgegeben,und die anderen cins übergangen ( das ergebniss ist sogar richtig) ,aber wieso kann ich in das erste cin die gesamte Rechnung einlesen verstehe das grade nicht. http://epvpimg.com/EZnbe hier ist ein Bild wie ich das ganze meine.Er liest ja zuerst nur den int wert ein wie kann ich in diesen denn die Rechnung einlesen?

Falsches Verständnis, was cin ist. cin ist nicht "lese etwas von der Tastatur ein". cin ist ein Streamobjekt, welches an den Zeichenstrom stdin gekoppelt ist. Ein Konsolenprogramm ist wie eine schwarze Kiste, da geht ein Lochstreifen^* rein, da stehen Zeichen drauf (stdin) und es gehen zwei Lochstreifen raus (stdout und stderr). Das cin-Objekt sitzt in dieser schwarzen Kiste und sieht nur diesen Lochstreifen. Es weiß nicht, wo er her kommt oder wie lang er ist. Es kann sich nur die Zeichen auf diesem Lochstreifen angucken. Das passiert, wenn du irgendwelche Lesefunktionen auf cin aufrufst. Dann gucken diese Funktionen sich den Lochstreifen an, fahren ihn dabei ggf. weiter und warten eventuell auch auf weitere Zeichen, falls die aktuelle Funktion noch nicht fertig ist. Dieses Warten erweckt bei Anfängern oft den Eindruck, dass die Lesefunktionen irgendwie aktiv Eingaben von der Tastatur einlesen würden. Dabei warten sie bloß darauf, dass über den Zeichenstrom stdin weitere Zeichen erscheinen.

Wie kommen diese Zeichen nun nach stdin? Dies kann sehr verschieden sein (und das ist auch gut so). Ich nehme mal an, dass du dein Programm von irgendeiner Konsole startest und dabei keine weitere Aktion unternimmst, um stdin irgendwie umzuleiten. Die Konsole wird dann einfach ihr eigenes stdin an dein Programm weiterleiten. Aber wo kommt das stdin der Konsole her? Die Konsole läuft in einem Terminal (heutzutage meistens ein Terminalemulator). Eventuell läuft der Terminal(emulator) auch nochmal in irgendetwas anderem. Aber irgendwann kommt man an der untersten Schicht an und diese Programmschicht fragt tatsächlich irgendwie Zeichen von der Tastatur ab, die dann weitergeleitet werden. Diese Eingaben werden dann mehr oder weniger unverändert an dein Programm weitergeleitet, ohne jede Information darüber, wo sie herkommen, wann sie entstanden sind oder sonst etwas. Einfach bloß ein langer Bytestrom. Ich sage fast unverändert, denn direkt die Tastendrücke weiterzuleiten wäre eher unpraktisch. Irgendeine Ebene zwischen der Tastatur und deinem Programm sorgt auch noch dafür, dass die Sondertasten so funktionieren, wie man es kennt. Also dass man Mit Delete und Backspace die Eingabe verändern kann und erst mit Druck der Entertaste wird die Eingabe tatsächlich an die nächste Ebene weitergeleitet. Wieder sieht es so aus, als hätte die cin-Lesefunktion auf die Entertaste gewartet. Dabei hat sie bloß auf weitere Zeichen auf stdin gewartet, während eine ganz andere Ebene auf den Abschluss der Eingabe mittels Entertaste gewartet hat und erst dann die von ihr gesammelte Eingabe an die stdins der weiteren Ebenen weitergeleitet hat, bis sie letztendlich bei deiner cin-Lesefunktion angekommen sind.

Nun sollte auch verständlich sein, warum es egal ist, wann und wie du deine Eingabe für das Programm durchführst. Dein Programm sieht sowieso nur einen Zeichenstrom und es ist ihm egal, wie dieser Zustande kommt.

^*: Für die Jüngeren:
http://en.wikipedia.org/wiki/Punched_tape

Vielen Dank für deine ausführliche Antwort ich denke ich habe das Prinzip von cin jetzt einigermaßen verstanden.

Ich weiß ich frage echt viel , und zum Teil auch echt doofe Fragen , aber ich habe da grade noch ein Problem an dem ich nicht weiterkomme.

Es geht darum ,dass ich in ner while Schleife prüfen möchte ,ob der User den richtigen Typ der Variable einliest ( nicht ,dass er nachher in einen int wert einen string einliest , und das Programm abstürzt ,oder sinnloses ausgibt
Mein Lösungsansatz habe ich in einem kleinen "Testprojekt" getestet ,allerdings klappt das ganze einfach nicht.

#include <iostream>

int main()
{       long number_one = 0;
        int richtige_eingabe = 0 ;
	while(richtige_eingabe == 0)
	{
	cout << "Erste Zahl\n";

	if( (cin >> number_one ))
	{
	++richtige_eingabe;
	}

       else if( !( cin >> number_one))
       {}

       } 
}

Er liest hier number_one nur einmal ein und hängt dann in einer Endlosschleife in welcher er den Text "Erste Zahl" unendlich oft ausgibt , aber eben nicht von neu in cin einliest . Habe auch schon versucht bei falscher Eingabe mittels ZeroMemory den Wert zurückzusetzen , aber da passiert nur genau das selbe.Der Text wird dauerhaft ausgegeben , aber es wird nichts neues eingelesen.
Sinn der Schleife sollte sein ,dass bei falscher eingabe wie z.B. asdasd in einen int Typ die Schleife von neu beginnt und man die Zahl erneut einlesen soll.

So kann man das beispielsweise machen:

#include <iostream>
#include <cctype>

using namespace std;

void skip_word(istream &in)
{
  for (char c = in.peek(); in && isgraph(c); c = in.peek())
    in.ignore(1);
}

int main()
{
  int i;
  for (;;)
    {
      cin >> i;
      if (!cin && !cin.eof())
        {
          cout << "Das war keine Zahl\n";
          cin.clear();
          skip_word(cin);
        }
      else
        break;
    }
  cout << "Zahl gelesen: " << i << '\n';
}

Du wirst merken, dieses schon relativ komplexe Beispiel lässt noch viele Wünsche offen. Falls du vor hast, das weiter zu treiben und weitere Fehler abzufangen, lass dir gesagt sein, dass dies in die Richtung geht, ein eigenes GUI-Framework zu schreiben. Das gibt es aber schon längst und in viel besser.

Hier gehen drei Dinge schief:
1. Nachdem eine Eingabe fehlgeschlagen ist, so befindet sich der Stream in einem Fehlerzustand und es schlagen alle weiteren Aktionen fehl, bis man sich darum kümmert (z.B. mit clear()).
2. Danach sind natürlich immer noch die Zeichen auf dem metaphorischen Lochstreifen, die zum Fehlschlag geführt haben. Da muss man sich auch drum kümmern, z.B. mit ignore().
3. In Zeile 16 steht bei dir ja wieder etwas aus dem Stream gelesen (oder wenigstens wird es versucht). Das ist bestimmt nicht die Logik, die du dir vorgestellt hast.

So kann man das beispielsweise machen:

#include <iostream>
#include <cctype>

using namespace std;

void skip_word(istream &in)
{
  for (char c = in.peek(); in && isgraph(c); c = in.peek())
    in.ignore(1);
}

int main()
{
  int i;
  for (;;)
    {
      cin >> i;
      if (!cin && !cin.eof())
        {
          cout << "Das war keine Zahl\n";
          cin.clear();
          skip_word(cin);
        }
      else
        break;
    }
  cout << "Zahl gelesen: " << i << '\n';
}

Du wirst merken, dieses schon relativ komplexe Beispiel lässt noch viele Wünsche offen. Falls du vor hast, das weiter zu treiben und weitere Fehler abzufangen, lass dir gesagt sein, dass dies in die Richtung geht, ein eigenes GUI-Framework zu schreiben. Das gibt es aber schon längst und in viel besser.

Ich danke dir
Ich habe denke ich verstanden wie das ganze funktioniert.
Als erstes wenn das cin fehlschlägt benutzt man die cin.clear() Funktion um soweit ich richtig verstanden habe den Eingabebuffer zu leeren. Als nächstes übergibt man den stream an die selbst geschriebene Funktion welche jedes Zeichen des Streams von Anfang bis Ende ignoriert(löscht?).
Dadurch kann man es danach auch wieder neu einlesen ,und die if schleife wird nicht endlos ausgeführt.
Habe ich das soweit richtig verstanden , oder ist da etwas noch falsch an dem wie ich es aufgefasst habe?