c ++ primer archivo de encabezado sales_iterm.h, y un ejemplo del uso del iterador de flujo para leer objetos de tipo de clase

 sales_items.h

#ifndef INCLUDE_SALES_DATA_H
#define INCLUDE_SALES_DATA_H
class Sales_item
{
public:
 Sales_item(const std::string &book):isbn(book),units_sold(0),revenue(0.0){}
 Sales_item(std::istream &is){ is >> *this;}
 friend std::istream& operator>>(std::istream &,Sales_item &);
 friend std::ostream& operator<<(std::ostream &,const Sales_item &);
public:
 Sales_item & operator+=(const Sales_item&);
public:
 double avg_price() const;
 bool same_isbn(const Sales_item &rhs)const
 {
  return isbn == rhs.isbn;
 }
 Sales_item():units_sold(0),revenue(0.0){}
public:
 std::string isbn;
 unsigned units_sold;
 double revenue;
};

using std::istream;
using std::ostream;
Sales_item operator+(const Sales_item &,const Sales_item &);
inline bool operator==(const Sales_item &lhs,const Sales_item &rhs)
{
 return lhs.units_sold == rhs.units_sold && lhs.revenue == rhs.revenue && lhs.same_isbn(rhs);
}
inline bool operator!=(const Sales_item &lhs,const Sales_item &rhs)
{
 return !(lhs == rhs);
}

inline Sales_item & Sales_item::operator +=(const Sales_item &rhs)
{
 units_sold += rhs.units_sold;
 revenue += rhs.revenue;
 return *this;
}
inline Sales_item operator+(const Sales_item &lhs,const Sales_item &rhs)
{
 Sales_item ret(lhs);
 ret += rhs;
 return ret;
}
inline istream& operator>>(istream &in,Sales_item &s)
{
 double price;
 in >> s.isbn >> s.units_sold >> price;
 if(in)
  s.revenue = s.units_sold * price;
 else
  s = Sales_item();
 return in;
}
inline ostream& operator<<(ostream &out,const Sales_item &s)
{
 out << s.isbn << "\t" <<s.units_sold << "\t" << s.revenue << "\t" << s.avg_price();
 return out;
}
inline double Sales_item::avg_price() const
{
 if(units_sold)
  return revenue/units_sold;
 else
  return 0;
}
#endif

//程序用途：每次从cin读取一个Sales_item对象，如果读取的isbn和上一次的相同，那么读取的
//对象加到前一个中，如果读取的isbn和前一次不一样，那么把前一次的结果输出，把新读入的元素存入
//


#include <iostream>
#include <string>
#include "sales_data.h"
#include <iterator>
using namespace std;
int main()
{
//新建一个istream的iterator，读取元素类型是Sales_item对象，该istream_iterator关联到
//流cin,同时创建一个空流eof，当读取元素时候遇到流错误或者文件末尾时候，in_iter 就会等于eof　

istream_iterator<Sales_item> in_iter(cin),eof;
//创建一个ostream_iterator，输出元素类型是Sales_item，关联到流cout，且每次输出时候在末尾
//加上"\n"
ostream_iterator<Sales_item> out_iter(cout,"\n");
//创建Sales_item对象sum，并且用in_iter内的元素初始化，接着in_iter读取下一个值
Sales_item sum =*in_iter ++;
//创建while循环，当in_iter关联的流没有遇到错误，并且没有到达文件末尾的时候，循环继续
while(in_iter != eof)
{
//如果刚才读取的元素的isbn和sum中的Sales_data的isbn相等，那么把这个元素加到sum中，且
//in_iter读取下一个值
 if(in_iter -> isbn == sum.isbn)
 {
  sum += *in_iter ++;   
 } 
//如果新读取的对象的isbn不等于sum中元素的isbn，那先输出sum中的对象，然后把新*in_iter
//赋值给sum，然后in_iter再读取下一个值
 else
 {
   *out_iter++ = sum;
   sum = *in_iter ++; 
 }
}
    return 0;
}

Tenga en cuenta varios usos:

1. Cuando el objeto istream_iterator está asociado con un istream o se llama al operador ++, el objeto istream_iterator leerá el nuevo valor, por ejemplo:

istream_iterator <Elemento_de_ventas> in_iter (cin); Cuando in_iter está asociado con cin, se leerá un valor de la secuencia cin.

in_iter ++; // Esta oración significa que in_iter lee un nuevo valor de cin

Mi propio entendimiento es que istream_iterator lee el nuevo valor, que es leer el nuevo valor con el flujo asociado a él. 

2. ¿Cómo generar el iterador de flujo de ostrem_iterator? Simplemente asígnele el objeto y podrá usarlo para generar, por ejemplo:

out_iter = suma;

Debido a que el iterador de flujo de ostream_iterator se llama *, el preincremento ++ y el posincremento ++ no realizan ninguna operación en ostream_iterator, por lo que también se puede escribir

* out_iter ++ = sum; // Equivalente a out_iter = sum

3. El iterador de flujo de entrada (tipo istream_iterator, el iterador de flujo de entrada es el nombre que tomé), leer el elemento solo necesita llamar al preincremento o postincremento ++, y el iterador de flujo de salida para generar el elemento

Simplemente asígnelo. Para facilitar la lectura y cambiar a otras transmisiones en el futuro, puede agregar algunos operadores como: ++, *.