Bulk I/O is a strenuous operation in terms of performance and resource allocation. For example, say you need to debug a container and wish to dump its content to cout as well as to a file. You’ll need to hardcode every such operation, writing ad-hoc code that serves for very pinpointed uses, none of which can be modified easily. This process would be tedious, time-consuming, and potentially complicated.

Thankfully, the library allows you to ignore the underlying type of data sources and targets?files, containers, the standard input, the standard output etc., thus freeing you from having to deal with the peculiarities of each type of data source or target.

When using stream iterators, the system can optimize your code as it conceptually performs an I/O operation in one shot. More importantly, the use of stream iterators provides more flexibility because it allows you to switch from one data source or target to another almost seamlessly.

In this solution, learn how to use the library to enhance your apps’ design and performance while reducing manual labor.

How to transfer data between containers, files, and streams efficiently and uniformly?

Use istream_iterator and ostream_iterator for sequential input and output.Demonstrating the Problem
Imagine a program that reads integers from cin and writes them to a vector. A naDumping a Container
“GUI-based applications rarely use cin and cout, so what’s the big deal?” you’re probably asking. To demonstrate the powerfulness of stream iterators, I’ll show you now a more realistic example that uses stream iterators to write the contents of a container to cout, and then to a file:

void func(){vector vi(10,35); //fill with 10 int of the value 35//write contents of vi to cout, each number on a new linestd::copy(vi.begin(),          vi.end(),          ostream_iterator (cout, "
"));}

func() uses the copy() algorithm to write the vector’s elements to cout. The first two copy() arguments are iterators that mark the boundaries of the input sequence. Here’s the output of this function:

Figure 4. Here’s the output of the func() function.

Writing a container’s elements to a file is similar:

void f(const vector &vi){ //open a file in write mode ofstream vi_dump("vi.txt"); if (!vi_dump) //failure? {   cerr<<"couldn't open file";   exit(1); } copy(vi.begin(),      vi.end(),      ostream_iterator (vi_dump, " "));}

The third copy() argument is an ostream_iterator bound to a file stream. copy() therefore writes vi’s content to the file vi.txt.

Writing a Stream to a Container
Reading a file into a container is just as easy:

#include#include#include#include#includeusing namespace std;int main(){ vector vi;//vector to be filled ifstream vi_dump("vi.txt"); //open for read if (!vi_dump) {   cerr<<"couldn't open file";   exit(1); } copy(istream_iterator (vi_dump),      istream_iterator (),      back_inserter(vi));}

copy() writes the file’s content into vi. back_inserter(vi) returns a special output iterator that automatically causes vi to allocate storage for incoming data as needed.

Iterators Reiterated
If you haven’t used stream iterators before, this technique might look like witchcraft. However, it’s based on a recurrent pattern:

1. Treat data sources as input streams and targets as output streams.
2. Create iterators that point to these streams.
3. Use an algorithm or a container to transfer data from a source to a target.

For the sake of simplicity, my examples use copy() exclusively. However, you can easily use this technique with other algorithms, such as transform(), find(), replace() etc.