double MASSE;

while ( true )
    {
      cout << "Bitte Eingabe Masse" << endl;
      fflush (stdin);
      cin >> MASSE;
      fflush (stdin);
      if ( MASSE >= 10 ) break;
      else
      {
        cout << "Dies ist keine gueltige Eingabe!" << endl;
	fflush (stdin);
      }
    }

Bei Eingabe von z.B. 3 ist alles i.O. - es wird erneut abgefragt.
Bei Eingabe von z.B. 13 ist alles i.O. - es geht weiter.
Wenn ich zuerst 3 eingebe und dann bei der erneuten Aufforderung zur Eingabe diesmal z.B. df eingebe, bin ich plötzlich in einer Endlosschleife gefangen.
Wenn ich z.B. df oder f sofort eingebe, geht es weiter obwohl das natürlich nicht korrekt ist (double-Variable).
Wie kann ich diese Eingabe narrensicher machen?? Helft mir bitte mal weiter!

cin >> MASSE;
if(cin.fail()) // fail() = input/output Fehler, zB bei char in int eingelesen
{
    cin.clear(); // Fehlerflags löschen
    std::string temp = "";
    getline(cin,temp); // Müll ausm Buffer weglesen
    // raus break, return sonstwas
}

#include <iostream>
using namespace std;
 
int main()
{	
    double dMasse = 10;
	cin.clear();
	while ( dMasse < 0 || dMasse >= 10 ) 
    { 
      cout << "Bitte Eingabe Masse" << endl; 
         cin >> dMasse; 
   } 
 return 0;
}

wird nicht hinhauen bei ner eingabe von zeichen , da bist du wieder in endlosschleife.. versuch die eingabe lieber per string und wandel das um,
strings lassen sich besser kontrollieren
du kannst ja mal anschauen was nach der fehlerhaften eingabe bei den Fehlerstromflags passiert

cout << "After a bad input operation:"
		<< "\ncin.rdstate(): " << cin.rdstate()
		<< "\n cin.eof(): " << cin.eof()
		<< "\n cin.fail(): " << cin.fail()
		<< "\n cin.bad(): " << cin.bad()
		<< "\n cin.good(): " << cin.good() << endl << endl;
	cin.clear(); // clear stream
	// display results of cin functions after clearing cin
	cout << "After cin.clear()" << "\ncin.fail(): " << cin.fail()
		<< "\ncin.good(): " << cin.good() << endl;

wenn das failbit gesetzt ist kommt es zur endlosschleife. egal ob da noch ein cin kommt oder net.

Also wenn ihr noch mehr code habt, nur zu, werde dann morgen mal die für mich plausibelsten Lösungen testen, danke!

wird nicht hinhauen bei ner eingabe von zeichen , da bist du wieder in endlosschleife.. versuch die eingabe lieber per string und wandel das um,
strings lassen sich besser kontrollieren
du kannst ja mal anschauen was nach der fehlerhaften eingabe bei den Fehlerstromflags passiert

Stimmt, daher hab ich es lieber gleich wieder rausgenommen, damit das niemand unnötigerweise kopiert und ausprobiert.

Hab mir jetzt eine Lösung zurechtgebastelt, die deiner Beschreibung entspricht und bombensicher ist.

#include <iostream>
using namespace std;

int main()
{
	double dMasse;
	char buf[80];
	char *err_ptr = NULL;

	do
	{
		err_ptr = NULL;
		cout << "Bitte geben sie die Masse ein: " << endl; 
        cin.getline( buf, 80 );
		dMasse = strtod( buf, &err_ptr );
	}
	while ( *err_ptr != '\0' );

   return 0;
}

Edit: '}' Klammer vergessen
Edit: Bombensicher ist das doch noch nicht, nämlich wenn man mehr als 80 Zeichen eingibt. Dann wird die Eingabe ja abgeschnitten und man erhält eine kleinere Zahl als eingegeben. Shit.

bool readDouble(double& value)
{
	std::string line;
	std::getline(std::cin, line);
	std::istringstream iss(line);

	if(iss >> value)
	{
		iss >> std::ws; // Leerzeichen verschlucken
		return iss.eof();
	}

	return false;
}

int main(){
    double d=0.0;
    do{
        while(!(cin>>d)){
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(),'\n'); //danke an David_pb (siehe unten)
        }
    }while(d>0.0 && d<10.0);

@proggingmania: wenn man enter drückt wird die schleife schon verlassen.

Peinlich peinlich

Meine gängige/gebräuchlische Lösung interessiert wohl niemanden ...

Klar, immer her damit.
Edit: Das ist keine Lösung, nur ein Fragment

Würde folgendes funktionnieren?

