cin wird übersprungen

Nathan

Du leerst den Puffer mit cin.ignore().
Es werden dann solange Zeichen aus dem Puffer geleert, bis entweder Argument 1 Zeichen gelöscht wurden oder das Zeichen Argument 2 erreicht wurde.
In diesem Fall soll maximal alles gelöscht werden.
std::numeric_limits<irgendein_arithemetischer_typ>::max() liefert den größten Wert zurück, denn irgendein_arithmetischer_typ annehmen kann.
In diesme Fall ist irgendein_arithmetischer_typ std::streamsize und wir müssen den maximalen Wert verwenden, weil wir die maximale Anzahl aus dem Puffer löschen wollen.

omg langsam finde ich auch die sprache brain like (ohne sinn)

Ich will was löschen warum so komplizeirt?

Und wie soll die lösung aussehen? fehlt da was? ich kenne den befehl nicht, da reicht mir nicht der halbe bzw ka was da noch kommen soll.

Nathan

Die haste doch schon oben geschrieben.
Fehlt nur noch ein #include <limits>.
Und mit der Komplexität kommt auch hohe Flexibilität.
Aber mit der Zeit wirst du die Hintergründe dahinter verstehen.

SeppJ

Ich würde nicht versuchen, den Streams eine Text-GUI aufzudrücken. Wenn du GUI machen willst, dann nimm dafür auch GUI-Mittel, damit ist das was du vor hast ganz einfach. Wenn du die Streams benutzt dann sieh sie als den Datenstrom an, der sie sind. Wenn ein Logikfehler im Format der Eingabe vorliegt, dann ist die Eingabe eben fehlerhaft. Fertig. Versuch dann nicht, interaktiv auf der Eingabe zu werden, sondern sieh es einfach als Fehler an. Denn interaktive Programme setzen eine Menge über die Art und Weise voraus, wie die Eingabe erfolgt (z.B. dass da ein Mensch an einer Tastatur mit Monitor sitzt), die bei den abstrakten Standardeingabe- und Ausgabestreams gar nicht unbedingt gegeben sind.

Nein das klapt halt nicht.

include ist drinne, aber es kommen trd fehler, bzw nur bei der zeile.

1. Es wird ein Bezeichner erwartet.
2. Nich genügende Parameter
3. Syntax fehler
3. Ungültiger Token auf der rechten seite ::

Ja das bei der einen zeile ja.
Das muss ich nicht verstehen, und wie ich oben beschrieben habe, möchte ich 4 int füllen.

mit std::cin >> key1 >> key2 >> key3 >> key4;

vil liegt da der fehler?

SeppJ ich bin Anfänger.

Ist klar das es easy ist, wenn man es verstanden hat und auch mehr weiß.

PS GUI soll was sein?

Das sieht so aus, mit Dynamischern Speicher (Eingabe)

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

	// Eingabe
	std::cin >> (int)*key1 >> (int)*key2 >> (int)*key3 >> (int)*key4;

Aber er fickt rum bei eurer zeile mit Puffer Löschen.

PS: Benutze VS 2012

SeppJ

b4nan1 schrieb:

SeppJ ich bin Anfänger.

Ist klar das es easy ist, wenn man es verstanden hat und auch mehr weiß.

Deshalb mache ich dich auch darauf aufmerksam, dass du gerade versuchst, das eckige Klötzchen in das runde Loch zu stopfen. Man kann mit viel Gewalt versuchen, einen Stream wie ein interaktives Benutzerinterface zu benutzen, aber dafür ist er nicht gedacht und daher ist es auch so schwierig und selbst wenn es klappt, dann nicht gut.

PS GUI soll was sein?

Was macht man denn, wenn man ein Wort nicht kennt?

