STL之迭代器实现

#ifndef __ITERATOR_H
#define __ITERATOR_H
#include"iterator_traits.h"
#include<iostream>
template<class Container>
class back_insert_iterator
{
protected:
	Container* container;
public:
	typedef output_iterator_tag_h iterator_category;
	typedef void value_type;
	typedef void difference_type;
	typedef void pointer;
	typedef void reference;
	explicit back_insert_iterator(Container& x) :container(&x){}
	back_insert_iterator<Container>& operator=(const typename Container::value_type& value)
	{
		container->push_back(value);
		return *this;
	}
	back_insert_iterator<Container>& operator*(){ return *this; }
	back_insert_iterator<Container>& operator++(){ return *this; }
	back_insert_iterator<Container>& operator++(int){ return *this; }
};

template<class Container>
inline back_insert_iterator<Container>& back_inserter(Container& x)
{
	return back_insert_iterator<Container>(x);
}

template<class Container>
class front_insert_iterator
{
protected:
	Container* container;
public:
	typedef output_iterator_tag_h iterator_category;
	typedef void value_type;
	typedef void difference_type;
	typedef void pointer;
	typedef void reference;
	explicit front_insert_iterator(Container& x) :container(&x){}
	front_insert_iterator<Container>& operator=(const typename Container::value_type& value)
	{
		container.push_front(value);
		return *this;
	}
	front_insert_iterator<Container>& operator*(){ return *this; }
	front_insert_iterator<Container>& operator++(){ return *this; }
	front_insert_iterator<Container>& operator++(int){ return *this; }
};

template<class Container>
front_insert_iterator<Container>& front_inserter(Container& x)
{
	return front_insert_iterator<Container>(x);
}

template<class Container>
class insert_iterator
{
protected:
	Container* container;
	typename Container::iterator iter;
public:
	typedef output_iterator_tag_h iterator_category;
	typedef void value_type;
	typedef void difference_type;
	typedef void pointer;
	typedef void reference;
	insert_iterator(Container& x,typename Container::iterator i)
		:container(&x), iter(i){}
	insert_iterator<Container>& operator=(const typename Container::value_type& value)
	{
		iter = container->insert(iter, value);
		return *this;
	}
	insert_iterator<Container>& operator*(){ return *this; }
	insert_iterator<Container>& operator++(){ return *this; }
	insert_iterator<Container>& operator++(int){ return *this; }
};

template<class Container,class Iterator>
insert_iterator<Container>& inserter(Container& x, Iterator i)
{
	typedef typename Container::iterator iter;
	return insert_iterator<Container>(x, iter(i));
}

template<class Iterator>
class reverse_iterator
{
protected:
	Iterator current;
public:
	typedef typename iterator_trait<Iterator>::iterator_category iterator_category;
	typedef typename iterator_trait<Iterator>::value_type value_type;
	typedef typename iterator_trait<Iterator>::difference_type difference_type;
	typedef typename iterator_trait<Iterator>::pointer pointer;
	typedef typename iterator_trait<Iterator>::reference reference;
	typedef Iterator iterator_type;
	typedef reverse_iterator<Iterator> self;
public:
	reverse_iterator(){}
	explicit reverse_iterator(iterator_type x) :current(x){}
	reverse_iterator(const self& x) :current(x.current){}
	iterator_type base()const{ return current; }
	reference operator*()const
	{
		Iterator tmp = current;
		return *--tmp;
	}
	pointer operator->()const
	{
		return &(operator*());
	}
	self& operator++()
	{
		--current;
		return *this;
	}
	self operator++(int)
	{
		self tmp = *this;
		--current;
		return tmp;
	}
	self& operator--()
	{
		++current;
		return *this;
	}
	self operator--(int)
	{
		self tmp = *this;
		++current;
		return tmp;
	}
	self operator+(difference_type n)const
	{
		return self(current - n);
	}
	self& operator+=(difference_type n)
	{
		current -= n;
		return *this;
	}
	self operator-(difference_type n)const
	{
		return self(current + n);
	}
	self& operator-=(difference_type n)
	{
		current += n;
		return *this;
	}
	reference operator[](difference_type n)const
	{
		return *(*this + n);
	}
};

template<class T,class Distance=ptrdiff_t>
class istream_iterator
{
protected:
	std::istream* stream;
	T value;
	bool end_marker;
	void read()
	{
		end_marker = (*stream) ? true : false;
		if (end_marker)
			*stream >> value;
		end_marker = (*stream) ? true : false;
	}
public:
	typedef input_iterator_tag_h iterator_category;
	typedef T value_type;
	typedef Distance difference_type;
	typedef const T* pointer;
	typedef const T& reference;
	istream_iterator() :stream(&std::cin), end_marker(false){}
	istream_iterator(std::istream& s) :stream(&s){ read(); }
	reference operator*()const{ return value; }
	pointer operator->()const{ return &(operator*()); }
	istream_iterator<T, Distance>& operator++()
	{
		read();
		return *this;
	}
	istream_iterator<T, Distance>  operator++(int)
	{
		istream_iterator<T, Distance> tmp = *this;
		read();
		return tmp;
	}
	bool _M_equal(const istream_iterator<T,Distance>& __x)const
	{
		return (end_marker == __x.end_marker) && (!end_marker || stream == __x.stream);
	}
};

template<class T,class Distance>
inline bool operator==(const istream_iterator<T, Distance>& x, const istream_iterator<T, Distance>& y)
{
	return x._M_equal(y);
}

template<class T, class Distance>
inline bool operator!=(const istream_iterator<T, Distance>& x, const istream_iterator<T, Distance>& y)
{
	return !x._M_equal(y);
}

template<class T>
class ostream_iterator
{
protected:
	std::ostream* stream;
	const char* string;
public:
	typedef output_iterator_tag_h iterator_category;
	typedef void value_type;
	typedef void difference_type;
	typedef void pointer;
	typedef void reference;
	ostream_iterator(std::ostream& s) :stream(&s), string(0){}
	ostream_iterator(std::ostream& s, const char* c) :stream(&s), string(c){}
	ostream_iterator<T>& operator=(const T& value)
	{
		*stream << value;
		if (string)
			*stream << string;
		return *this;
	}
	ostream_iterator<T>& operator*(){ return *this; }
	ostream_iterator<T>& operator->(){ return &(operator*()); }
	ostream_iterator<T>& operator++(int){ return *this; }
};
#endif