Признак окончания потока для буферного итератора

      ///  Construct end of input stream iterator.
      istreambuf_iterator() throw()
      : _M_sbuf(0), _M_c(traits_type::eof()) { }
 
      ///  Construct start of input stream iterator.
      istreambuf_iterator(istream_type& __s) throw()
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
 
      ///  Construct start of streambuf iterator.
      istreambuf_iterator(streambuf_type* __s) throw()
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }

std::copy(std::istreambuf_iterator<char>(std::cin), std::istreambuf_iterator<char>(), back_inserter(Container));

template <class T>
void my_copy(std::istreambuf_iterator<char> in, T& Container)
{
    while (true)
    {
        Container.push_back(*in++);
        if ((cin.rdbuf() ->in_avail()) == 0)
            break;
    }
}
 
vector <char> Container;
std::istreambuf_iterator<char> in(std::cin);
my_copy(in, Container);

#include <fstream>
int main()
{
    std::vector<char> Container;
    std::istreambuf_iterator<char> bcin(std::cin);
    while(*bcin != '\n') {
        Container.push_back(*bcin++);
    }
    std::copy(Container.begin(), Container.end(), std::ostream_iterator<char>(std::cout, ""));
    std::cout << std::endl;
    return 0;
}

if ((cin.rdbuf()->in_avail()) == 1)
            break;

#include <iostream>
#include <iterator>
#include <vector>
using namespace std;
 
template <class T>
void my_copy(std::istreambuf_iterator<char> in, T& Container)
{
    while (true)
    {
        Container.push_back(*in++);
 
        if ((cin.rdbuf() ->in_avail()) == 1)
        break;
    }
}
 
int main()
{
    vector <char> Container;
 
    ios_base::sync_with_stdio(0); // !!!
    std::istreambuf_iterator<char> in(std::cin);
 
    my_copy(in, Container);
 
    for (int i = 0; i < Container.size(); ++i)
        cout << Container[i];
    cout << endl;
}

template <typename CharT, typename Traits = std::char_traits<CharT> >
class endline_iterator
    : public std::iterator<std::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 std::basic_streambuf<CharT, Traits>     streambuf_type;
    typedef std::basic_istream<CharT, Traits>       istream_type;
 
private:
    mutable streambuf_type *  sbuf;
    mutable int_type          c;
 
public:
    endline_iterator() throw()
        : sbuf(0), c(eof_value())
    { }
 
    endline_iterator(istream_type & s) throw()
        : sbuf(s.rdbuf()), c(eof_value())
    { }
 
    endline_iterator(streambuf_type * s) throw()
        : sbuf(s), c(eof_value())
    { }
 
    char_type operator*() const
    {
        return traits_type::to_char_type(get());
    }
 
    endline_iterator & operator++()
    {
        if(sbuf)
        {
            sbuf->sbumpc();
            c = eof_value();
        }
        return *this;
    }
 
    endline_iterator operator++(int)
    {
        endline_iterator old = *this;
        if(sbuf)
        {
            old.c = sbuf->sbumpc();
            c = eof_value();
        }
        return old;
    }
 
    bool equal(endline_iterator const & b) const
    {
        return at_eof() == b.at_eof();
    }
 
private:
    static int_type eof_value() // eof - это конец строки
    {
        return int_type('\n');
    }
 
    int_type get() const
    {
        const int_type eof = eof_value();
        int_type ret = eof;
        if(sbuf)
        {
            if (!traits_type::eq_int_type(c, eof))
                ret = c;
            else if (!traits_type::eq_int_type((ret = sbuf->sgetc()), eof))
                c = ret;
            else
                sbuf = 0;
        }
        return ret;
    }
 
    bool at_eof() const
    {
        const int_type eof = eof_value();
        return traits_type::eq_int_type(get(), eof);
    }
};
 
template<typename CharT, typename Traits>
inline 
bool operator==(endline_iterator<CharT, Traits> const & a,
           endline_iterator<CharT, Traits> const & b)
{
    return a.equal(b);
}
 
template<typename CharT, typename Traits>
inline
bool operator!=(endline_iterator<CharT, Traits> const & a,
                endline_iterator<CharT, Traits> const & b)
{
    return !a.equal(b);
}

std::copy(endline_iterator<char>(std::cin), endline_iterator<char>(), std::back_inserter(Container));