C++ RSS C++ RSS

How do I flush the input stream?

Please support our C++ advertiser: Intel Parallel Studio Home
Closed Thread
1 2 Last »

•
•
Join Date: Sep 2004
Posts: 7,566
Reputation: Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute 
Solved Threads: 705
Team Colleague
Narue's Avatar
Narue Narue is offline Offline
Code Goddess

How do I flush the input stream?

 
4
  #1
Sep 20th, 2007
When you want to remove extraneous characters from an input stream in C++, it's usually because you mixed formatted and unformatted input methods. The formatted method would leave a newline in the stream and the unformatted method would consume it and terminate successfully, but fail completely to do what you wanted.
C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2.  
  3. int main()
  4. {
  5.   std::cout<<"Enter the letter A: ";
  6.   std::cin.get();
  7.   std::cout<<"Enter the letter B: ";
  8.   std::cin.get();
  9.   std::cout<<"Too late, you can't type anymore\n";
  10. }
Often this question stems from another question, which is how to pause a program before it terminates. Using cin.get() works only when there are no characters left in the stream. The instant you throw a cin>> foo; in the code, suddenly the solution fails. You need to clear out any leftover characters from the stream before it'll work again.

So how do you fix the problem? The good news is that unless you want to get picky, it's as simple as a loop:
C++ Syntax (Toggle Plain Text) 
  1. #include <istream>
  2.  
  3. void ignore_line ( std::istream& in )
  4. {
  5.   char ch;
  6.  
  7.   while ( in.get ( ch ) && ch != '\n' )
  8.     ;
  9. }
This loop simply reads characters until end-of-file or a newline is read. It's generally assumed that interactive input in C++ is line-oriented and you're guaranteed to have a clean buffer after reading a newline. While that's not true (input doesn't have to be line-oriented), it's wide spread enough that we can assume it for the purposes of this thread.

So what's wrong with this approach? Nothing. In fact, this is about as good as it gets unless you want to dig down and fix the subtle problems. But before we look at the problems, here's an alternative solution that does the same thing in a different way:
C++ Syntax (Toggle Plain Text) 
  1. #include <ios>
  2. #include <istream>
  3. #include <limits>
  4.  
  5. void ignore_line ( std::istream& in )
  6. {
  7.   in.ignore ( std::numeric_limits<std::streamsize>::max(), '\n' );
  8. }
The ignore member function of std::istream will read and discard up to N characters or until a delimiter. In the above example, N is represented by the largest value of the streamsize data type, and the delimiter is a newline. It works equally well with just a large value (80 is common):
C++ Syntax (Toggle Plain Text) 
  1. in.ignore ( 80, '\n' );
However, the streamsize data type is more likely to be an accurate representation of the size of the buffer that the stream is using, and it's more likely to work all of the time. This is the solution that I recommend.

