beim Versuch einen Reaktionstest in ANSI C++ für die Konsole zu schreiben, stieß ich auf ein Problem.

#include <iostream>
#include <stdlib.h>
#include <ctime>

using namespace std;

int main(int argc, char *argv[])
{
  cout << endl;
  char c;
  int n;
  double diff, best;
  clock_t c1, c2;
  char cstr[256];

  best = 0.5;

  while(true)
  {
    cout << "CLOCK STARTED..." << endl;

    n = (rand() % 10 + 5) * CLOCKS_PER_SEC;
    c1 = clock();
    while(n > clock() - c1)
    {}

    cout << "PRESS ENTER NOW!";

    // Wie leert man cin?

    c1 = clock();
    cin.get(c);
    c2 = clock();
    diff = (double(c2 - c1) / CLOCKS_PER_SEC);
    cout << "reaction time: " << diff << "s" << endl;

    ...

    cout << endl;
  }
  return 0;
}

Wenn man bei diesem Programm noch bevor PRESS ENTER NOW! erscheint die Eingabetaste betätigt, dann scheint die Reaktionszeit 0s zu sein. Wie kann man also den Eingabepuffer leeren?

Lg freeG

cin.flush();

Bitte lieber nachdenken bevor geschrieben wird -- .flush() gibt's nur für ostream -Objekte, nicht für istream -Objekte!
http://www.cplusplus.com/reference/iostream/istream/

cin.flush();

Lg freeG

‘struct std::istream’ has no member named ‘flush’

@ccc: Kann dir leider auch nicht weiterhelfen, denn alle Methoden den Eingabepuffer zu leeren sind eher Behelfsmittel, da C++ die Eingabe nur als eine lange Reihe von Zeichen ansieht, ohne irgendwelche Informationen darüber in welchem Puffer sie gerade sind, wann sie eingegeben wurden oder woher sie kommen. Beispielsweise könnte man jedes C++ Programm ohne jede Änderung mit einer Datei anstatt einer Tastatur als Eingabe benutzen, dies ist sogar eine sehr verbreitete Methode. Und wie du dir sicherlich denken kannst, macht "Eingabepuffer leeren" bei einer Datei keinen Sinn, weil gar nicht klar ist was ein Eingabepuffer sein soll.
Wenn du wirklich sicher gehen willst, dass die Eingabe von der Tastatur kommt, empfehle ich dir eine Konsolenbibliothek zu benutzen. Diese bieten dann natürlich auch Methoden um den Puffer zu leeren, denn wenn man weiß, dass die Eingabe von der Tastatur kommt, macht der Begriff "Eingabepuffer" auch einen Sinn. Leider sind die verschiedenen Konsolen zueinander ziemlich inkompatibel, weswegen du dich mit der Bibliothek auch auf ein System festlegen würdest. Eine verbreitete Bibliothek für POSIX-Konsolen ist beispielsweise ncurses.

fr33g schrieb:

cin.flush();

Bitte lieber nachdenken bevor geschrieben wird -- .flush() gibt's nur für ostream -Objekte, nicht für istream -Objekte!
http://www.cplusplus.com/reference/iostream/istream/

Ups, ja sorry wär in dem Fall besser gewesen

Lg freeG

cin is an object of class istream that represents the standard input stream. I

4.) click auf istream, scroll down, lies methoden

ignore Extract and discard characters (public member functions)

5.) click ignore, scroll down, lies und schau den Code an

Mach eigenen code:
Ignoriere ganz viele Zeichen vor deinen Textausgaben.
Mach deine Textausgabe 1. Warte ... vor Textausgabe prüfe of Taste gedrückt wurde, wenn ja BEEEEEEEEEEEEEEEEEEEEEEEP, Verloren.
Mach deine 2. Textausgabe, warte auf Taste und rechne Zeit

...istream::ignore()...

Keine gute Idee:

www.cplusplus.com schrieb:

`istream& ignore ( streamsize n = 1, int delim = EOF );

`
Extract and discard characters
Extracts characters from the input sequence and discards them.

The extraction ends when n characters have been extracted and discarded or when the character delim is found, whichever comes first. In the latter case, the delim character itself is also extracted.

Hervorhebung durch mich. Der Satz heißt:

Wenn man ignore macht und es sind nicht genug Zeichen zum ignorieren da, dann wird solange gewartet bis so viele Zeichen eingegeben wurden.

Wenn man ignore macht und man gibt das newline-Zeichen '\n' (entspricht Enter-Taste) als Trennzeichen an, dann wird (sofern vorhanden) zwar das nächste newline-Zeichen ingoriert (sofern vorhanden, ansonsten wird gewartet), das nützt aber herzlich wenig wenn der Benutzer zweimal Enter drückt, denn dann wird nur das erste Drücken verworfen.

Testprogramm:

#include<iostream>
using namespace std;

int main()
{
  int a,b;
  cout<<"A?"<<endl;
  cin>>a;
  cin.ignore(20);
  cout<<"B?"<<endl;
  cin>>b;
  cout<<"A: "<<a<<" B: "<<b<<endl;
}

Man achte darauf, dass nach der Abfrage von A das Programm stoppt und erstmal 20 Zeichen eingegeben werden müssen, bevor nach B gefragt wird.

Keine gute Idee:

Jo stimmt, mein Fehler.

Mit while(1) { peek(); if (good()) ignore(1); else break;} klappts auch nicht.
Härtere Nuß als ich dachte

SeppJ schrieb:

Keine gute Idee:

Jo stimmt, mein Fehler.