P.S.: Mein Rat ist übrigens nicht, dass du dich jetzt auf das nächstbeste GUI-Framework stürzt. Das wäre vermutlich viel zu schwierig. Mein Rat ist, die Streams so zu nutzen wie gedacht. Wenn es einen Fehler gibt, dann sieh die Eingabe als beendet oder fehlerhaft an (je nach Bedürfnis der Programmlogik). Versuch nicht, den Fehler zu korrigieren. Niemanden interessiert es, wie benutzerfreundlich dein Übungsprogramme sind, das ist der unwichtigste Aspekt beim Lernen. Sieh lieber zu, dass deine Programme korrekt funktionieren, schön geschrieben sind und coole Sachen machen.
Eine schöne Benutzerführung ist wie die Note im Schönschreiben. Im Prinzip könnte es jeder, wenn man sich bloß genug anstrengt, aber der Inhalt des geschriebenen wird dadurch nicht besser. Eventuell sogar schlechter, weil man Zeit mit den Äußerlichkeiten verschwendet.

ok, werde mich mal an die streams machen die mal alle kennen zu lern.
Wenn du eine PDF kennst was bezüglich das abhandelt wäre ich dir sehr verbunden

Das ding ist, was mache ich damit jetzt nun?
Soll ich das weg lasen, und nur clear benutzen, oder wie sol ich das verstehen?
Verstehe schon was du mit sauberers Programmieren meinst, bloß geht das klar mit clear? Also funktionieren tut es, aber ob es später vil zum fehler kommen kann weiß ich nicht, weswegen du mich wahrscheinlich auchf amerksam gemacht hast.

SeppJ

b4nan1 schrieb:

Wenn du eine PDF kennst was bezüglich das abhandelt wäre ich dir sehr verbunden

Heißt das, du lernst ganz ohne Lehrmaterial nur aus dem Internet? Nicht so gut. Hier hast du wenigstens ein brauchbares freies Ebook:
http://www.mindview.net/Books/TICPP/ThinkingInCPP2e.html
Du darfst aber erwarten, dass du damit nochmal völlig neulernen musst, wenn du bisher nur Internettutorials kennst. Aber das wäre dann auch gut so, denn Internettutorials sind meisten ziemlich schlecht.

Das ding ist, was mache ich damit jetzt nun?

Was soll dein Programm überhaupt machen?

Ne nicht ganz ohne
Vieles habe ich natürlich nicht (Noch nicht).

Der dynamische speicher soll den int den wert geben, und der int soll das dann zusammen rechnen bzw verarbeiten.

Wenn der int eine fehleingabe bekommt, was zum cin fehler anscheind führ, dann soll er halt den int auf 0 zurück setzen, und den cin ja clearen, damit die eingabe wiederholbar ist, und das nicht zu einer schleigfe kommt.

Deswegen habe ich ja hier geschrieben, warum de cin übersprungen wird, aber das weiß ich ja jetzt warum, bloß wie ich es jetzt gut löse ist jetzt die frage, mit clear geht das zwar, bloß meintest du das es nicht ausreicht.

Und das nicht ausreicht ist jetzt mein Problem, da es bei mir nicht klapt

SeppJ

b4nan1 schrieb:

Der dynamische speicher soll den int den wert geben, und der int soll das dann zusammen rechnen bzw verarbeiten.

Wenn der int eine fehleingabe bekommt, was zum cin fehler anscheind führ, dann soll er halt den int auf 0 zurück setzen, und den cin ja clearen, damit die eingabe wiederholbar ist, und das nicht zu einer schleigfe kommt.

Ich versteh kein Wort.

Beschreib mal auf Deutsch, ohne zu versuchen, Programmierfachjargon zu benutzen.

Ok,

Es wird ja eine Eingabe erwartet die er ja auch bearbeitet sprich auch rechnet (deswegen int).

Das ganze wird dann per fstream in einer datei gespeichrt und fertig.