[author's note]
If you don't care about the advanced stuff and the above solves your problem, you can stop reading here.
[/author's note]

So what's wrong with this? There are two notable problems. The first is easy to fix, and it stems from the fact that istream isn't very flexible. istream is actually a typedef for basic_istream<char>. If you want a wide stream to work with ignore_line, you're SOL with istream. So the trick is to use basic_istream<> instead:
C++ Syntax (Toggle Plain Text) 
  1. #include <ios>
  2. #include <istream>
  3. #include <limits>
  4.  
  5. template <typename CharT>
  6. void ignore_line ( std::basic_istream<CharT>& in )
  7. {
  8.   in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
  9. }
Now ignore_line is a template function that will derive the type of characters that the stream contains from the first argument. You can pass any stream that derives from or specializes basic_istream, and the problem is gone. Instead of just '\n', it's a good idea to use widen on the literal so that it will be properly converted to a wider type if necessary. Nice and easy.

The second problem is harder. Much harder. It's harder because standard iostreams seem to block your way at every turn with lack of portability or undesired features. In fact, it's impossible to completely fix the problem. The problem is that the behavior is different depending on the contents of the stream. For example:
C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2. #include <ios>
  3. #include <istream>
  4. #include <limits>
  5.  
  6. template <typename CharT>
  7. void ignore_line ( std::basic_istream<CharT>& in )
  8. {
  9.   in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
  10. }
  11.  
  12. int main()
  13. {
  14.   std::cout<<"First input: ";
  15.   std::cin.get();
  16.   std::cout<<"Clearing cin.\n";
  17.   std::cin.clear();
  18.   ignore_line ( std::cin );
  19.   std::cout<<"All done.\n";
  20. }
Run this program three times:

Input: "asdf"
Output: The program finishes without any more input from you.

Input: Just hit Enter
Output: The program waits for you to hit Enter one more time.

Input: Signal EOF
Output: The program waits for you to hit Enter one more time.

The problem is that the stream is empty. If you hit Enter immediately, a newline is placed on the stream and consumed by cin.get. Likewise with signaling EOF. At that point there's nothing left in the stream and cin.ignore stops everything until you type more characters. This is because cin.ignore is a blocking read. If there's nothing to read, it waits.

What we'd like it to do is not block for any of those three cases. The good news is that the iostream library supports some possible solutions. The bad news is that these are dead ends. Here are two common ones:

The sync member function
The istream class supports a member function called sync. Why it has such a function is under debate, because nobody can agree on what it should be doing. Even Bjarne Stroustrup himself incorrectly stated that it discards all characters in the stream:
C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2.  
  3. int main()
  4. {
  5.   std::cout<<"First input: ";
  6.   std::cin.get();
  7.   std::cout<<"Clearing cin.\n";
  8.   std::cin.clear();
  9.   std::cin.sync();
  10.   std::cout<<"All done.\n";
  11. }
When this works, it works beautifully. The bad news is that the C++ standard doesn't require sync to do anything like discarding extraneous characters. This solution is non-portable.

The in_avail member function
The next step is to look at the in_avail member function of istream's stream buffer. At first glance it looks like this member function will tell you how many characters are in the stream, and if it returns 0, you can refrain from calling ignore:
C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2. #include <ios>
  3. #include <istream>
  4. #include <limits>
  5.  
  6. template <typename CharT>
  7. void ignore_line ( std::basic_istream<CharT>& in )
  8. {
  9.   if ( in.rdbuf()->in_avail() > 0 )
  10.     in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
  11. }
  12.  
  13. int main()
  14. {
  15.   std::cout<<"First input: ";
  16.   std::cin.get();
  17.   std::cout<<"Clearing cin.\n";
  18.   std::cin.clear();
  19.   ignore_line ( std::cin );
  20.   std::cout<<"All done.\n";
  21. }
As with sync, when this works, it works great. But once again, the standard raises a wall by saying that in_avail isn't required to give you an accurate representation of the characters in the stream. In fact, some popular implementations have a strictly conforming in_avail that always returns 0. Not very useful. Now we have to get creative.

The putback member function
C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2. #include <ios>
  3. #include <istream>
  4. #include <limits>
  5.  
  6. template <typename CharT>
  7. void ignore_line ( std::basic_istream<CharT>& in )
  8. {
  9.   if ( !in.putback ( in.widen ( '\n' ) ) )
  10.     in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
  11.   else
  12.     in.ignore();
  13. }
  14.  
  15. int main()
  16. {
  17.   std::cout<<"First input: ";
  18.   std::cin.get();
  19.   std::cout<<"Clearing cin.\n";
  20.   std::cin.clear();
  21.   ignore_line ( std::cin );
  22.   std::cout<<"All done.\n";
  23. }
This looks very promising because at first glance, it seems that you can attempt to push back a newline. If the operation fails, the last read character wasn't a newline and you're free to call ignore without blocking. If the operation succeeds, the newline is back and you can remove it with a single character ignore.

Sadly, it doesn't work. putback isn't not required to do any of this predictably, which raises the question of why it's even available.

But putback actually takes us close to a solution that seems plausible enough to work most of the time. Instead of relying on putback to fail or not, we can guarantee that the last read character is put back by using the sungetc member function of the stream's buffer. The trick is to unget the last character, then read it again and test it against a newline:
C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2. #include <ios>
  3. #include <istream>
  4. #include <limits>
  5.  
  6. template <typename CharT>
  7. void ignore_line ( std::basic_istream<CharT>& in )
  8. {
  9.   if ( in.rdbuf()->sungetc() != std::char_traits<CharT>::eof()
  10.     && in.get() != in.widen ( '\n' ) )
  11.   {
  12.     in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
  13.   }
  14. }
  15.  
  16. int main()
  17. {
  18.   std::cout<<"First input: ";
  19.   std::cin.get();
  20.   std::cout<<"Clearing cin.\n";
  21.   std::cin.clear();
  22.   ignore_line ( std::cin );
  23.   std::cout<<"All done.\n";
  24. }
The reason we use sungetc instead of istream's unget is because unget returns the stream, but sungetc returns either the character that was pushed back, or EOF. This way we can tell if the function failed or not more easily.

If sungetc fails, one of the following will be true:

1) The stream is in an error state.
2) There are no characters to unget.
3) The stream doesn't support ungetting characters.

