自己实现iterator迭代器

#include <iterator>
#include <iostream>

struct List_node_base {
	List_node_base* M_next;
	List_node_base* M_prev;
};

template <class T>
struct List_node : public List_node_base {
	T M_data;
};

struct List_iterator_base {
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;							// typedef int ptrdiff_t;
	typedef std::bidirectional_iterator_tag iterator_category;

	List_node_base* M_node;
	List_iterator_base(List_node_base* x) : M_node(x) {}
	List_iterator_base() {}

	void M_incr() { M_node == M_node->M_next; }
	void M_decr() { M_node == M_node->M_prev; }

	bool operator==(const List_iterator_base& x) const {
		return M_node == x.M_node;
	}

	bool operator!=(const List_iterator_base& x) const {
		return M_node != x.M_node;
	}
};

template<class T, class Ref, class Ptr>
struct List_iterator : public List_iterator_base {
	typedef List_iterator<T, T&, T*> iterator;
	typedef List_iterator<T, const T&, const T*> const_iterator;
	typedef List_iterator<T, Ref, Ptr> Self;

	typedef T value_type;
	typedef Ptr pointer;
	typedef Ref reference;
	typedef List_node<T> Node;

	List_iterator(Node* x) : List_iterator_base(x) {}
	List_iterator() {}
	List_iterator(const iterator& x) : List_iterator_base(x.M_node) {}

	reference operator*() const { return ((Node*)M_node)->M_data; }
	pointer operator->() const { return &(operator*()); }

	Self& operator++() {
		this->M->incr();
		return *this;
	}

	Self operator++(int) {
		Self tmp = *this;
		this->M_incr();
		return tmp;
	}

	Self& operator--() {
		this->M_decr();
		return *this;
	}

	Self operator--(int) {
		Self tmp = *this;
		this->M_Decr();
		return tmp;
	}
};

template<class T, class Ref, class Ptr>
List_iterator<T, Ref, Ptr> insert(List_iterator<T, Ref, Ptr> position, const T& x) {
	List_node<T>* tmp = M_create_node(x);
	tmp->M_next = position.M_node;
	tmp->M_prev = position.M_node->M_prev;
	position.M_node->M_prev->M_next = tmp;
	position.M_node->M_prev = tmp;
	return tmp;
}

template<class T, class Ref, class Ptr>
List_iterator<T, Ref, Ptr> insert(List_iterator<T, Ref, Ptr> position) {
	return insert(position, T());
}

template<class T, class Ref, class Ptr>
void push_front(const T& x) {
	insert(begin(), x);
}

template<class T, class Ref, class Ptr>
void push_front() {
	insert(begin());
}

template<class T, class Ref, class Ptr>
void push_back(const T& x) {
	insert(end(), x);
}

template<class T, class Ref, class Ptr>
void push_back() {
	insert(end());
}

template<class T, class Ref, class Ptr>
List_iterator<T, Ref, Ptr> erase(List_iterator<T, Ref, Ptr> position) {
	List_node_base* next_node = position.M_node->M_next;
	List_node_base* prev_node = position.M_node->M_prev;
	List_node* n = (List_node*)position.M_node;
	prev_node->M_next = next_node;
	next_node->M_prev = prev_node;
	Destory(&n->M_data);
	M_put_node(n);
	return iterator((List_node*)next_node);
}

int main()
{

	getchar();
	return 0;
}