Wenn du aber jetzt bei der eingabe ein großen wert reinschreibst der größer ist als int aufnehmen kann, dann kommt es zur einer schleife, da die abfrage fehgeschlagen ist (die ich noch stelle), und die eingabe soll wiederholt werden.
Bloß überspringt er den cin befehl, wenn ich nicht clear hätte, da es ja zum fehler führt.

Die Werte brauche ich nur am anfagn des Programms, und wenn die richtig sind, holt er die sich ja aus der Datei die ich zuvor angelgt habe (per programm).

Die schleife will ich ja beenden was ja mit clear klapt, aber du meinst es reicht ja nicht.

PS:
Er soll einfach damit rechnen und wieder vergessen, aber im laufe des programms kommen noch andere eingaben, vieleicht kommt es dann da zum fehler?

mfg

Hier mal der Source-Code:

int *key1 = new int;
	int *key2 = new int;
	int *key3 = new int;
	int *key4 = new int;

	*key1 = NULL;
	*key2 = NULL;
	*key3 = NULL;
	*key4 = NULL;

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

	// Eingabe
	std::cin >> (int)*key1 >> (int)*key2 >> (int)*key3 >> (int)*key4;

	keyblock1 = *key1;
	keyblock2 = *key2;
	keyblock3 = *key3;
	keyblock4 = *key4;

	if (eingabech (keyblock1, keyblock2, keyblock3, keyblock4) == true)
	{
		keytemp = 0;
		keytemp = keyblock1 + keyblock2;
		keytemp += keyblock3;
		keytemp -= keyblock4;
	}

	savekey ();

	// Speicher Löschen
	delete key1;
	delete key2;
	delete key3;
	delete key4;

	key1 = 0;
	key2 = 0;
	key3 = 0;
	key4 = 0;

	// Lösche Keyblock
	keyblock1 = NULL;
	keyblock2 = NULL;
	keyblock3 = NULL;
	keyblock4 = NULL;

	if (keytemp == OK)
		return true;
	else
		return false;
}

bool eingabech (int keyblock1, int keyblock2, int keyblock3, int keyblock4)
{
	if (keyblock1 > 00000 && keyblock2 > 00000 && keyblock3 > 00000 && keyblock4 > 00000 || keyblock1 == 0 && keyblock2 == 0 && keyblock3 == 0 && keyblock4 == 1)
		return true;
	else
		return false;
}

Der Checkt, und wenn das net passt schickt er dich hier rein. (mit for schleife)

SeppJ

Kannst du mir nun sagen, ob ich es brauche für meine Awendung oder nicht?

mfg

SeppJ

Ich weiß immer noch nicht, was das Programm überhaupt tun soll. Du würdest wohl selbst Microsoft Word so in dieser Art beschreiben:

"Es wird ja eine Eingabe erwartet die er ja auch bearbeitet. Der dynamische speicher soll den char den wert geben, und der char soll das dann zusammen verarbeiten. Das ganze wird dann per fstream in einer datei gespeichrt und fertig. "

Swordfish

...

jaahaaa ist klar das dir das so wie es da steht komisch vor kommt, genauso wie mir es komisch vor kommen wurde.

Ja dynamische speicher damit habe ich weig.. was getestet was ich noch net weg gemacht habe.

Oben die auf 0 setzen hat mit einer anderen funktion zu tun, weil er da nochmal rein kommen kann.

Und wie gesagt, bin noch Anfänger... wenns danach geht, könnte ich mein ganzes zeug umschreiben (bzw besser) da ich jett eiwder mehr weiß als ich damit angefangen hab

PS: das sind nicht alle funktionen :), es ging ja um meine frage bzw das clearen von (cin).

Swordfish

...

//    HEADER    //

// INCLUDE
#include "stdafx.h"

#ifndef AKTIVIEREN_H
#define AKTIVIEREN_H

class aktivieren
{
private:

	std::string aktivs;
	bool aktivS;

public:

	void erstellestring ()
	{
		if (aktivS == true)
			aktivs = "-> Aktiviert!";
		else
			aktivs = "-> Nicht Aktiviert!";
	}