If sungetc succeeds, there will always be a character to read and test against the newline. If that character matches a newline, then the last read character was also a newline and we don't need to call ignore. If the character doesn't match, then a full line hasn't been read and we can safely call ignore without blocking.

If the stream is in an error state, that's something the calling code has to deal with. If there are no characters to unget, then that's precisely what this solution is designed to properly handle. But, if the stream doesn't support ungetting characters, that's an issue. The ignore_line function will always fail to discard characters, so for those implementations that don't support ungetting characters, we can add a flag that forces an ignore. It's sometimes useful to know how many characters were ignored as well, so let's add that too and we have the final solution:
C++ Syntax (Toggle Plain Text) 
  1. #include <ios>
  2. #include <istream>
  3. #include <limits>
  4.  
  5. template <typename CharT>
  6. std::streamsize ignore_line (
  7.   std::basic_istream<CharT>& in, bool always_discard = false )
  8. {
  9.   std::streamsize nread = 0;
  10.  
  11.   if ( always_discard
  12.     || ( in.rdbuf()->sungetc() != std::char_traits<CharT>::eof()
  13.     && in.get() != in.widen ( '\n' ) ) )
  14.   {
  15.     // The stream is good, and we haven't
  16.     // read a full line yet, so clear it out
  17.     in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
  18.     nread = in.gcount();
  19.   }
  20.  
  21.   return nread;
  22. }
Just for good measure, I'll also include a manipulator that calls ignore_line and also a manipulator that uses ignore_line to pause the program. That way the unwashed masses can stop using system ( "PAUSE" ); and getch();:
C++ Syntax (Toggle Plain Text) 
  1. class ignoreline {
  2.   bool _always_discard;
  3.   mutable std::streamsize _nread;
  4. public:
  5.   ignoreline ( bool always_discard = false )
  6.     : _always_discard ( always_discard ), _nread ( 0 )
  7.   {}
  8.  
  9.   std::streamsize gcount() const { return _nread; }
  10.  
  11.   template <typename CharT>
  12.   friend std::basic_istream<CharT>& operator>> (
  13.     std::basic_istream<CharT>& in, const ignoreline& manip )
  14.   {
  15.     manip._nread = ignore_line ( in, manip._always_discard );
  16.     return in;
  17.   }
  18. };
  19.  
  20. class pause {
  21.   ignoreline _ignore;
  22. public:
  23.   pause ( bool always_discard = false )
  24.     : _ignore ( always_discard )
  25.   {}
  26.  
  27.   std::streamsize gcount() const { return _ignore.gcount(); }
  28.  
  29.   template <typename CharT>
  30.   friend std::basic_istream<CharT>& operator>> (
  31.     std::basic_istream<CharT>& in, const pause& manip )
  32.   {
  33.     if ( !( in>> manip._ignore ) )
  34.       in.clear();
  35.  
  36.     std::cout<<"Press Enter to continue . . .";
  37.  
  38.     return in.ignore();
  39.   }
  40. };