Mit while(1) { peek(); if (good()) ignore(1); else break;} klappts auch nicht.
Härtere Nuß als ich dachte

Wie schon gesagt, liegt dass daran, dass das einfach nicht vorgesehen ist. Das Modell der Eingabestreams ist nur eine lange Kette von Zeichen ohne jede Zusatzinformation. Die ganze technische Umsetzung mit eventuellen Pufferspeichern ist wegabstrahiert und mit Standardmitteln nicht zugänglich.

fflush (stdin)
Zumindest unter Windows löscht man damit den Eingabepuffer.
http://msdn.microsoft.com/en-us/library/9yky46tz(VS.71).aspx

> Wie schon gesagt, liegt dass daran, dass das einfach nicht vorgesehen ist.

Ich dachte, dafür gibt's std::basic_istream<char, std::char_traits<char>>::sync() .

streambuf * pbuf;
pbuf = cin.rdbuf();

int size = pbuf->in_avail();
cin.ignor(size);

Lichtlein

while(cin.get() =! '\n');

wird cin geleert, jedoch muss man wieder die Eingabetaste drücken.

streambuf * pbuf;
pbuf = cin.rdbuf();

int size = pbuf->in_avail();
cin.ignor(size);

Es verändert den Programmablauf leider irgendwie in keiner Weise.

Ich verweise gern noch mal auf sync(). Alle anderen Lösungen sind Quatsch.

Mit sync() funktioniert es aber auch nicht!
-->Test am Code

> Wie schon gesagt, liegt dass daran, dass das einfach nicht vorgesehen ist.

Ich dachte, dafür gibt's std::basic_istream<char, std::char_traits<char>>::sync() .

Sicher? Also zumindest bei mir funktioniert das damit nicht. Und die Beschreibung im Standard was sync() machen soll ist ziemlich unverständlich, jedoch würde ich es nicht so interpretieren, dass das geforderte Verhalten folgt.

Lichtlein schrieb:

Das kann man über den Stream Buffer machen.

streambuf * pbuf;
pbuf = cin.rdbuf();

int size = pbuf->in_avail();
cin.ignor(size);

Lichtlein

Leider liefert in_avail() nur die Mindestzahl der lieferbaren Zeichen. Bei den meisten Streamtypen ist dies immer 0 . Ansonsten würde es funktionieren.

Liefert bei mir:

$ > Hallo
$ > 1                   <--------- Das Newline-Zeichen
$ > 0

Und genau das soll es auch tun.

#include <iostream>
#include <string>

void out_in_avail(std::ostream& os, std::streambuf* buf) {
	os << buf->in_avail() << std::endl;
}

void iflush(std::istream& ios) {
	std::ostream os(ios.rdbuf());
	os.flush();
	ios.rdbuf(os.rdbuf());
}

int main() {
	std::string s1;
	std::cin >> s1;
	out_in_avail(std::cout, std::cin.rdbuf());
	iflush(std::cin);
	out_in_avail(std::cout, std::cin.rdbuf());
	std::cin.get();
}

Hallo
0
0

und es wird am Ende beim get trotzdem nicht gewartet. Getestet unter einem Linux, sowohl mit dem neuesten GCC als auch mit dem neuesten Intel-Compiler.

Und wie ich das sehe, ist dieses Verhalten auch durch den recht lax formulierten Standard gedeckt. Vermutlich gibt es auch gute Gründe dafür warum der Standard so formuliert ist und warum die Compilerhersteller sich nicht die Mühe geben es trotzdem besser zu machen, aber das würde zu ziemlich viel Spekulationen über Dinge führen mit denen ich mich nicht wirklich gut auskenne (Mein Wilder Tipp: Es hat wahrscheinlich was mit dem IO-Modell von POSIX zu tun).

// clear() setzt den Stream zurück
// ignore(std::cin.rdbuf()->in_avail()) ignoriert alle im eingabepuffer enthaltenen zeichen (Trick von IIRC@www.c-plusplus.net)
// ignore() ignoriert alle restlichen Zeichen (wird unter Linux benötigt)
// Dadurch wird keine Endlosschleife ausgelöst wenn eine leere Eingabe getätigt wurde

#ifdef __unix__
    #define Menue_clearBuffer() std::cin.clear(); std::cin.ignore(std::cin.rdbuf()->in_avail()); std::cin.ignore();
#else
    #ifdef _MSC_VER
        #define Menue_clearBuffer() std::cin.clear(); std::cin.ignore(std::cin.rdbuf()->in_avail());
    #else
        #define Menue_clearBuffer() std::cin.clear(); std::cin.ignore(std::cin.rdbuf()->in_avail()); std::cin.ignore();
    #endif
#endif

// cin/cout Helper funktionen um den Quellcode übersichtlicher zu gestalten
#define Menue_newLine() std::cout << std::endl;
#define Menue_readLine(label,variable) std::cout << label << ": "; std::cin >> variable; Menue_clearBuffer();
#define Menue_printLine(output) std::cout << output; Menue_newLine();
#define Menue_printTabbedLine(_left, _right, _space) std::cout << std::setw(_space) << std::left << _left << _right; Menue_newLine();
#define Menue_printSeperator(character) for(int __i = 0; __i < 79; __i++) std::cout << character; Menue_newLine()
#define Menue_inputWait() Menue_newLine(); Menue_printLine("Naechste Eingabe erst in 2 Sekunden moeglich."); Sleep(2000);
#define Menue_addCommandCall(command, function) if(input == command){ function; continue; }