#ifndef _POLY_ITERATOR_
#define _POLY_ITERATOR_
 
#include <iterator>
#ifndef HPUX11
using namespace std;
#endif //HPUX11
 
#include <iterator>
#ifndef LIN
using namespace std;
#endif //HPUX11
 
template<class C, typename T>
class poly_iterator 
#if _MSC_VER>=1300 // VC7
    : public iterator_traits<typename C::iterator>
#endif
{
private:
    // typedef poly_iterator<C,T> _Self;
 
protected:
    typedef typename C::iterator I;
    //!< regular iterator of the underlying container
    I i; 
    //! mimic inheritage from the regular iterator
    //! because we cannot simply derive from it since
    // some iterators are regular pointers
public:
    operator I&() 
    {
        return (I&)i;
    }
    //!<needed to use poly_iterator in algorithms transparently
 
public:
    poly_iterator<C,T>() {};
    poly_iterator<C,T>(const I& p):i(p) {};
    //!< construction form const_poly_iterator
 
    T& operator*() {return (T&)*i;}
    T* operator->() {return (T*)&*i;}
 
public: // compatibility with I iterator
    poly_iterator<C,T>& operator++() {++i; return *this;}
    poly_iterator<C,T>& operator--() {--i; return *this;}
 
    poly_iterator<C,T> operator+(const Int count)
    {
        I temp = i; 
        temp += count;
        return poly_iterator<C,T>(temp);
    }
 
    poly_iterator<C,T> operator-(const Int count)
    {
        I temp = i; 
        temp -= count;
        return poly_iterator<C,T>(temp);
    }
 
    poly_iterator<C,T>& operator++(Int) 
    {
        i++; 
        return *this;
    }
 
    poly_iterator<C,T>& operator--(Int)
    {
        i--;
        return *this;
    }
 
    bool operator<(const poly_iterator<C,T>& other) const
    {
        return i < other.i;
    }
 
    bool operator<(const I& other) const
    {
        return i < other;
    }
 
    bool operator<=(const poly_iterator<C,T>& other) const
    {
        return i <= other.i;
    }
 
    bool operator<=(const I& other) const
    {
        return i <= other;
    }
 
    bool operator>(const poly_iterator<C,T>& other) const
    {
        return i > other.i;
    }
 
    bool operator>(const I& other) const
    {
        return i > other;
    }
 
    bool operator>=(const poly_iterator<C,T>& other) const
    {
        return i >= other.i;
    }
 
    bool operator>=(const I& other) const
    {
        return i >= other;
    }
 
    bool operator==(const I& other) const 
    { 
        return i==other;
    }
 
    bool operator!=(const I& other) const 
    {
        return i!=other;
    }
 
    bool operator==(const poly_iterator<C,T>& other) const 
    {
        return i==other.i;
    }
 
    bool operator!=(const poly_iterator<C,T>& other) const 
    {
        return i!=other.i;
    }
 
}; 
 
#endif // _POLY_ITERATOR_
 
#endif

    Int operator-(poly_iterator<C,T> const& rhs)
    {
      /*
             Just to see if it compiles...
      */
    }

int main()
{
    std::vector<int> v(10);
    v[4] = 42;
    poly_iterator<std::vector<int>, int> first(v.begin()), last(v.end()), it;
    it = std::find(first, last, 42);
    if (it != last) {
        std::cout << *it << '\n';
    }
}

class poly_iterator 
#if _MSC_VER>=1300 // VC7
    : public iterator_traits<typename C::iterator>
#endif

    typename I::difference_type operator-(const poly_iterator<C,T>& other)
    {
        //I temp =i;
        //poly_iterator<C,T> temp =(temp -(other.i));
        //return temp;
        return i - other.i;
    }

poly_iterator<std::vector<int>, int> first(v.begin()), last(v.end()), it;

template<class C>
class poly_iterator : public iterator_traits<typename C::iterator>
{
private:
    // typedef poly_iterator<C,T> _Self;

protected:
    typedef typename C::iterator I;
    typedef typename I::value_type T;

#include<iostream>
#include <iterator>
#include <vector>
typedef int Int;


using namespace std;


template<class C, typename T>

class poly_iterator : public iterator_traits<typename C::iterator>
{
private:
	// typedef poly_iterator<C,T> _Self;

protected:
	typedef typename C::iterator I;
	//!< regular iterator of the underlying container
	I i; 
	//! mimic inheritage from the regular iterator
	//! because we cannot simply derive from it since
	//            some iterators are regular pointers
public:
	operator I&() 
	{
		return (I&)i;
	}
	//!<needed to use poly_iterator in algorithms transparently

public:
	poly_iterator<C,T>() {};
	poly_iterator<C,T>(const I& p):i(p) {};
	//!< construction form const_poly_iterator

	T& operator*() {return (T&)*i;}
	T* operator->() {return (T*)&*i;}

public: // compatibility with I iterator
	poly_iterator<C,T>& operator++() {++i; return *this;}
	poly_iterator<C,T>& operator--() {--i; return *this;}

	poly_iterator<C,T> operator+(const Int count)
	{
		I temp = i; 
		temp += count;
		return poly_iterator<C,T>(temp);
	}

	poly_iterator<C,T> operator-(const Int count)
	{
		I temp = i; 
		temp -= count;
		return poly_iterator<C,T>(temp);
	}

	poly_iterator<C,T>& operator++(Int) 
	{
		i++; 
		return *this;
	}

	poly_iterator<C,T>& operator--(Int)
	{
		i--;
		return *this;
	}

	bool operator<(const poly_iterator<C,T>& other) const
	{
		return i < other.i;
	}

	bool operator<(const I& other) const
	{
		return i < other;
	}

	bool operator<=(const poly_iterator<C,T>& other) const
	{
		return i <= other.i;
	}

	bool operator<=(const I& other) const
	{
		return i <= other;
	}

	bool operator>(const poly_iterator<C,T>& other) const
	{
		return i > other.i;
	}

	bool operator>(const I& other) const
	{
		return i > other;
	}

	bool operator>=(const poly_iterator<C,T>& other) const
	{
		return i >= other.i;
	}

	bool operator>=(const I& other) const
	{
		return i >= other;
	}

	bool operator==(const I& other) const 
	{   
		return i==other;
	}

	bool operator!=(const I& other) const 
	{
		return i!=other;
	}

	bool operator==(const poly_iterator<C,T>& other) const 
	{
		return i==other.i;
	}

	bool operator!=(const poly_iterator<C,T>& other) const 
	{
		return i!=other.i;
	}

}; 

TEST.CPP


//#include "stdafx.h"
// iterator_traits.cpp
// compile with: /EHsc
#include <iostream>
#include <iterator>
#include <vector>
#include <list>
#include <algorithm>

using namespace std;

#include "test.hpp"


int main()
{
    vector<int> v(10);
    v[4] = 42;
    poly_iterator<vector<int>, int> it;
	poly_iterator<vector<int>, int> first(v.begin());
	poly_iterator<vector<int>, int> last(v.end());
	
	it = find(first, last, 42);
    if (it != last) {
        cout << *it << '\n';
    }

	return 0;
}