C++ Output Iterator

• Output Iterator is an iterator used to modify the value in the container.
• Dereferencing an output iterator allows us to alter the value of the container.
• It does not allow us to read the value from the container.
• It is a one-way and write-only iterator.
• It can be incremented, but cannot be decremented.
• Operators that can be used for an output iterator are increment operator(++), decrement operator(--) and assignment operator(=).

There are two main subclasses of an Output Iterator are

• insert iterator
• ostream iterator

Insert Iterator

• An insert iterator is an iterator used to insert the element in a specified position.
• An assignment operator on the insert_iterator inserts the new element at the current position.

template<class Container, class Iterator>
insert_iterator<container> inserter(Container &x,Iterator it);

Parameters

x: It is the container on which the new element is to be inserted.

it: It is an iterator object pointing to the position which is to be modified.

Let's see a simple example

#include <iostream>     // std::cout
#include <iterator>     // std::front_inserter
#include <vector>         // std::list
#include <algorithm>    // std::copy
using namespace std;
int main () {
  vector<int> v1,v2;
  for (int i=1; i<=5; i++)
  { 
  v1.push_back(i); 
  v2.push_back(i+2);
  }
 vector<int>::iterator it = v1.begin();
  advance (it,3);
 copy (v2.begin(),v2.end(),inserter(v1,it));
  cout<<"Elements of v1 are :";
  for (  it = v1.begin(); it!= v1.end(); ++it )
  cout << ' ' << *it;
  cout << '\n';
  return 0;
}

In the above example, insert_iterator is applied on the copy algorithm to insert the elements of the vector v2 into the vector v1 at a specified position pointed by it.

Ostream iterator

• An ostream iterators are the output iterators used to write to the output stream such as cout successively.
• An ostream iterator is created using a basic_ostream object.
• When an assigenment operator is used on the ostream iterator, it inserts a new element into the output stream.

template<class T, class charT=char, class traits=char_traits<charT>>
class ostream_iterator;

Member functions of Ostream Iterator class

Ostream_iterator<T, charT, traits>& operator=(const T& value);
Ostream_iterator<T, charT, traits>& operator*();
Ostream_iterator<T, charT, traits>& operator++();
Ostream_iterator<T, charT, traits>& operator++(int);

Parameters

• T It is the type of elements to be inserted into the container.
• charT The type of elements that ostream can handle, for example, char ostream.
• traits These are the character traits that the stream handles for the elements.

Let's see a simple example

#include <iostream>
#include<iterator>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
   vector<int> v;
   for(int i=1;i<=5;i++)
   {
       v.push_back(i*10);
   }
 ostream_iterator<int> out(cout,",");
 copy(v.begin(),v.end(),out);
    return 0;
}

In the above example, out is an object of the ostream_iterator used to add the delimiter ',' between the vector elements.

Let's see another simple example of ostream iterator

#include <iostream>
#include<iterator>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
   ostream_iterator<int> out(cout,",");
   *out = 5;
   out++;
   *out = 10;
   out++;
   *out = 15;
   return 0;
}

Features Of Output Iterator

Equality/Inequality Operator

Output iterators cannot be compared either by using equality or inequality operator. Suppose X and Y are the two iterators

X==Y;  invalid
X!=Y;   invalid

Dereferencing

An output iterator can be dereferenced as an lvalue.

*X=7;

Incrementable

An output iterator can be incremented by using operator++() function

X++;
++X;

Limitations Of Output Iterator

Assigning but no accessing

We can assign an output iterator as an lvalue, but we cannot access them as an rvalue.

Suppose 'A' is an output iterator type and 'x' is a integer variable

*A = x;                   // valid
  x = *A;                 // invalid

It cannot be decremented

We can increment the output iterator by using operator++() function, but we cannot decrement the output iterator.

Suppose 'A' is an output iterator type

A++;            // not valid
++A;            // not valid

Multi-pass algorithm

An output iterator cannot be used as a multi-pass algorithm. Since an output iterator is unidirectional and can move only forward. Therefore, it cannot be used to move through the container multiple times

Relational Operators

An output iterator cannot be compared by using any of the relational operators.

Suppose 'A' and 'B' are the two iterators:

A = =B;        // not valid
A = =B;        // not valid

Arithmetic Operators

An output iterator cannot be used with the arithmetic operators. Therefore, we can say that the output iterator only moves forward in a sequential manner.

Suppose 'A' is an output iterator

A + 2;               // invalid
A + 5;               // invalid