C++ 为什么我不能创建流迭代器？

我应该创建一个看起来像流迭代器的类，以便在导入类的对象时可以从输入流中读取

我已经做到了：

template<class T>
struct istrm_it{
    istrm_it() = default;
    istrm_it(std::istream& in) :
        in_(in), val_(T()) {
        in_ >> val_;
    }
    T val_;
    std::istream& in_ = std::cin;
    istrm_it& operator++() { in >> val_; return *this; };
    istrm_it& operator++(int) { in_ >> val_; return *this; };
    T operator*() { return val_; }
    bool operator==(const istrm_it& rhs)const { return in_ == rhs.in_; }
    bool operator!=(const istrm_it& rhs) const{ return in_ != rhs.in_; }
};

int main(){

    istrm_it<int> it(std::cin), e;
    cout << *it << endl; // ok

    it++; // ok read the next value from the nput stream

    vector<int> vi;
    while (it != e) // the problem here
        vi.push_back(*it++);

    for (auto i : vi)
        std::cout << i << ", ";
    std::cout << std::endl;


    std::cout << std::endl;
}

模板
struct istrm_it{
istrm_it（）=默认值；
istrm_it（标准：：istream&in）：
in（in），val（T（））{
在>>val；
}
T瓦卢；
标准：：istream&in=标准：：cin；
istrm_it&operator++（{in>>val_u; return*this；}；
istrm_it&operator++（int）{in_>>val\uu；return*this；}；
T运算符*（）{return val_；}
布尔运算符==（const istrm_it&rhs）const{return in.==rhs.in.}
布尔运算符！=（const istrm_it&rhs）const{return in_33;！=rhs.in_33;
};
int main（）{
istrm_it（标准：：cin），e；
cout问题在于比较中的
in_！=rhs.in_
（以及
in_==rhs.in_
），无法比较流

相反，您需要保持某种“is end iterator”或“is at end of file”状态，这种状态是在到达文件末尾时设置的，默认情况下在默认构造的迭代器对象中设置。
As
@some programmer dude
：流对象无法复制、分配或比较

如果您想让它用于某种教育目的，那么您可以向类中添加另一个成员，该成员跟踪它绑定到的流状态，并且in/equality运算符比较迭代器的内部状态是否良好，因此如果两者都良好，则它们相等，当t它们是
非端的
，否则它们不相等：

没有将迭代器绑定到流的默认构造函数应该使内部状态变差

而
++
应该在每个输入操作符之后检查流是否达到
EOF
或报告了IO错误，从而将状态设置为bad。这使得它与使用默认构造函数构造的流（作为结束迭代器）相等

这里有一个简单的建议：

template<class T>
struct istrm_it {
    istrm_it() = default;
    istrm_it(std::istream& in) :
        in_(in), val_(T()),
        is_good_(true) {
        in_ >> val_;
    }
    bool is_good_ = false;
    T val_ = T{};
    std::istream& in_ = std::cin;
    istrm_it& operator++() { in_ >> val_; if (!in_) is_good_ = false; return *this; };
    istrm_it& operator++(int) { in_ >> val_;  if (!in_) is_good_ = false; return *this; };
    T operator*() { return val_; }
    bool operator==(const istrm_it& rhs) const {
        return is_good_ && rhs.is_good_ || !is_good_ && !rhs.is_good_;}
    bool operator!=(const istrm_it& rhs) const{ return !(operator==(rhs)); }
};

模板
struct istrm_it{
istrm_it（）=默认值；
istrm_it（标准：：istream&in）：
in（in），val（T（）），
好吗{
在>>val；
}
布尔是好的，错的；
T val_uu=T{}；
标准：：istream&in=标准：：cin；
istrm_it&operator++（）{in_>>val_;；如果（！in_u）是u good_uu=false；返回*this；}；
istrm_it&operator++（int）{in>>val；如果（！in_）是_good_=false；返回*this；}；
T运算符*（）{return val_；}
布尔运算符==（常量istrm\U it&rhs）常量{
返回值为(u good)&&rhs.is(u good)(u good)(u good)&&rhs.is(u good)
布尔运算符！=（常量istrm_it&rhs）常量{return！（运算符==（rhs））；}
};

总的来说：

int main(){
    istrm_it<int> it(std::cin), e;
    cout << *it << endl;

    vector<int> vi;

    while (it != e)
        vi.push_back(*it++);


    for (auto i : vi)
        std::cout << i << ", ";
    std::cout << std::endl;
}

intmain（）{
istrm_it（标准：：cin），e；
我明白了。你能告诉我怎么解决吗？我只想为了教育目的。