Now all three cases behave identically:
C++ Syntax (Toggle Plain Text) 
  1. int main()
  2. {
  3.   std::cout<<"First input: ";
  4.   std::cin.get();
  5.   std::cout<<"Clearing cin.\n";
  6.   std::cin>> ignoreline();
  7.   std::cout<<"All done.\n";
  8.   std::cin>> pause();
  9. }
And the moral of the story is: It's never as simple as it seems, writing portable code that does what you want is extremely difficult, and the iostream library is a huge mess.

p.s. While I haven't yet discovered a portability issue with this solution in the standard, it doesn't mean that one doesn't exist. However, I'm confident enough in my ability to parse the legalese in the standard document that I don't foresee any problems presently.

This has been a public announcement from your friendly neighborhood C++ hacker. We now return you to your regularly scheduled programming.
Last edited by Narue; Feb 12th, 2008 at 5:26 pm.
I'm here to prove you wrong.
Quick reply to this message  
•
•
Join Date: Aug 2005
Posts: 5,264
Reputation: iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold 
Solved Threads: 377
Featured Poster
iamthwee's Avatar
iamthwee iamthwee is offline Offline
Posting Expert

Re: How do I flush the input stream?

 
0
  #2
Sep 20th, 2007
I'd much rather read everything in as a string then convert to ints or doubles wherever necessary.
Last edited by iamthwee; Sep 20th, 2007 at 5:04 pm.
*Voted best profile in the world*
Quick reply to this message  
•
•
Join Date: Sep 2004
Posts: 7,566
Reputation: Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute Narue has a reputation beyond repute 
Solved Threads: 705
Team Colleague
Narue's Avatar
Narue Narue is offline Offline
Code Goddess

Re: How do I flush the input stream?

 
0
  #3
Sep 20th, 2007
>I'd much rather read everything in as a string then convert to ints or doubles wherever necessary.
You're so boring, iamthwee. Why do things the conventional way when you can flex your brainy muscles and solve a problem the hard way?
I'm here to prove you wrong.
Quick reply to this message  
•
•
Join Date: Aug 2005
Posts: 5,264
Reputation: iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold iamthwee is a splendid one to behold 
Solved Threads: 377
Featured Poster
iamthwee's Avatar
iamthwee iamthwee is offline Offline
Posting Expert

Re: How do I flush the input stream?

 
0
  #4
Sep 20th, 2007
Well there you go, maybe this might also be better submitted as a tutorial as opposed to a random one off thread?
*Voted best profile in the world*
Quick reply to this message  
•
•
Join Date: Dec 2007
Posts: 2
Reputation: msary80 is an unknown quantity at this point 
Solved Threads: 0
msary80 msary80 is offline Offline
Newbie Poster

Re: How do I flush the input stream?

 
0
  #5
Dec 28th, 2007
About flush the input stream, I'll check it out, Thank you for your work.


Daniweb - Friendly online community for C++ learners with accurate tutorials.
Last edited by cscgal; Dec 29th, 2007 at 3:34 pm. Reason: Fake signature snipped.
Quick reply to this message  
•
•
Join Date: May 2008
Posts: 6
Reputation: faust_g is an unknown quantity at this point 
Solved Threads: 1
faust_g faust_g is offline Offline
Newbie Poster

Re: How do I flush the input stream?

 
0
  #6
May 22nd, 2008
Works great! Thanks so much!
Quick reply to this message  
•
•
Join Date: Mar 2008
Posts: 25
Reputation: iansane is an unknown quantity at this point 
Solved Threads: 0
iansane iansane is offline Offline
Light Poster

Re: How do I flush the input stream?

 
0
  #7
May 22nd, 2008
works great for windows. I saved it as ignoreline.h and use it as an include.

Doesn't work in linux. Anyone know why?

Compile time error message:

