C++：List的模拟实现

list.hpp

#pragma once
namespace MyList
{
	template<class T>
	struct ListNode
	{
		ListNode* _next;
		ListNode* _prev;
		T _data;

		ListNode(const T& x = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{
		}
	};

	template<class T, class Ref, class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;

		Node* _node;

		ListIterator(Node* node)
			:_node(node)
		{}

		Ref operator* ()
		{
			return _node->_data;
		}
		//(1)
		Ptr operator-> ()
		{
			return &(_node->_data);
		}

		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self operator++(int)
		{
			Self temp(*this);
			_node = _node->_next;
			return temp;
		}

		Self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		Self operator--(int)
		{
			Self temp(*this);
			_node = _node->_prev;
			return temp;
		}

		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}

		bool operator ==(const Self& it)
		{
			return _node == it._node;
		}
	};

	template<class T>
	class list
	{
		typedef ListNode<T> Node;
	public:
		typedef ListIterator<T, T&, T*> iterator;
		typedef ListIterator<T, const T&, const T*> const_iterator;

		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		//(3)
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}
		//lt2;
		list()
		{
			empty_init();
		}
		//lt2(lt1);
		list(const list<T>& lt)
		{
			empty_init();
			for (auto& e : lt)
			{
				push_back(e);
			}
		}
		//lt2=lt1;
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		  size_t size()const
		{
			return _size;
		}

		void empty()
		{
			return _size == 0;
		}

		//正向迭代器
		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}

		const_iterator begin()const
		{
			return const_iterator(_head->_next);
		}

		const_iterator end()const
		{
			return const_iterator(_head);
		}	
		
		//反向迭代器
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}

		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}

		void insert(iterator pos, const T& val)
		{
			Node* NewNode = new Node(val);
			Node* cur = pos._node;
			Node* prev = pos._node->_prev;

			prev->_next = NewNode;
			cur->_prev = NewNode;

			NewNode->_prev = prev;
			NewNode->_next = cur;


			_size++;
		}
		//(2)
		iterator erase(iterator pos)
		{
			Node* tail = pos._node->_next;
			Node* prev = pos._node->_prev;
			prev->_next = tail;
			tail->_prev = prev;
			delete pos._node;
			_size--;
			return iterator(tail);
		}

		void push_back(const T& x = T())
		{
			/*
			Node* NewNode = new Node(x);
			Node* cur = _head->_prev;

			NewNode->_prev = cur;
			NewNode->_next = _head;

			_head->_prev = NewNode;
			cur->_next = NewNode;

			_size++;
			*/

			insert(end(), x);
		}

		void push_front(const T& x = T())
		{
			/*
			Node* NewNode = new Node(x);
			Node* cur = _head->_next;

			NewNode->_prev = _head;
			NewNode->_next = cur;

			cur->_prev = NewNode;
			_head->_next = NewNode;

			_size++;
			*/
			insert(begin(), x);
		}

		void pop_back()
		{
			/*
			Node* temp = _head->_prev;
			_head->_prev = temp->_prev;
			temp->_prev->_next = _head;
			delete temp;

			_size--;
			*/
			erase(--end());
		}

		void pop_front()
		{
			/*
			Node* temp = _head->_next;
			_head->_next = temp->_next;
			temp->_prev = _head;
			delete temp;

			_size--;
			*/
			erase(begin());
		}

	private:
		Node* _head;
		size_t _size;
	};
}
#if 0
(1)
struct A
{
	int _a1;
	int _a2;

	A(int a1 = 0, int a2 = 0)
		:_a1(a1)
		, _a2(a2)
	{}
};

神奇!!！编译器省略了一个  '->'
cout << it->_a1 << ":" << it->_a2 << endl;
cout << it.operator->()->_a1 << ":" << it.operator->()->_a2 << endl;
相当于：
A a = { 1,2 };
A* p = &a;
cout << p->_a1 << ":" << p->_a2 << endl;
#endif
#if 0
(2)
注意迭代器失效的问题！！！
#endif
#if 0
(3)
需要析构，一般就需要自己写深拷贝!!!!
不需要析构，一般就不需要自己写深拷贝，默认浅拷贝就可以!!!
#endif

reverse_iterator .hpp

 

// 阻止头文件被多次包含
#pragma once

// 定义一个命名空间 MyList
namespace MyList
{
    // 定义一个模板结构体 ReverseIterator，用于实现反向迭代器
    template<class Iterator, class Ref, class Ptr>
    struct ReverseIterator
    {
        // Self 类型定义为当前结构体的类型，便于在结构体内部引用自身
        typedef ReverseIterator<Iterator, Ref, Ptr> Self;

        // 迭代器成员变量，存储当前迭代器的位置
        Iterator _it;

        // 构造函数，接受一个迭代器并初始化 _it 成员变量
        ReverseIterator(Iterator it) : _it(it) {}

        // 重载解引用操作符，返回反向迭代器所指向的元素的引用
        Ref operator*()
        {
            Iterator temp = _it; // 保存当前迭代器的副本
            return *(--temp);    // 后移迭代器并解引用，实现反向访问
        }

        // 重载成员访问操作符，返回反向迭代器所指向的元素的指针
        Ptr operator->()
        {
            return &(operator*()); // 通过解引用操作符返回地址
        }

        // 重载前置递增操作符，移动迭代器到前一个元素并返回迭代器自身
        Self& operator++()
        {
            --_it; // 后移迭代器
            return *this;
        }

        // 重载前置递减操作符，移动迭代器到后一个元素并返回迭代器自身
        Self& operator--()
        {
            ++_it; // 前移迭代器
            return *this;
        }

        // 重载后置递增操作符，创建当前迭代器的副本，后移副本迭代器，然后返回副本
        Self operator++(int)
        {
            Self temp(*this); // 创建当前迭代器的副本
            --_it;            // 后移副本迭代器
            return temp;      // 返回副本
        }

        // 重载后置递减操作符，创建当前迭代器的副本，前移副本迭代器，然后返回副本
        Self operator--(int)
        {
            Self temp(*this); // 创建当前迭代器的副本
            ++_it;           // 前移副本迭代器
            return temp;      // 返回副本
        }

        // 重载不等于操作符，比较两个反向迭代器是否不相等
        bool operator!=(const Self& s)
        {
            return _it != s._it; // 比较迭代器成员变量
        }

        // 重载等于操作符，比较两个反向迭代器是否相等
        bool operator==(const Self& s)
        {
            return _it == s._it; // 比较迭代器成员变量
        }
    };
}

用用看： 

更多学习代码： XiangChao (RuofengMao) - Gitee.com