Ich wollte folgenden Code programmieren:

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

int main()
{
	cout << "\tAlles rund um Strings\n";
	cout << "\n";
	int number_1;

	do
	{
		cout << "Was wollen Sie tun?\n";
		cout << "(1) Stringlänge berechnen\n";
		cout << "(2) Strings addieren\n";
		cout << "(3) Pointer auf String\n";
		cout << "(4) Referenz auf String\n";
		cout << "(5) Groesse eines Strings ausgeben\n";
		cout << "(0) Abbruch\n";
		cin  >> number_1;

		switch(number_1)
		{
		case 1:
			string Text_1;

			cout << "Geben Sie einen Text ein!\n";
			getline(cin, Text_1);
			cout << "\n";
			cout << "Diesen Text haben Sie eingegeben:\n";
			cout << Text_1;
			cout << "Ihr Text hat " << Text_1.size() << " Buchstaben\n";

			break;

		case 2:
			string str_1;
			string str_2;
			string str_3;

			std::cin.ignore(1);

			cout << "Geben Sie das erste Wort ein:";
			getline(cin, str_1);
			cout << "Geben Sie das zweite Wort ein:";
			getline(cin, str_2);

			str_3 = str_1 + str_2;

			cout << "Zusammengefuegt heisst das Wort " << str_3 <<"\n";

			break;

		case 3:
			string Text_2;
			string *pText_2=&Text_2;

			std::cin.ignore(2);

			cout << "Geben Sie einen Text ein!\n";
			getline (cin, Text_2);

			cout << "\n";
			cout << "Diesen Text haben Sie eingegeben: \n";
			cout << Text_2;
			cout << "Speicheradresse Ihres Textes: " << &Text_2 << "\n";

			break;

		case 4:

			std::cin.ignore(3);
			 string a("Hallo");
			 string & ref = a;

			 ref += " Welt";

			 cout << (a==ref) << endl;
			 cout << a << std::endl << ref << endl;

			 break;

		case 5:

			std::cin.ignore(4);

			string Text;
			cout << "Geben Sie einen Text ein!\n";
			cin  >> Text;

			cout << sizeof(Text) << "\n";
			cout << "Groesse:\t " << Text.size() << "\n";
			cout << "Laenge:\t" << Text.length ()<< "\n";
			cout << "Kapazitaet:\t" << Text.capacity() << "\n";
			cout << "Max. Laenge:\t" << Text.max_size() << "\n";

			break;

		case 0:
			cout << "Exit durch Abbruch!\n";
			break;
		}
	}while(number_1!=0);

	return 0;
}

Nun bekomme ich jedoch bei der switch Anweisung folgende Fehlermeldung:

Error: Die Übertragung eines Steuerelements umgeht die Initialisierung von:

Ich weiß nicht, auf was sich die Fehlermeldung bezieht, da ich denke, dass ich richtig programmiert habe...

Wo liegt mein Denkfehler??

Danke für die Antworten im Voraus.

Gruß

Max

Eine Variable hat einen gewissen Gültigkeitsbereich, also ein Bereich wo sie existiert. Dieser geht von der Definition bis zum nächsten zugehörigen schließenden }.

{
int i; // i wird hier erzeugt
// ...
// ...
// ...
// ...
// ...
} // i wird hier zerstört

Analog auch:

{
// ... hier existiert i noch nicht!
// ...
// ...
int i; // i wird hier erzeugt
// ...
// ...
// ...
// ...
// ...
} // i wird hier zerstört

Auf der anderen Seite muss eine Variable in solch einer Klammerumgebung stehen. In deinen Cases vom Switch stehen sie aber ohne alles da.

Die Lösung ist, dass du das hier machst:

switch (xXx)
{
case 1:
    {
        // ...
    }
}

Du setzt also in die cases noch mal solche Klammern.

War silent_max das auch ?
Hatte nur im Kopf, dass das Problem hier aufkam, aber wusste nicht mehr von wem

Ja, das war ich und als cooky451 es gesagt hat, habe ich mich wieder daran errinnert...

Sorry nochmal...

Skym0sh0 schrieb:

War silent_max das auch ?
Hatte nur im Kopf, dass das Problem hier aufkam, aber wusste nicht mehr von wem

Ja, das war ich und als cooky451 es gesagt hat, habe ich mich wieder daran errinnert...

Sorry nochmal...

Wow, Du hast genau eine Woche gebraucht, das Erlernte zu vergessen.

Nicht schlecht.

mfg Martin

Es gibt Leute, die brauche weit weniger Zeit...

Vielleicht hat er auch erst jetzt wieder einen switch benutzt. Hätte er direkt im Anschluss an den letzten Thread dieses Programm geschrieben, wäre das Ergebnis vermutlich das gleiche gewesen.

Wow, Du hast genau eine Woche gebraucht, das Erlernte zu vergessen.

Sicher?

mgaeckler schrieb:

