iterator

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;

int main ()
{
    vector<int> vInt(5);
    iota (vInt.begin(),vInt.end(),1);

    vector<int>::iterator It = vInt.begin();

    while ( It != vInt.end() )
        cout << It++ <<  ";
    cout << ;

    // or
    for ( It = vInt.begin(); It != vInt.end(); It++ )
        cout << It <<  ";
    cout << ;

    return 0;
}
OUTPUT:
// 1 2 3 4 5
// 1 2 3 4 5

istream_iterator 1

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;

int main () 
{
    // first way
    istream_iterator<int> start_cin(cin);
    istream_iterator<int> end_of_cin;
    vector<int> v;

    cout << "Enter sequance of integers "
        << "(d - quit) : ";
    copy(start_cin,end_of_cin,back_inserter(v));

    for ( vector<int>::iterator It = v.begin();
            It != v.end(); It++ )
        cout << *It << " - ";
    cout << endl;
	 
    // second way
    vector<string> vS;
	cout << "Enter three strings : ";
    for ( int i = 0; i < 3; i++ )
        vS.push_back(*istream_iterator<string>(cin));
 	
    ostream_iterator<string> sIt(cout,", ");
    copy(vS.begin(),vS.end(),sIt);
 	 
    cout << endl;

    return 0;
}
OUTPUT:
// Enter sequance of integers (d - quit) : 2 3 4
// 2 - 3 - 4 -
// Enter three strings : one two three
// one, two, three,

istream_iterator 2

#include <iostream>
#include <list>
#include <fstream>
#include <algorithm>
using namespace std;

int main () 
{
    list i;
    ifstream f("ITER.DAT");
	
    // read data from file
    istream_iterator<int> file_iter(f);
    istream_iterator<int> end_of_stream;

    copy (file_iter, end_of_stream, back_inserter(i));

    cout << endl;

    ostream_iterator<int> ositer(cout, " - ");
    copy (i.begin(), i.end(), ositer);
    cout << endl;

    return 0;
}
OUTPUT:
//  11 - 22 - 33 - 44 - 55 - 

ostream_iterator

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
using namespace std;

int main () 
{
    int ary[] = {2,5,7,2,8,9};
    ofstream ofile("TEST.DAT");
    
    // write to STDOUT
    copy(ary,ary+6,ostream_iterator<int>(cout," - "));
    // write into file "TEST.DAT"
    copy(ary,ary+6,ostream_iterator<int>(ofile,"\n"));
    ofile.close();
    cout << endl;

    ifstream ifile("TEST.DAT");
	 
    istream_iterator<int> start_file(ifile);
    istream_iterator<int> end_file;
    
    // read from file and write to STDOUT
    copy(start_file,end_file,
        ostream_iterator<int>(cout," * "));
    ifile.close();
    cout << endl;

    return 0;
}
OUTPUT:
// 2 - 5 - 7 - 2 - 8 - 9 -
// 2 * 5 * 7 * 2 * 8 * 9 *

insert_iterator

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

int main () 
{
    list<int> L;
    L.push_front(3);
    insert_iterator<list<int> > ii(L, L.begin());
    *ii++ = 0;
    *ii++ = 1;
    *ii++ = 2;
    copy(L.begin(), L.end(), 
	    ostream_iterator<int>(cout, " "));
}
OUTPUT:
// 0 1 2 3.

inserter


#include <iostream>
#include <set>
#include <algorithm>
using namespace std;

int main() 
{
    int a[] = {1, 3, 5, 7, 9, 10};
    int b[] = {1, 2, 3, 4, 5, 6};
	
    set<int> result;

    merge(a, a+6, b, b+6, 
        inserter(result, result.begin()));
 
    copy(result.begin(), result.end(), 
	    ostream_iterator<int>(cout, " "));
    cout << endl;

    return 0;
}
OUTPUT:
// 1 2 3 4 5 6 7 9 10

front_insert_iterator


#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