C++ Syntax (Toggle Plain Text) 
  1.  clearTheStream.cpp: In function ‘int main()’:
  2. clearTheStream.cpp:24: error: ambiguous overload for ‘operator>>’ in ‘std::cin >> pause()’
  3. /usr/include/c++/4.2/istream:131: note: candidates are: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>& (*)(std::basic_istream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>] <near match>
  4. /usr/include/c++/4.2/istream:135: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>] <near match>
  5. /usr/include/c++/4.2/istream:142: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>] <near match>
  6. /usr/include/c++/4.2/istream:250: note:                 std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>] <near match>
  7. /usr/include/c++/4.2/backward/ignoreline.h:54: note:                 std::basic_istream<CharT, std::char_traits<_CharT> >& operator>>(std::basic_istream<CharT, std::char_traits<_CharT> >&, const ignoreline&) [with CharT = char]
  8. /usr/include/c++/4.2/backward/ignoreline.h:72: note:                 std::basic_istream<CharT, std::char_traits<_CharT> >& operator>>(std::basic_istream<CharT, std::char_traits<_CharT> >&, const pause&) [with CharT = char]

What is abiguous overload? And is there a known bug with istream in linux?
Quick reply to this message  
•
•
Join Date: Mar 2008
Posts: 25
Reputation: iansane is an unknown quantity at this point 
Solved Threads: 0
iansane iansane is offline Offline
Light Poster

Re: How do I flush the input stream?

 
0
  #8
May 23rd, 2008
after looking up ambiguous, I'm wondering if this code could or should be rewritten so it can be called as a member function instead of as cin >> pause(). Don't know, just throwing the idea out there. I don't even know how to begin doing that. I just copy and pasted but don't fully understand the above code yet.
Like I said it works in windows compiled with dev c++, just not in linux with g++.

Thanks for the code. I'll be able to use it in windows apps till I find out the problem with linux.
Quick reply to this message  
•
•
Join Date: Mar 2008
Posts: 268
Reputation: Traicey is an unknown quantity at this point 
Solved Threads: 19
Traicey's Avatar
Traicey Traicey is offline Offline
Posting Whiz in Training

Re: How do I flush the input stream?

 
0
  #9
May 26th, 2008
•
•
•
•
Originally Posted by Naure
You're so boring, iamthwee. Why do things the conventional way when you can flex your brainy muscles and solve a problem the hard way?
Why should you complicate things while there is a easy way out, I mean C++ alone is complicated
Some people get so rich they lose all respect for humanity. That's how rich I want to be.
Quick reply to this message  
•
•
Join Date: Mar 2008
Posts: 25
Reputation: iansane is an unknown quantity at this point 
Solved Threads: 0
iansane iansane is offline Offline
Light Poster

Re: How do I flush the input stream?

 
0
  #10
May 26th, 2008
looks like Naure covered a lot of bases with one class of functions which is great.

I appreciate your comedy ruotine Traicey, but if there is an easier way to be able to flush,empty,ignore (what ever you want to call it, it accomplishes the goal), would you please explain and post the code?

Again if anyone knows why I'm getting the compile error posted above when using g++ in linux (ubuntu) would you please help me out?

Thanks :-)
Quick reply to this message  
Closed Thread
1 2 Last »

Quick Reply to Thread
This thread is more than three months old.
Perhaps start a new thread instead?
•
•
•
•
•
•
•
•
Message:
•
•
•
•



Similar Threads
Other Threads in the C++ Forum
Thread Tools Search this Thread



api array based beginner binary bitmap c++ c/c++ calculator char class classes code coding compile compiler console conversion count database delete deploy desktop developer directshow dll download dynamic dynamiccharacterarray email encryption error file forms fstream function functions game givemetehcodez google graph gui homeworkhelp homeworkhelper iamthwee ifstream int integer java lib linkedlist linker linux list loop looping loops map math matrix memory multiple news node number output parameter pointer problem program programming project python read recursion recursive reference return rpg string strings struct temperature template templates test text text-file tree unix url variable vector visualstudio win32 windows winsock word wordfrequency wxwidgets
About Us | Contact Us | Advertise | DaniWeb | Acceptable Use Policy | RSS Feed

©2003 - 2009 DaniWeb® LLC