while (cin >> c >> d){
		if(!(cin >> c >> d)) 
			error("Please put an integer \n");

do
{
    c = getc();
} while(c > ASCII-Zahlen-Anfang && c < ASCII-Zahlen-Ende);

int c,d;
cin >> c >> d;
if (int != c || int != d) error("Das ist kein Integer");

Ich weiß das der Code falsch ist nur so kann ich sagen was ich meine.

kannst du das erklären ?

while(!(cin>>i))
{
 cin.clear();
 // Fehlermeldung anzeigen;
 cin.ignore(/*eines oder alle Zeichen*/);
}

int c,d;
while (!(cin>>c || cin>>d)){
	 cin.clear(); 
             error ("Please put an integer \n");
	 cin.ignore('!');
}

Da es zwei Integer überprüfen soll. Doch irgendwie will das nicht. Wenn ich ein Double eingebe beendet sich das Programm.

#include <conio.h>
//...
int a, b;
char token;
cout << "Gebe einen Term ein: (zb 2+6) ";
if(!(cin >> a)) {
    cerr << "Fehler bei der Eingabe!\n";
    _getch();
    return -1;
}
cin >> token;
if(!(cin >> b)) {
    cerr << "Fehler bei der Eingabe!\n";
    _getch();
    return -1;
}
cout << a << token << b;
//usw.

Nur beendet sich da das Prog, die Variante mit cin.ignore() hat bei mir nie geklappt. Was ist daran denn auch so schlimm? Mich stört das eigentlich nicht.
Würde mich aber auch interessieren ob hier endlich mal eine funktionierende Lösung gepostet wird.

Ich habe es so geschrieben:

int c,d;
while (!(cin>>c || cin>>d)){
	 cin.clear(); 
             error ("Please put an integer \n");
	 cin.ignore('!');
}

Da es zwei Integer überprüfen soll. Doch irgendwie will das nicht. Wenn ich ein Double eingebe beendet sich das Programm.

Kleines Fallbeispiel - du gibst folgendes ein: 3 4.23
Resultat: alles ok - c hat den Wert 3 und d hat den Wert 4

Anderes Beispiel - Eingabe: 3 .3f
Resultat: c hat den Wert 3 aber d konnte nicht eingelesen werden. Da du aber geschrieben hast while (!(cin>>c || cin>>d)) wird die while-Schleife abgebrochen. Warum? cin>>c wird als wahr ausgewertet. Bei einem logischen Oder reicht es wenn einer der Operanden wahr ist um den Ausdruck als wahr auszuwerten. Demzufolge ist (cin>>c || cin>>d) nun also wahr. Du negierst das ganze dann noch --> es wird false. Somit wird die while-Schleife nicht durchlaufen.

Was du möchtest ist etwas in der Art (wie SeppJ ja bereits zeigte):

int a,b;
while (!(std::cin>>a>>b)) {
	std::cout<<"\nFehler - bitte neu eingeben\n";
	std::cin.clear();
	std::cin.ignore(std::cin.rdbuf()->in_avail());
}

wobei ich meine mich erinnern zu können, dass SeppJ mal erwähnte, man soll sich nicht auf das letzte statement verlassen. Müsste ich mir nochmal genauer ansehen warum und wie etc.

int a,b;
while (!(std::cin>>a>>b)) {
    std::cout<<"\nFehler - bitte neu eingeben\n";
    std::cin.clear();
    std::cin.ignore(std::cin.rdbuf()->in_avail());
}

Und ich was falsches eingebe (zb einen Buchstaben), dann erscheint eine Endlosschleife mit "\nFehler - bitte neu eingeben\n"..

#include <limits>
    //..code
    if(!cin) {
        cerr << "Fehler bei der Eingabe! Nochmal eingeben!\n";
        cin.clear();
        cin.ignore(numeric_limits<int>::max(), '\n');
        continue;
    }

Aber was machen diese beiden Zeilen hier?

cin.clear();
cin.ignore(numeric_limits<int>::max(), '\n');

clear:
http://www.cplusplus.com/reference/iostream/ios/clear/

ignore:
http://www.cplusplus.com/reference/iostream/istream/ignore/

#include "stdafx.h"
#include "std_lib_facilities.h"

void rand_in_range(int a,int b){
     cout << randint(a - b) + b << endl;
}

void calc(){
	cout << "Please enter 2 integer to generate a number\n";
	cout << "To exit enter any char\n";
    int c,d;
	while (cin >> c >> d){
        if (!(cin)){
		cout << "Error in the Input! Re-enter!\n"; 
        cin.clear(); 
        cin.ignore(numeric_limits<int>::max(), '\n'); 
        continue;} 
		else{
		rand_in_range(c,d);}
        }
}

int main()
try{
	calc();

	keep_window_open();
    return 0;
}
catch (runtime_error e) {	
	cout << e.what() << '\n';
	keep_window_open("~");	
}
catch (...) {	
	cout << "exiting\n";
	keep_window_open("~");	
}

Doch wenn ich einen Buchstaben oder Double eingebe beendet sich das Programm.

Das ist der Code mit dem ich Arbeite.

//..snip..
    int c,d;
	while (cin >> c >> d){        // <-------- 1
        if (!(cin)){              // <-------- 2
		cout << "Error in the Input! Re-enter!\n"; 
        cin.clear(); 
        cin.ignore(numeric_limits<int>::max(), '\n'); 
        continue;} 
		else
		rand_in_range(c,d);
        }
//..snap..

Doch wenn ich einen Buchstaben oder Double eingebe beendet sich das Programm.

zu 1.) Nur wenn die Bedingung wahr ist - wird die Schleife durchlaufen, und zwar solange sie wahr ist. Der Operator >> mit einem stream als linksseitigem Operanden liefert eine Referenz dieses Streams zurück. Der Stream verwaltet intern Zustandsflags die angeben, in welchem Zustand sich der stream befindet. Wenn alles ok ist ist dieser Wert 0 was dem goodbit entspricht. Soll ein int eingelesen werden aber du lieferst beispielsweise einen Buchstaben, so wird das failbit gesetzt.
Testest du nun den stream in einer Bedingung auf einen Wahrheitswert wird überprüft, welche flags gesetzt sind. Wenn der stream in Ordnung ist (goodbit) wird true geliefert, anderenfalls false.

Lange Rede kurzer Sinn: Wenn du while (cin>>c>>d) schreibst und beispielsweise einen Buchstaben eingibst, wird das failbit gesetzt, vom operator>> per return-by-reference der stream zurückgegeben, dieser dann auf Wahrheitswert getestet und dieser liefert dann aufgrund des gesetzten failbits den Wert false.
Resultat: die while-Schleife wird nicht durchlaufen und somit auch nicht deine zweite Zeile (2) if(!(cin)).