Is it good practice to fake an inserter?

Question

We're taught to create function objects to use algorithms.

There are algorithms that call the operator(), like:

• for_each
• find_if
• remove_if
• max_element
• count_if

These function objects should typically inherit from unary_function or binary_function, to behave like a function, a predicate, etc.

But books don't generally demonstrate examples for creating OutputIterators:

e.g. to traverse the output of functions like std::set_intersection(), I have to provide a destination container, and then traverse the result:

std::vector<int> tmp_dest;

std::set_difference (
        src1.begin(), src1.end(), 
        src2.begin(), src2.end(), 
        std::back_inserter(tmp_dest));

std::for_each( tmp_dest.begin(), tmp_dest.end(), do_something );
int res = std::accumulate( tmp_dest.begin(), tmp_dest.end(), 0 );

but think that it would be more efficient sometimes to use the values of each algorithm, without storing them first, like:

std::set_difference (
        src1.begin(), src1.end(), 
        src2.begin(), src2.end(), 
        do_something );

Accumulator accumulate(0);  // inherits from std::insert_iterator ?
std::set_difference (
        src1.begin(), src1.end(), 
        src2.begin(), src2.end(), 
        accumulate );

• Should we generally create classes like this Accumulator ?
• What should its design look like?
• What should it inherit from ? Accumulator could inherit from insert_iterator, but it is not really an iterator (eg it does not implement operator++() )

what are the widely accepted practices?

Answer 1

If you want an output iterator that calls your own function for every value received, use Boost.Iterator's function_output_iterator.