int main() 
{
    list<int> L;
    L.push_front(3);
	
    front_insert_iterator<list<int> > iL(L);
    *iL++ = 0;
    *iL++ = 1;
    *iL++ = 2;
	
    copy(L.begin(), L.end(), 
	    ostream_iterator<int>(cout, " "));
}
OUTPUT:
// 2 1 0 3

front_inserter


#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

int main() 
{
    deque<int> d;
    front_inserter(d) = 100;
    front_inserter(d) = 200;

    copy(d.begin(),d.end(),
        ostream_iterator<int>(cout," "));
    cout << endl;
	
    // use front inserter to insert all elements again
    copy (d.begin(), d.end(),   // source
        front_inserter(d));   // destination
		  
    copy(d.begin(),d.end(),
        ostream_iterator<int>(cout," "));
    cout << endl;
	
    return 0;
}
OUTPUT:
// 200 100
// 200 100 200 100

back_insert_iterator


#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

int main() 
{
    list<int> L;
    L.push_back(3);
	
    back_insert_iterator<list<int> > iL(L);
    *iL++ = 0;
    *iL++ = 1;
    *iL++ = 2;
	
    copy(L.begin(), L.end(), 
	    ostream_iterator<int>(cout, " "));
}
OUTPUT:
// 3 0 1 2 

back_inserter


#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

int main() 
{
    deque<int> d;
    back_inserter(d) = 100;
    back_inserter(d) = 200;

    copy(d.begin(),d.end(),
        ostream_iterator<int>(cout," "));
    cout << endl;
	
    // use front inserter to insert all elements again
    copy (d.begin(), d.end(),   // source
        back_inserter(d));   // destination
		  
    copy(d.begin(),d.end(),
        ostream_iterator<int>(cout," "));
    cout << endl;
	
    return 0;
}
OUTPUT:
// 100 200
// 100 200 100 200

reverse_iterator

// The reverse function requires bidirectional iterators.

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

int main() 
{
	vector<int> v(10);
	iota (v.begin(),v.end(),1);
	copy (v.begin(),v.end(),
		ostream_iterator<int>(cout," "));
	cout << endl;
 	
	vector<int>::reverse_iterator r = v.rbegin();	
	while ( r != v.rend() )
		cout << *r++ << " ";
	cout << endl;
	
	return 0;

}
OUTPUT:
// 1 2 3 4 5 6 7 8 9 10
// 10 9 8 7 6 5 4 3 2 1

bidirectional_iterator

// Bidirectional iterators are forward iterators that also
// permit moving backwards one position at a time in the 
// container. 

#include <iostream>
#include <vector>
#include <numeric>  // for iota
#include <algorithm>
using namespace std;

int main ()
{
    vector<int> v(10);
    iota (v.begin(), v.end(),1);

    copy (v.begin(),v.end(),
            ostream_iterator<int>(cout," "));
    cout << endl;
    
    vector<int>::iterator i1 = v.begin();
    vector<int>::iterator i2 = v.end();
    
    random_shuffle(i1,i2);
    
     copy (v.begin(),v.end(),
            ostream_iterator<int>(cout," "));
    cout << endl;
    cin.get();
    return 0;
}
OUTPUT:
// 1 2 3 4 5 6 7 8 9 10
// 9 2 10 3 1 6 8 4 5 7
 
random_access_iterator

// Random access iterators are bidirectional iterators that
// can access any point in the container. In a constant
// amount of time, one can move to any position in a
// containerusing a random access iterator. This is
// useful when sorting or performing binary search. 
 

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
using namespace std;

int main ()
{
    vector<int> v(10);
    iota (v.begin(), v.end(),10);

    copy (v.begin(),v.end(),
            ostream_iterator<int>(cout," "));
    cout << endl;
    
    // vector::iterator and deque::iterator 
    // are random access iterator types 
    vector<int>::iterator pos;
    
    pos = v.begin() + 3;
    cout << *pos << endl;
    
    pos = find(v.begin(),v.end(),15);
    cout << *pos << endl;
    
	// put pointer 3 element forfard
    advance(pos,3);
    cout << *pos << endl;
	
    return 0;
}
OUTPUT:
// 10 11 12 13 14 15 16 17 18 19
// 13
// 15
// 18