int main(){
    double d=0;
    do(){
        while(!(cin>>d)){
            cin.clear();
            cin.ignore(32000,'\n); //wie war das mit den numeric_limits<stream_buf>() nochmal? Ka wie das richtig war...
        }
    }while(d<10);

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

proggingmania:

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

// funktioniert  

int main() 

{ 

    double MASSE; 
    string eingabe; 
    char *err_ptr = NULL; 

    do 
    { 
        err_ptr = NULL; 
        cout << "Bitte geben sie die Masse ein (Wert >= 10):  " << endl; 
        cin >> eingabe; 
        MASSE = strtod( eingabe.c_str(), &err_ptr ); 
    } 
    while (  *err_ptr != '\0' || ( MASSE < 10) ); 

    cout << "Sie haben bombensicher einen Wert >= 10 " 
        "eingegeben: " << MASSE << endl; 

   return 0; 
}

KasF:

// funktioniert

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

int main ()
{

  double MASSE;

while ( true )
{
cout << "Bitte geben sie die Masse ein:  " << endl; 
cin >> MASSE; 
if(cin.fail()) // fail() = input/output Fehler, zB bei char in int eingelesen 
{ 
    cout << "Eingabe einer Zahl >= 10 erforderlich!" << endl; 
    cin.clear();
    fflush (stdin);
    continue;
}   

if ( MASSE < 10 ) cout << "Masse zu klein!" << endl;
if ( MASSE >= 10 ) cout << "Eingabe akzeptiert!" << endl;
if ( MASSE >= 10 ) break;

}
cout << "Masse = " << MASSE << endl;
return 0;

}

fflush (stdin);

Würde folgendes funktionnieren?

int main(){
    double d=0.0;
    do{
        while(!(cin>>d)){
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(),'\n'); //danke an David_pb (siehe unten)
        }
    }while(d>0.0 && d<10.0);

Jetzt muss ich mich doch mal selbst zitieren: warum ist diese (für mich pers. einfacherer Variante) nicht praktikabel? (Frage zum eigenen Verständnis)

EDIT: nochn Syntaxfehler drin gehabt...

Jetzt muss ich mich doch mal selbst zitieren: warum ist diese (für mich pers. einfacherer Variante) nicht praktikabel? (Frage zum eigenen Verständnis)

frag ich mich auch :p.

wahrscheinlich ist es einfach schöner, zuerst ne endlosschleife zu programmieren und dann mit break rauszuspringen, anstatt ne anständige abbruchbedingung zu nutzen .

Vielleicht will man auch unbedingt nen c++ stream mit c mitteln clearen, um damit je nach standardbibliothek fast unmöglich zu findende fehler zu produzieren ;).

Vielleicht liegts auch einfach an dem Syntaxfehler. Hinter do kommen keine "()".

so funktionierts bei mir perfekt:

double d=0.0;
do
{
    cout<<"Bitte geben sie eine Zahl >10 ein: ";
    while(!(cin>>d))
    {
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(),'\n');
        cout<<"\nFehlerhafte eingabe! Bitte geben sie eine Zahl >10 ein: ";
    }
}
while(d<10.0);
cout<<"eingabe:"<<d;

Mit welchen Header-Dateien?
Nicht jeder ist ein solcher Crack wie du!
schreib doch mal nen vollständigen code
max() ist unbekannt...
wenn ihr einfach nen vollständigen code schreiben würdet, könnten sich die nicht-profis auch mitunterhalten

...
Jetzt muss ich mich doch mal selbst zitieren: warum ist diese (für mich pers. einfacherer Variante) nicht praktikabel? (Frage zum eigenen Verständnis)
...

1. Weil sie fehlerhaft ist und sich nicht kompilieren lässt.
2. Als C++ Einsteiger weiß man nicht, das man für:
   cin.ignore(numeric_limits<streamsize>::max(),'\n');
   eine extra Headerdatei einbinden muss.

Daher nimmt man einfach die Lösung, wo man die Fehler zunächst intuitiv schneller beseitigen kann, oder am besten erst gar keine vorhanden sind.

Wenn man nun die von otze verbesserte Version dahernimmt und <limits> mit einbindet, funktioniert das in der Tat einwandfrei.
Darum gefällt mir persönlich diese Version auch am besten, weil sie im Gegensatz zu meiner ohne die Fehlerprüfung über strtod auskommt.
Gruß, p.

Mit welchen Header-Dateien?
Nicht jeder ist ein solcher Crack wie du!
schreib doch mal nen vollständigen code
max() ist unbekannt...
wenn ihr einfach nen vollständigen code schreiben würdet, könnten sich die nicht-profis auch mitunterhalten

google ist dein Freund :D. erster treffer numeric_limits: http://www.cpp-tutor.de/cpp/le13/le13_03.htm. Und schon kannst du wieder mitreden.
Du kannst immer davon ausgehen, dass alles was hier gesagt wird,standard c++ ist(ausser, es wird ausdrücklich gesagt, dass man fremdcode wie boost nutzt). Dann reicht googlen nach dem unbekannten wort,zb "c++ numeric_limits", und man weis wieder worum es geht(wenn man nicht weis, was ein code macht ist es eh nicht sinnvoll ihn einfach zu kopieren. Das ist viel zu fehleranfällig und man ist aufgeschmissen, wenn man was ändern will, also muss man im zweifelsfall eh googlen )

header wurde ja jetzt genannt, läuft mit iostream und limits

Ich denke mal, die obige Zeile kann man rausschmeissen.
Dann müsste man noch prüfen, ob korrekt konvertiert wurde.
Grund:
Wenn zu viele Zeichen eingegeben werden, dann wird die while-Schleife beendet und in der Variable d steht #inf.

Ich darf an dieser Stelle in aller Bescheidenheit darauf hinweisen, das diese Gegebenheit bei meiner Version abgefangen wird!