Arrayelemente schreiben und lesen

Schauen ob lesen funktioniert, dann einfügen.
Index erhöhen.

double  tmp;
  if (cin>>tmp)
    arr[i]=tmp

Sone

Schauen ob lesen funktioniert, dann einfügen.

Falsch. Dann wird solange gewartet bis überhaupt ein Zeichen eingegeben wird das kein Whitespace ist.

Wenn ich beim Eingeben der 10 Werte, einmal keinen Wert eingebe und nur die Entertaste drücke, dann soll der Array Werte auch keinen Wert aufnehmen. Sprich das jeweilige Arrayelement soll leer bleiben und dennoch soll Werte hochzählen....

Es sollte aber einen Wert annehmen.
Vorschlag: Es wird Null zugewiesen.

Nun zum Ansatz: Du musst durch einen String puffern, d. h. zuerst den String einlesen und dann in einen String-Stream stopfen und daraus extrahieren. Vor dem Stopfen prüfst du dann die Länge.
Die genannten Sachen sollten in einem guten Buch erklärt werden.

Ok, ich will dir mal was erklären.
Hier erstmal goldene Eigenschaften von Code:

Flexibilität
Lesbarkeit
Wartbarkeit
Kürze und Aussagekräftigkeit/Selbsterklärlichkeit
Nicht wiederholend

So, jetzt was mir auffällt:

Du deklarierst Variablen viel zu global - siehe bspw. Z. 7-9. Also wenn das mal goldig ist!
Schon mal was von der Refactoring-Technik extract method gehört?
Viel von deinem Code in der main() lässt sich auslagern sodass das Ganze viel goldiger ist!
Du flushst den Stream viel zu oft. Merke dir: Unnötige Sachen machen den Code weniger goldig!
Seinen Code mit einer Einrückungstiefe von zwei oder z. T. sogar nur einem Leerzeichen zu formatieren ist überhaupt nicht goldig!
So wenig Abstände in Form von Leerzeilen und Leerzeichen zu machen ist auch gar nicht goldig! Sieh dir mal das Gesetz der Nähe an, das lässt sich sehr schön auf Code-Gestaltung übertragen.

Sone schrieb:

Schauen ob lesen funktioniert, dann einfügen.

Falsch.

Sone, der alte Fuchs, hat mich wieder voll erwischt!

Und warum?
Weil ich kein kompilierbares Beispiel hatte....

Ich muss mich verbessern:

Schauen ob lesen funktioniert
wenn ja: einfügen
wenn nein: Eingabe Puffer leeren
Index erhoehen

Cheers,
FW

Oje...
Einen Compiler zur Hand schwant mir böses....

Sone

Schauen ob lesen funktioniert
wenn ja: einfügen
wenn nein: Eingabe Puffer leeren
Index erhoehen

Falsch... ^^
Dein Prinzip ist daneben. Es macht nicht was der TE will, denn die Extraktion ist formatiert und wartet bis ein Zeichen eingegeben wird was kein Whitespace ist - zum zweiten Mal...

Sone schrieb:

Dein Prinzip ist daneben.

Warum ist Deiner Meinung nach das Prinzip daneben?
Die erste Ausführung in C++ kränkelt etwas...

Aber ich kann es nach dem Prinzip(bzw. dem ersten) in ausreichender Qualität auch ordentlich hinbekommen und das newline schlucken...

double  tmp;
std::string s;
 if(std::getline(cin,s))
   if(std::stringstream(s) >> tmp)
     arr[j]=tmp;
++j;

Sone

Furble Wurble schrieb:

Sone schrieb:

Dein Prinzip ist daneben.

Warum ist Deiner Meinung nach das Prinzip daneben?
Die erste Ausführung in C++ kränkelt etwas...

Aber ich kann es nach dem Prinzip(bzw. dem ersten) in ausreichender Qualität auch ordentlich hinbekommen und das newline schlucken...
double  tmp;
std::string s;
 if(std::getline(cin,s))
   if(std::stringstream(s) >> tmp)
     arr[j]=tmp;
++j;

Ach, so meinst du das!
Ich hab verstanden du willst direkt aus cin extrahieren.

Sone schrieb:

Ich hab verstanden du willst direkt aus cin extrahieren.

Ja.
Das war auch mein ursprünglicher Plan.

Aber Du und mein Compiler wussten es besser....

Prinzipiell war's richtig ("schauen ob lesen funktioniert"), allein C++s Besonderheiten brachten mich zu Fall...

Danke! und
evtl. ist das auch ein Signal an den TE, warum kurze kompilierbare Beispiel von Nutzen sind!

silent_max

Werde ich ab sofort beherzigen, aber was soll ich machen, wenn der Programmcode wirklich nur drei Switch Anweisungen enthält, aber doch so lang ist??

Gruß

Max

silent_max

Ich habe es schon wie Furble Wurble gemeint.

Gruß

Swordfish

Sone schrieb:

Ich hab verstanden du willst direkt aus cin extrahieren.

#include <limits>
#include <vector>
#include <iostream>

void clear_istream( std::istream &is )
{
	is.clear();
	is.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
}

int main()
{
	int input = 0;

	std::vector< int > numbers;

	for( std::size_t i = 0; i < 10; ++i ) {

		while( !( std::cin.peek() == '\n' || std::cin >> input ) ) {

			std::cout << "Input error, try again!\n";
			clear_istream( std::cin );
		}

		numbers.push_back( input );
		input = 0;
		clear_istream( std::cin );
	}

	for( std::size_t i = 0; i < 10; ++i )
		std::cout << numbers[i] << '\n';
}

Sone

Hui, peek hab' ich ganz vergessen.

Werner Salomon

silent_max schrieb:

Wert[8] und Wert[9] sollen durch Betätigung von Enter keinen Wert aufnehmen, während Wert[i] dennoch inkrimentiert.

Wie kann ich das bewerkstelligen???

Hallo Max,

wenn Du die Helferlein is_endl und skipline zur Verfügung hast - würdest Du es dann hin bekommen?

Gruß
Werner

silent_max

So weit wie Du Werner bin ich noch lange nicht.

Gruß

Werner Salomon

Hallo Max,

silent_max schrieb:

So weit wie Du Werner bin ich noch lange nicht.

Brauchst Du ja auch nicht. Du sollst die beiden Funktionen auch nicht selber schreiben, sondern nur benutzen. Ich dachte etwa in der Art:

if( is_endl( cin ) ) // ist die Zeile leer?
            cout << "keine Eingabe" << endl;
        else if( cin >> wert >> skipline ) // nein, Zeile nicht leer, dann 'wert' lesen und Rest der Zeile überspringen
        {
            cout << "Ihre Eingabe: " << wert << endl;
            // .. wert speichern, oder was auch immer
        }

Ist das verständlich?

Gruß
Werner

Nexus

Werner Salomon: Falls dir die Zeit zur Verfügung steht, hast du schon einmal darüber nachgedacht, einen Artikel über die Parser-Fähigkeiten von std::istream zu schreiben? Davon könnten viele Leute profitieren (ich eingeschlossen). Müsste nicht zu sehr ins Detail über Stream-Interna gehen, darüber gibt es hier schon einen Artikel. Aber halt die netten Tricks mit operator>> , um nicht alles mit getline() und std::string zu zerstückeln