Wow, Du hast genau eine Woche gebraucht, das Erlernte zu vergessen.

Sicher?

Mea Culpa. Es waren weniger als 5 Tage 13 Stunden und 50 Minuten.

Ich finde es nicht so bemerkenswert, dass das wieder vergessen wurde, sondern vielmehr, dass die Fehlermeldung nicht für ein 'Ach ja ... ' - Erlebnis gesorgt hat.

Daher hat Bashar das Wort "Erlernte" markiert. Er bezog sich nicht auf den Zeitraum.

Das komische am Quellcode ist das, dass es zwar nun ausgeführt wird, aber dass Menüpunkt 1 übersprungen wird...

cin  >> number_1; // hinter dieser Zeile in deinem Code das hier einfügen:
cin.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );

Danke für den Tipp.

P.S.: Warum macht die Erklärung keinen Sinn?

P.S.: Warum macht die Erklärung keinen Sinn?

Es gab vor 6h so eine Diskussion darüber, aber offensichtlich hast du sie vergessen.

Es gab vor 6h so eine Diskussion darüber, aber offensichtlich hast du sie vergessen.

Sorry, aber ich war zwischen ca. 10:30 Uhr und 17:30 Uhr nicht am PC. Das sind 7 Stunden, in denen ich nichts mitbekommen habe...

Sorry, aber ich war zwischen ca. 10:30 Uhr und 17:30 Uhr nicht am PC. Das sind 7 Stunden, in denen ich nichts mitbekommen habe...

Das erklärt so einiges...

cin  >> number_1; // hinter dieser Zeile in deinem Code das hier einfügen:
cin.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );

ich versuchs einfach mal zu erklären:
mit Zeile 1 liest du wie gewohnt etwas von der Standardausgabe ein.
Was passiert aber im Fehlerfall (Als Programmierer lässt du ein int eingeben, der User gibt aber z.B. "123abc456" ein.)
Der Inputstream hat intern diese Zeichen alle (ob als String oder als sonstwas ist implementierungsabhängig) vorhanden. Er guckt dann zeichenweise, ob das Zeichen zur Anforderung (also zu einem int) passt. In dem konkreten Fall liest er die 1, 2 und die 3 und schiebt sie auch direkt aus dem Puffer (also dem Speicher-String). Dann merkt er "Oh, das a passt aber nicht".

Intern hat der Stream dann noch ein Flag (z.B. eine bool'sche Variable) für den Fehlerfall, die er sogleich auf Fehler setzt und er bricht mit dem Lesen ab.

Jetzt ist dein Standard-Input-Stream erstmal fertig, bzw ausser Gefecht. Diesen Status muss man aber abfragen, denn von sich aus meldet der Stream nichts.

Szenario 1: Du nutzt cin(also deinen Stream) einfach weiter wie gewohnt und liest jetzt noch einen int ein (bzw willst). Intern sieht der Stream aber jetzt "Oh, da steht noch was im Puffer, ich nehm das zuerst. Aber huch, da ist ja auch ein Fehler. Da hab ich keine Lust mehr und streike". Das Ergebnis für deine zweite Eingabeauforderung: Der User wird gar nicht erst gefragt(der Stream gibt ja schon vorhergeschriebenen Inhalt vor), aber hat die int Variable beschrieben.
Auf gut deutsch: inputstreams in einer Schleife fragen den User bis zur Falscheingabe und laufen danach naja ungefragt im Endlosmodus weiter.

Szenario 2: Du fragst nach jeder Eingabe den Stream, ob er noch ganz beisammen ist, etwa so:

int i;
if ( !(cin >> i) ) { }
// oder so
cin >> i;
if ( !cin ) { }
// oder so
cin >> i;
if ( cin.good() ) { }
// oder so
cin >> i;
if ( cin.fail() ) { }

Und im Fehlerfall korrigierst du den/die Fehler.
Und das macht man mit Ignore. Dieses löscht nämlich beliebig viele Zeichen (erster Parameter) aus dem Stream. Die andere Möglichkeit ist, es löscht so viele Zeichen im Streambuffer bis ein gewisses Zeichen kommt (der zweite Parameter). Der Fall von den beiden geschilderten, der zuerst eintritt, entscheidet.
In dem von komisch genannten Beispiel ist das erste Argument die grösste Zahl die eine Streamgrösse annehmen kann. (std::numeric_limits< std::streamsize >::max())

Danach ist der Streambuffer leer. Das Failbit ist aber noch gesetzt, dieses entfernt man mit clear().

Ist eigentlich ganz einfach und logisch. Aber frag nicht warum der Standard das so will und nicht die Streams automatisch korrigiert, dafür gibt es viele Gründe (sowohl dafür als auch dagegen).

int i;
cin >> i;

if ( !cin )
{
    cin.ignore(std::numeric_limits< std::streamsize >::max(), '\n');
    cin.clear();
}