class template
<iterator>
std::istreambuf_iterator
template <class charT, class traits=char_traits<charT> >
class istreambuf_iterator;
Input stream buffer iterator
Istreambuf iterators are input iterators that read successive elements from a stream buffer.
They are constructed from a basic_streambuf object open for reading, to which they become associated.
This kind of iterator has a special state as an end-of-stream iterator, which is acquired when the end of the stream is reached, and is also the resulting value of a default-constructed object: This value can be used as the end of a range in any function accepting iterator ranges to indicate that the range includes all the elements up to the end of the input buffer.
It is defined with a behavior similar to:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
template <class charT=char, class traits=char_traits<charT> >
class istreambuf_iterator :
public iterator<input_iterator_tag, charT,
typename traits::off_type, charT*, charT&>
{
public:
typedef charT char_type;
typedef traits traits_type;
typedef typename traits::int_type int_type;
typedef basic_streambuf<charT,traits> streambuf_type;
typedef basic_istream<charT,traits> istream_type;
class proxy {
charT keep_; streambuf_type* sbuf_;
public:
proxy (charT c, streambuf_type* sbuf) : keep_(c), sbuf_(sbuf) { }
charT operator*() {return keep_;}
};
istreambuf_iterator() throw() : sbuf_(0) { }
istreambuf_iterator(istream_type& s) throw(): sbuf_(s.rdbuf()) { }
istreambuf_iterator(streambuf_type* s) throw(): sbuf_(s) { }
istreambuf_iterator(const proxy& p) throw(): sbuf_(p.sbuf_) { }
charT operator*() const { return sbuf_->sgetc(); }
istreambuf_iterator<charT,traits>& operator++() { sbuf_->sbumpc(); return *this; }
proxy operator++(int) {return proxy(sbuf_->sbumpc(),sbuf_);}
bool equal (istreambuf_iterator& b) const {
if ( sbuf_==0 || *(*this)==traits::eof() )
{ if ( b.sbuf_==0 || *b==traits::eof() ) return true; }
else if ( b.sbuf_!=0 && *b!= traits::eof() ) return true;
return false;
}
private:
streambuf_type* sbuf_;
};
| |
Header <iterator> defines the comparison with operator== and operator!=): Two istreambuf_iterators compare equal if both are end-of-stream iterators or neither is, regardless of the streambuf object they use.
Member functions
- constructor
- istreambuf_iterator objects are constructed from either a basic_streambuf object or a basic_istream object.
The default constructor constructs an end-of-stream iterator and the copy constructor constructs a copy of the iterator passed as argument.
operator*- Returns the current value in the stream buffer.
operator++- Advances the position of the basic_streambuf object by one element.
proxy- Temporary type returned by the post-increment operator (which can be implicitly converted to the class type). A member class is just one of the possible ways to preserve a streambuf_iterator value. Some implementations of istreambuf_iterator may not have this member class if they use an alternate method.
Example
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
// istreambuf_iterator example
#include <iostream> // std::cin, std::cout
#include <iterator> // std::istreambuf_iterator
#include <string> // std::string
int main () {
std::istreambuf_iterator<char> eos; // end-of-range iterator
std::istreambuf_iterator<char> iit (std::cin.rdbuf()); // stdin iterator
std::string mystring;
std::cout << "Please, enter your name: ";
while (iit!=eos && *iit!='\n') mystring+=*iit++;
std::cout << "Your name is " << mystring << ".\n";
return 0;
}
| |
Possible output:
Please, enter your name: HAL 9000
Your name is HAL 9000.
|