#include <iostream>
#include <sstream>
#include <fstream>
#include <stdexcept>
using namespace std;
int main(void)
{
   int ival;
   while(cin >> ival, !cin.eof())
   {
      if(cin.fail())
      {
         cerr << "BAD DATA";
         cin.clear(istream::failbit);
         continue;   
      }                
   }    
}

Irgendwas ist da ncoh falsch...-.-

cya
David

Du musst das "nicht richtig Interpretierbare" auch aus cin "löschen". So liest er immer wieder dasselbe Token. => cin.ignore()

"continue" ist in diesem Beispiel natürlich überflüssig, aber vermutlich kommt bei Dir nach dem if-Block noch eine Verarbeitung, die Du damit überspringen möchtest (auch da würde ich kein continue machen, aber das ist wohl Geschmaxache).

Gruß,

Simon2.

Danke!
Werds mal ausprobieren, wenn mein PC wieder geht- meine Festplatte ist nämlich soeben abgefreckelt^^

Wie kam's? Hast du die Bedeutung von "undefined behaviour" unterschätzt *scnr*

Geht aber leider immer noch nicht so:

#include <iostream> 
#include <sstream> 
#include <fstream> 
#include <stdexcept> 
using namespace std; 
int main(void) 
{ 
   int ival; 
   while(cin >> ival, !cin.eof()) 
   { 
      if(cin.fail()) 
      { 
         cerr << "BAD DATA"; 
         cin.clear(istream::failbit); 
         cin.ignore();
         continue; 
      }                 
   }     
}

Geht aber leider immer noch nicht so:

#include <iostream> 
#include <sstream> 
#include <fstream> 
#include <stdexcept> 
using namespace std; 
int main(void) 
{ 
   int ival; 
   while(cin >> ival, !cin.eof()) 
   { 
      if(cin.fail()) 
      { 
         cerr << "BAD DATA"; 
         cin.clear(istream::failbit); 
         cin.ignore();
         continue; 
      }                 
   }     
}

Hmm, sollte aber eigentlich passen.

Wobei, ignore() ohne weitere Parameter verwirft genau ein Zeichen der Eingabe - d.h. wenn du viel Müll eingegeben hast, bekommst du entsprechend viele "BAD DATA" Meldungen. Versuch' mal, einen etwas größeren Abschnitt zu verwerfen: cin.ignore(numeric_limits<size_t>::max(),'\n'); (braucht noch ein '#include <limits>).

... so geht das ^^ Guck dir mal den operator! von std::istream an ... evtl. dann noch mal gucken was bei std::istream::clear und was bei std::istream::ignore genau passiert

Also der folgende Code ergibt bei mir das selbe:

#include <iostream> 
#include <sstream> 
#include <fstream> 
#include <stdexcept> 
#include <limits>
using namespace std; 
int main(void) 
{ 
   int ival; 
   while(cin >> ival, !cin.eof()) 
   { 
      if(cin.fail()) 
      { 
         cerr << "BAD DATA"; 
         cin.clear(istream::failbit); 
         cin.ignore(numeric_limits<size_t>::max(),'\n'); 
         continue; 
      }                 
   }     
}

(D)Evils Code funktioniert zwar, aber er ist einfach ein ganz anderer Weg zur Lösung.
Ich würde aber am liebsten den Weg zur Lösung verstehen, der im Buch gesagt wird.*
Ich hab als Compiler DEV C++... vielleicht liegts ja dadran

cya
David

*Also so mit Failbits und Statusflags das Lösen.

Weiterhin: ignore erwartet einen Wert vom Typ streamsize. streamsize ist ein *signed* Integertype. Du übergibst aber numeric_limits<size_t>::max(), wobei size_t ein *unsigned* Integertype ist. D.h. bei der Umwandlung kann -1 herauskommen und wenn deine Implementation z.B. das Argument auf > 0 vergleicht, passiert hier gar nix.

Korrekt wäre:
a) clear()
b) Verwendung von std::numeric_limitsstd::streamsize::max()

#include <iostream>
#include <sstream>
#include <fstream>
#include <stdexcept>
#include <limits>
using namespace std;
int main(void)
{
   int ival;
   while(cin >> ival, !cin.eof())
   {
      if(cin.fail())
      {
         cerr << "BAD DATA";
         cin.clear();
				 cin.ignore(numeric_limits<std::streamsize>::max(),'\n');
         continue;
      }                
   }    
}

So wird ein Schuh draus.

Aber noch eine Frage:

EOF heißt meines Wissens 'End Of File'.

Was genau hat dieser Header der schleife für einen Sinn?
Wann wird das EOF-Bit im Stream gesetzt?

cya
David

THX

cya
David

Ich würde es eher so lösen:

while(true)//wird später per break verlassen
{
    cin >> ival
    if(cin.fail())
    {
        cerr << "BAD DATA";
        cin.clear();
        char test = cin.get()
        if(test=='q') break;

        cin.ignore(numeric_limits<std::streamsize>::max(),'\n');
        continue;
    }
}

Gruß Tobi.

Wenn der User die Eingaben mit Strg+Z abbricht, ist cin nämlich anschließend "tot" (und ich bin mir auch nicht sicher, ob du die Konsole aus dem Programm heraus reaktivieren kannst)

Doch, man kann den Toten wieder zum Leben erwecken:

#include<iostream>

struct StreamDefi{
  void brizzl(std::ios& io, int voltage) {
    io.clear();
    ++voltage;  //supress warnings about unused variables
  }
}

using std::cin;
using std::cout;

int main() {
  for (char c; cin; cin.get(c)) cout << c;
  if (cin.eof()) {
    StreamDefi Defibrilator;
    Defibrilator.brizzl(cin, 240); //BRZZL cin lebt wieder!
  }
}

*scnr*

(btw, was soll das '++voltage' bringen?)