Okay, lets enhance the asterisk triangle program so that it only accepts numeric input. That is, if a user types in a non numeric then the program should re-request correct input until a number is entered.

Remove these lines:

and replace with:

An understanding of the cin object is required for this snippet. As the variable rows is defined as an integer type, attempting to assign a non integer to this type will set the cin objects error flag to true. The expression (cin >> rows) returns a boolean value (true or false) relating to the error state of the expression. We can include this error state as a conditional part of a while loop. while loops only continue whilst a condition is true and therefore in this instance we need to check for when not true which means false. Confusing, I know.

Compile and run the program. Enter a single non numeric character. You'll now note that the program asks you to input only an integer. Entering an integer is the only way to exit the loop and continue through to the end.

Here is another form of the cin use. This form, cin.get(arrayname, size) is similar to cin.getline(arrayname, size) discussed previously. This form cin.get(arrayname, size) reads an entire line from the keyboard terminated by the 'ENTER' key BUT leaves the newline '\n' character in the input queue. Why it does this I'm not sure and why have such a function which for all intents and purposes is the same as the cin.getline(...) method, I'm not sure either.

Some things to be aware of

If there is an existing newline in the input buffer prior to calling cin.get(arrayname,20);, this form will not accept it, remember it leaves the newline character in the input buffer. The point here is that an error state is created in the cin object; the failbit flag is set to true. No further cin operations are permitted whilst the error flag is set to true. In order to remove the error flag this command cin.clear(); is required. It resets the cin error state back to false.

The above is not applicable if the input buffer contains normal characters ending with a newline character prior to calling the cin.get(arrayname, 20);. What occurs in this instance is that the errant characters or characters already in the input buffer as a result of a previous cin operation are assigned or allocated to the character array arrayname. The newline character is left in the input buffer.

Another situation arises whereby the user types in more characters than is specified by the size parameter of the cin function. No error state is recorded and the character array arrayname only receives the number of specified characters. The remaining characters are left in the input buffer.

The following code snippet should explain the various workings of this topic. The code, as is, will create an error state, simply uncomment the line after cin.get(line, 20);.

Play with the program. You will note that if you input more than a single character for the first input, that it adversely affects the following cin methods. I'll deal with flushing the input stream/buffer/queue in a separate article but in the interim the exit routine should be a clue as to how to flush the input buffer.

This is the basic form of retrieving characters from the keyboard. The characters typed at the keyboard are sent to the input stream terminated by the 'ENTER' key. Once in the input stream they are allocated or assigned to the receiving variable, from the above example, getdata. What this means is that prior to the 'ENTER' key being pressed there is no control or checking of the characters typed.

So far, so good but there is a catch, well quite a few actually and we'll ease into them.

Firstly, this form only reads alphanumeric characters up until the first white space, tab, null or newline ('ENTER' key) character. (I'm not too sure how to type in a 'null' character, maybe leave that one for later)

Lets assume a user typed, this is really awkward stuff [ENTER]

From our example at the top of the page cin >> getdata; only the word this would be assigned (or attempted to be assigned/allocated) to getdata. This is because cin only accepted characters up until the first whitespace or only retrieves a series of characters (words) not containing spaces. The remaining words is really awkward stuff [ENTER] are left in the input stream. This is the source of many problems as the very next cin >> getwhatever; will retrieve the next word from the input stream, in our case, is. Still, the input stream now contains really awkward stuff [ENTER]

In general, if a line of text, which includes spaces and/or tabs, needs to be input, do not use this form of the cin object. Yes, there are other ways and there are ways to deal with this problem if using this form of the cin object and they will be the subject of another entry.

Returning to our example at hand cin >> getdata; there are other factors that come into play. The main 'other factor' is the data type of the variable getdata. To this point that hasn't been considered but as you'll soon see it plays an important and significant part of this whole cin >> getdata; saga.

Here is a more complete snippet of code in how a basic 'get data from the keyboard' is implemented.

The above code snippet, if applied to our example above, would not throw any errors as the variable getdata is actually a char array having the ability to store 20 characters (enough for our purposes). Those characters being alphanumeric, which means numbers or letters or both. We still have the same issue that only the first word is received and assigned to the variable getdata.

Now the fun starts. Let's change the data type of the variable getdata from being an array to just a plain old char variable. Our snippet of code becomes:

A line of text, including spaces and/or tabs, can still be entered, ending up in the input stream. The result is that only the first character of the input stream will be assigned to the variable getdata. The input stream still contains the user entered text, minus the first character. This behaviour occurred as the data type of the receiving variable getdata is of type char. This means it can only hold or store a single character (digit or letter).

Whether we need to receive only a single character or a word, if the input stream still contains characters then the next cin >> getwhatever; operation will retrieve them. This might not be the expected or intended result.

Now the real fun starts. What if the data type of the receiving variable is of type integer. It's only expecting numbers not letters. Here's our snippet of code:

If a user types in abc where is that to be stored? The variable getdata can't receive it as it can only hold an integer (a number). What occurs is that the cin object throws an error and sets it's failbit to 'true'. The other error bit of the cin object is the eofbit which is an 'End of File' (EOF) error. In the context of this discussion the eofbit is not relevant.

The consequences of the cin object throwing an error (failbit or eofbit) is that no further calls to the cin object has any effect, they are ignored. This means if your program does in fact make use of the cin object after an error, it simply won't work as intended.

To clear the error state of the cin object issue this command:

This clears the error state and further processing of cin object is allowed.

As you've probably guessed there may still be characters remaining in the input stream which need to be dealt with as well. On this point, the newline (\n) character 'ENTER' remains in the input queue/stream even upon successful keyboard data input. For this discussion that's not overly relevant as the very next cin object disregards any newline character if it's the first in the input queue/stream. This aspect becomes relevant when other forms of the cin object follow the basic form of cin >> getdata;. This will be the subject of another article.

How do we trap for incorrect data input? How do we know when to clear the cin object's error state? How do we know....? Well these are all valid questions and will be answered in the next article.

Related article : Asterisk Triangle Program in which trapping incorrect data input and restricting input to a valid numeric range is discussed.