I am writing a program where I place a check like this:
int small;
cout<<"Small Pizza Price: ";
cin>>small;
while(!isdigit(small)){
cout<<"Small Pizza Price: ";
cin>>small;
}
but when the user inputs a value other than integer the program just break. I want to place a check where the user only inputs an integer value.
You need to check if extraction of the int succeeded, and if it didn't, possibly clear() the fail state of the stream. cin.eof() and cin.bad() can be used to check if the stream is in an unrecoverable state or you can combine them both with std::ios::badbit | std::ios::eofbit and check if std::cin.rdstate() has any of those bits set.
Checking if extraction succeeds is usually done by checking the stream's state in boolean context, like so:
if(!std::cin) { // or if(not std::cin) "not" is an alternative to "!"
// the stream is in a failed state
}
When you do formatted extraction from a stream with std::cin >> small, operator>> will return a reference to the stream, which makes extracting and then checking the state easy:
if(not(std::cin >> small)) { /* extraction failed */ }
Full example:
#include <iostream>
#include <limits> // std::numeric_limits
int main() {
int small;
while(std::cout << "Small Pizza Price: " && not(std::cin >> small)) {
// if(std::cin.eof() || std::cin.bad()) { or:
if(std::cin.rdstate() & (std::ios::badbit | std::ios::eofbit)) {
std::cout << "aborted\n";
return 1;
}
std::cout << "please enter a valid price\n";
std::cin.clear(); // clear the fail state
// remove any lingering characters in the istream:
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
// small read successfully
}
You do not show in your source the declaration of the variable, small. If it is a string, I am assume that the extraction operator will parse the stream up until it encounters whitespace. If you were to declare the "small" variable as an integer or float like value, than the stream extraction operator would attempt to parse an integer from the stream using the locale currently imbued in the stream. If that attempt to parse the stream fails, then the stream's error flag will be set and you can test it using the not "!" operator.
Assuming that you want the program to only take integer value for variable int small, these are some points I would want to point out.
When a char value is passed instead of int to the variable int small, the program shows undefined behavior/falls in infinite loop. What happens is cin goes into a failed state and that makes it ignore further calls to it, till the error flag and buffer are reset.
isdigit() only takes a single char, returns positive number if it holds a digit(char c='7'). If char doesn't hold a digit, function returns 0.
possible solution:
To check whether valid input type(in this case int) is taken via cin>>, we can check return value of cin. If input is invalid, cin will return false value and vice versa.
When invalid(non-digit in this case) input is taken instead of valid(int) we have to clear the cin and input buffer for further input. To do that, we can use:
cin.clear();
cin.ignore(100, '\n');//clear next 100 value from input buffer
void get_Untill_Int(int* pInput)//keep taking input untill input is `int or float`
{
cin>> *pInput;
/*-----------check input validation----------------*/
while (!cin)
{
cin.clear();
cin.ignore(100, '\n');
cout<<"Invalid Input Type.\nEnter again: ";
cin >>*pInput;
}
/*-----------checked input validation-------------*/
}
Final program
int small;
cout<<"Small Pizza Price: ";
get_Untill_Int(&small);
You can do a check while your variable is undefinde you're going to ask an input from the user like :
int small;
cout<<"Small Pizza Price: ";
while(small == NULL){
cin>>small;
}
Since you have defined your small as an int, it will repeat to ask until it gets an valid int as input