	void aktiv ()
	{
		aktivS = true;
	}

	void naktiv ()
	{
		aktivS = false;
	}

	void zeige ()
	{
		std::cout << aktivs;
	}

	void demo ()
	{
		aktivs = "-> Demo!";
	}

	bool a ()
	{
		if (aktivS == true)
			return true;
		else
			return false;
	}
};

// INSTACE
extern aktivieren Aktiv;

#endif

//    CPP    //
#define OK 86051

unsigned int keyblock1, keyblock2, keyblock3, keyblock4 = 0;
int keytemp = 0;

std::fstream keyfile;

// Serial - Aktivieren
bool serialkey ()
{

	// Dynamischer Speicher (KEY)
	int *key1 = new int;
	int *key2 = new int;
	int *key3 = new int;
	int *key4 = new int;

	*key1 = NULL;
	*key2 = NULL;
	*key3 = NULL;
	*key4 = NULL;

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

	// Eingabe
	std::cin >> (int)*key1 >> (int)*key2 >> (int)*key3 >> (int)*key4;

	keyblock1 = *key1;
	keyblock2 = *key2;
	keyblock3 = *key3;
	keyblock4 = *key4;

	if (eingabech (keyblock1, keyblock2, keyblock3, keyblock4) == true)
	{
		keytemp = 0;
		keytemp = keyblock1 + keyblock2;
		keytemp += keyblock3;
		keytemp -= keyblock4;
	}

	savekey ();

	// Dynamischer Speicher Löschen
	delete key1;
	delete key2;
	delete key3;
	delete key4;

	key1 = 0;
	key2 = 0;
	key3 = 0;
	key4 = 0;

	// Lösche Keyblock
	keyblock1 = NULL;
	keyblock2 = NULL;
	keyblock3 = NULL;
	keyblock4 = NULL;

	if (keytemp == OK)
		return true;
	else
		return false;
}

bool eingabech (int keyblock1, int keyblock2, int keyblock3, int keyblock4)
{
	if (keyblock1 > 00000 && keyblock2 > 00000 && keyblock3 > 00000 && keyblock4 > 00000 || keyblock1 == 0 && keyblock2 == 0 && keyblock3 == 0 && keyblock4 == 1)
		return true;
	else
		return false;
}

bool checkserial ()
{
	if (keyfile)
	{
		keyfile.open("uksdac.dat",std::ios::in);
		keyfile >> keyblock1;
		keyfile >> keyblock2;
		keyfile >> keyblock3;
		keyfile >> keyblock4;
		keyfile.close ();
		keytemp = 0;
		keytemp = keyblock1 + keyblock2;
		keytemp += keyblock3;
		keytemp -= keyblock4;
	}

	if (keytemp == OK)
		return true;
	else
		return false;
}

void serial ()
{
	int x = 0;
	while (x == 0)
	{
		if (checkserial () == true || demo () == true)
		{
			x = 1;
			Aktiv.aktiv ();
			savekey ();

			if (demo () == true)
			{
				Aktiv.demo ();
				savekey ();
			}
			else
			{
				Aktiv.erstellestring ();
				savekey ();
			}
		}
		else
		{
			Aktiv.naktiv ();
			serialkey ();
		}
	}
}

void savekey ()
{
	keyfile.open("uksdac.dat", std::ios::out);
	keyfile << keyblock1 << std::endl;
	keyfile << keyblock2 << std::endl;
	keyfile << keyblock3 << std::endl;
	keyfile << keyblock4 << std::endl;
	keyfile.close ();
}

bool demo ()
{
	if (keyblock1 == 0 && keyblock2 == 0 && keyblock3 == 0 && keyblock4 == 1)
		return true;
	else
		return false;
}

Das soll sowas wie ein Key sein.
Ich weiß das die eig.. anders Funktionieren, aber ok

PS: Ich bin immer noch Anfänger