C++ list 的模拟实现

已于 2024-10-03 21:28:49 修改
阅读量943 收藏 11
点赞数 10
文章标签： c++
于 2024-10-02 14:20:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68102654/article/details/142675037
版权

文章目录

list 实现接口总览

template <class T>
class list {
public:
	typedef ListNode<T> Node;
	typedef Iterator<T, T&, T*> iterator;
	typedef Iterator<T, const T&, const T*> const_iterator;
	typedef Reverse_Iterator<iterator, T&, T*> reverse_iterator;
	typedef Reverse_Iterator<const_iterator, const T&, const T*> const_reverse_iterator;

	//默认函数
	list();
	list(size_t n, const T& val = T());
	template <class InputIterator>
	list(InputIterator first, InputIterator last);
	list(const list<T>& lst);
	list<T>& operator=(const list<T>& lst);
	~list();

	//插入和删除
	void push_back(const T& val);
	void pop_back();
	void push_front(const T& val);
	void pop_front();
	iterator insert(iterator pos, const T& val);
	void insert(iterator pos, size_t n, const T& val);
	template <class InputIterator>
	void insert(iterator pos, InputIterator first, InputIterator last);
	iterator erase(iterator pos);
	iterator erase(iterator first, iterator last);

	//迭代器相关函数
	iterator begin();
	iterator end();
	const_iterator begin()const;
	const_iterator end()const;
	const_iterator cbegin()const;
	const_iterator cend()const;
	reverse_iterator rbegin();
	reverse_iterator rend();
	const_reverse_iterator rbegin()const;
	const_reverse_iterator rend()const;
	const_reverse_iterator crbegin()const;
	const_reverse_iterator crend()const;

	//访问元素函数
	T& front();
	const T& front()const;
	T& back();
	const T& back()const;

	//容器大小控制
	size_t size()const;
	void reszie(size_t n, const T& val = T());
	bool empty()const;
	void clear();

	//容器操作函数
	template <class Compare = bool(const T&, const T&)>
	void sort(Compare comp = compare_sort);
	
	void splice(iterator pos, list<T>& lst);
	void splice(iterator pos, list<T>& lst, iterator it);
	void splice(iterator pos, list<T>& lst, iterator first, iterator last);
	
	void remove(const T& val);
	template <typename Compare = bool(const T&)>
	void remove_if(Compare comp);

	template <class Compare = bool(const T&, const T&)>
	void unique(Compare comp = compare_unique);

	template <class Compare = bool(const T&, const T&)>
	void merge(list& lst, Compare comp = compare_sort);

	void reverse();

	void assign(size_t n, const T& val);
	template <class InputIterator>
	void assign(InputIterator first, InputIterator last);

	void swap(list& lst);

	template<class... Arg>
	iterator emplace(iterator pos, Arg&&... args);

private:
	bool compare_sort(const T& val1, const T& val2) {
		return val1 <= val2;
	}
	bool compare_unique(const T& val1, const T& val2) {
		return val1 == val2;
	}
	Node* _node;		//头结点
};

⭕️注意：

  1. list 是一个带头结点的双向循环链表，其头结点不含有效元素

  2. 为了防止与 C++ 中已有的 list 冲突，我们将自己模拟实现的 list 放到自己的命名空间

  3. 所有成员函数均在类外实现

一、节点类的实现

🍀list 节点类只需要实现构造函数即可，其析构在 list 容器类实现

template <class T>
struct ListNode {
	//构造函数
	ListNode(const T& val = T()) 
		:_val(val)
		, _next(nullptr)
		, _prev(nullptr) {}
	
	//成员变量
	T _val;
	ListNode* _next;
	ListNode* _prev;
};

🍀这里也可以使用 class 定义节点类，但是需要实现获取其成员变量的方法，或者将其设置成 list 的友元类，从而实现其他非类内函数获取成员变量

template <class T>
class ListNode {
public:
	ListNode(const T& val = T()) 
		:_val(val)
		,_next(nullptr)
		,_prev(nullptr) 
	{}
	ListNode*& next() {
		return this->_next;
	}
	ListNode*& prev() {
		return this->_prev;
	}
	T& get_val() {
		return this->_val;
	}
private:
	T _val;
	ListNode* _next;
	ListNode* _prev;
};

二、迭代器的实现

🍀与前面 vector 和 string 不同，我们不能再将迭代器直接定义为如下：

template <class T>
class list {
	typedef ListNode Node;
	//方式 1
	typedef Node* iterator;
	//方式 2
	typedef T* iterator;

	//else...
};

⭕️注意：

  1. 上面两种方式都是错误的，对于 vector 或者 string，其迭代器就是容器元素类型指针的重命名，所以对迭代器进行 ++ 或 -- 操作就是对指针进行这些操作，这些操作可以使指针（也就是迭代器）指向容器下一个元素所在的位置

  2. 对于 list ，如果直接将节点 Node* 设置成迭代器，那么对其进行 ++ 或 -- 操作不能实现将迭代器（指针）指向下一个元素所在位置，因为 list 的节点是离散存储的，正确操作应该如下（伪代码）：

typedef Node* iterator;

iterator = iterator->_next;		//实现 ++ 操作
iterator = iterator->_prev		//实现 -- 操作

🍀所以正确做法是，将正向迭代器封装成一个类，方向迭代器作为正向迭代器的适配器（类似于 vector 迭代器的第二种实现方法）。具体代码实现如下：

//正向迭代器
template <class T, class Ref, class Ptr>
struct Iterator {
	typedef ListNode<T> Node;
	typedef Iterator<T, Ref, Ptr> self;
	Iterator(Node* it) :_it(it) {}

	self& operator++() {
		_it = _it->_next;
		return*this;
	}
	self operator++(int) {
		Node* tmp = _it;
		_it = _it->_next;
		return self(tmp);
	}
	self& operator--() {
		_it = _it->_prev;
		return *this;
	}

	self operator--(int) {
		Node* tmp = _it;
		_it = _it->_prev;
		return self(tmp);
	}
	Ref operator*() {
		return _it->_val;
	}
	Ptr operator->() {
		return &_it-_val;
	}
	bool operator==(const self& it) {
		return it._it == _it;
	}
	bool operator!=(const self& it) {
		return it._it != _it;
	}
	Node* _it;
};
//反向迭代器
template <class Iterator, class Ref, class Ptr>
struct Reverse_Iterator {
	typedef Reverse_Iterator<Iterator, Ref, Ptr> self;
	Reverse_Iterator(Iterator it) :_it(it) {}

	self& operator++() {
		++_it;
		return *this;
	}
	self operator++(int) {
		self tmp(_it++);
		return tmp;
	}
	self& operator--() {
		--_it;
		return *this;
	}
	self operator--() {
		self tmp(_it--);
		return tmp;
	}
	Ref operator*() {
		return *_it;
	}
	Ptr operator->() {
		return _it;
	}
	bool operator==(const self& it) {
		return it._it == _it;
	}
	bool operator!=(const self& it) {
		return it._it != it;
	}
	
	Iterator _it;
};
//list 容器中
template <class T>
class list {
public:
	typedef ListNode<T> Node;
	typedef Iterator<T, T&, T*> iterator;
	typedef Iterator<T, const T&, const T*> const_iterator;
	typedef Reverse_Iterator<iterator, T&, T*> reverse_iterator;
	typedef Reverse_Iterator<const_iterator, const T&, const T*> const_reverse_iterator;
	//else...
private:
	Node* _node;
);

🍀说明：

  1. 上面的实现方法在 vector 中已经说过一次，这里不在赘述

  2. 这里设计的迭代器的拷贝构造都是浅拷贝，因为拷贝的是迭代器的成员变量（节点指针），并没有拷贝这个节点

  3. 迭代器不需要实现析构函数，因为其不需要释放节点，这是 list 容器需要考虑的问题

  4. 关于 operator->()：我们返回的是节点的指针（Node*），因为事实上，一个类指针使用 -> 访问成员变量时，就会先调用其实现的 operator-> 返回这个类的指针，然后再通过整个指针访问数据，例如：

class Date {
	public:
		int day;
};
Date* d = new Date;
d->day;		//相当于 d->operator->()->day 或者 d->->day
//但是这样太别扭，所以编译器进行了优化，可以直接写成 d->day

🍀总结：迭代器的意义就是让使用者可以不用关系容器底层实现，可以用简单统一的方式对容器进行访问，但是如果 list 将迭代器定义成节点指针（Node*），那么就与其意义不符

三、list 的模拟实现

默认成员函数

构造函数
template <typename T>
list<T>::list() :_node(nullptr) {
	_node = new Node;	//申请头结点
	_node->_next = _node;
	_node->_prev = _node;
}

template <typename T>
template <typename InputIterator>
list<T>::list(InputIterator first, InputIterator last) {
	_node = new Node;
	Node* prev = _node;
	for (InputIterator it = first; it != last; it++) {
		Node* cur = new Node(*it);
		prev->_next = cur;
		cur->_prev = prev;
		prev = cur;
	}
	prev->_next = _node;
	_node->_prev = prev;
}

template <typename T>
list<T>::list(size_t n, const T& val) :_node(nullptr) {
	_node = new Node;
	_node->_next = _node;
	_node->_prev = _node;
	resize(n, val);
}

🍀注意：第三个构造函数应当还要实现两个重载（具体原因可以看 vector 的模拟实现）：

list<T>::list(int n, const T& val);

list<T>::list(long n, const T& val);
拷贝构造函数
template <typename T>
list<T>::list(const list<T>& lst) {
	_node = new Node;
	_node->_next = _node;
	_node->_prev = _node;
	for (const auto& e : lst) {
		push_back(e);
	}
}
赋值运算符重载 operator=

下面提供两种写法：

//传统写法
template <typename T>
list<T>& list<T>::operator=(const list<T>& lst) {
	if (&lst != this) {
		clear();
		for (const auto& e : lst) {
			push_back(e);
		}
	}
	return *this;
}
//现代写法
template <typename T>
list<T>& list<T>::operator=(const list<T>& lst) {
	if (&lst != this) {
		list<T> tmp(lst);
		::swap(_node, tmp._node);
	}
	return *this;
}
析构函数
template <typename T>
list<T>::~list() {
	clear();
	delete _node;	//释放头结点
	_node = nullptr;
}

迭代器相关函数

template <typename T>
typename list<T>::iterator list<T>::begin() {
	return iterator(_node->_next);
}

template <typename T>
typename list<T>::iterator list<T>::end() {
	return iterator(_node);
}

template <typename T>
typename list<T>::const_iterator list<T>::begin()const {
	return const_iterator(_node->_next);
}

template <typename T>
typename list<T>::const_iterator list<T>::end()const {
	return const_iterator(_node);
}

template <typename T>
typename list<T>::const_iterator list<T>::cbegin()const {
	return const_iterator(_node->_next);
}

template <typename T>
typename list<T>::const_iterator list<T>::cend()const {
	return const_iterator(_node);
}

template <typename T>
typename list<T>::reverse_iterator list<T>::rbegin() {
	return reverse_iterator(iterator(_node->_prev));
}

template <typename T>
typename list<T>::reverse_iterator list<T>::rend() {
	return reverse_iterator(iterator(_node));
}

template <typename T>
typename list<T>::const_reverse_iterator list<T>::rbegin()const {
	return const_reverse_iterator(const_iterator(_node->_prev));
}

template <typename T>
typename list<T>::const_reverse_iterator list<T>::rend()const {
	return const_reverse_iterator(const_iterator(_node));
}

template <typename T>
typename list<T>::const_reverse_iterator list<T>::crbegin()const {
	return const_reverse_iterator(const_iterator(_node->_prev));
}

template <typename T>
typename list<T>::const_reverse_iterator list<T>::crend()const {
	return const_reverse_iterator(const_iterator(_node));
}

访问容器相关函数

front() 和 back()

⭕️注意：front() 和 back() 返回的均为引用

template <typename T>
T& list<T>::front() {
	assert(!empty());
	return _node->_next->_val;
}
template <typename T>
const T& list<T>::front()const {
	assert(!empty());
	return _node->_next->_val;
}

template <typename T>
T& list<T>::back() {
	assert(!empty());
	return _node->_next->_val;
}
template <typename T>
const T& list<T>::back()const {
	assert(!empty());
	return _node->_next->_val;
}

容器元素的插入和删除

insert()
template <typename T>
typename list<T>::iterator list<T>::insert(iterator pos, const T& val) {
	Node* new_node = new Node(val);
	Node* pos_node = pos._it;
	pos_node->_prev->_next = new_node;
	new_node->_prev = pos_node->_prev;
	pos_node->_prev = new_node;
	new_node->_next = pos_node;
	return iterator(new_node);
}

template <typename T>
void list<T>::insert(iterator pos, size_t n, const T& val) {
	for (size_t i = 0; i < n; i++) {
		pos = insert(pos, val);
	}
}

template <typename T>
template <typename InputIterator>
void list<T>::insert(iterator pos, InputIterator first, InputIterator last) {
	for (InputIterator it = first; it != last; it++) {
		insert(pos, *it);
	}
}
erase()
template <typename T>
typename list<T>::iterator list<T>::erase(iterator pos) {
	Node* pos_node = pos._it;
	pos_node->_prev->_next = pos_node->_next;
	pos_node->_next->_prev = pos_node->_prev;
	Node* ret = pos_node->_next;
	delete pos_node;
	pos_node = nullptr;
	return iterator(ret);
}

template <typename T>
typename list<T>::iterator list<T>::erase(iterator first, iterator last) {
	for (iterator it = first; it != last;) {
		it = erase(it);
	}
	return last;
}
push_back() 和 pop_back()
template <typename T>
void list<T>::push_back(const T& val) {
	Node* new_node = new Node(val);
	_node->_prev->next = new_node;
	new_node->_prev = _node->_prev;
	_node->_prev = new_node;
	new_node->_next = _node;
}

template <typename T>
void list<T>::pop_back() {
	if (!empty()) {
		Node* target = _node->_prev;
		_node->_prev = target->_prev;
		target->_prev->_next = _node;
		delete target;
		target = nullptr;
	}
}
push_front() 和 pop_front()
template <typename T>
void list<T>::push_front(const T& val) {
	Node* new_node = new Node(val);
	_node->_next->_prev = new_node;
	new_node->_next = _node->_next;
	new_node->_prev = _node;
	_node->_next = new_node;
}

template <typename T>
void list<T>::pop_front() {
	if (!empty()) {
		Node* target = _node->_next;
		_node->_next = target->_next;
		target->_next->_prev = _node;
		delete target;
		target = nullptr;
	}
}

容器大小相关函数

size() 和 resize()
template <typename T>
size_t list<T>::size()const {
	Node* first = _node->_next;
	size_t size = 0;
	while (first != _node) {
		++size;
		first = first->_next;
	}
	return size;
}

template <typename T>
void list<T>::resize(size_t n, const T& val) {
	if (size() <= n) {
		insert(end(), n - size(), val);
	}
	else {
		//未重载 iterator 的 - 操作，会报错
		erase(end() - size() + n, end());		
	}
}
empty() 和 clear()
template <typename T>
bool list<T>::empty()const {
	return _node->_next == _node;
}

//删除容器中所有有效元素（不删除头结点）
template <typename T>
void list<T>::clear() {
	erase(begin(), end());
}

容器操作函数

sort()
template <class T>
class list {
public:
	//函数模板参数设置缺省值
	template <class Compare = bool(const T&, const T&)>
	void sort(Compare comp = compare_sort);
	//else...
private:
	//默认升序排序的比较函数	
	bool compare_sort(const T& val1, const T& val2) {
		return val1 <= val2;
	}
	//else...
};

template <typename T>
template <typename Compare>
void list<T>::sort(Compare comp) {
	//使用选择排序这里只交换元素值，不交换整个节点
	for (iterator first = begin(); first != end(); first++) {
		for (iterator it = first; it != end(); it++) {
			if (!comp(first._it->_val, it._it->_val)) {
				::swap(first._it->_val, it._it->_val);
			}
		}
	}
}

🍀说明：

  1. 这里我们的排序只实现了交换节点里面的值，并没有交换整个节点

  2. 我们在 list 类中实现了一个进行升序排序的比较函数，并将其设置为 sort() 函数的缺省值，所以 sort() 函数可以默认实现升序排序

splice()
template <typename T>
void list<T>::splice(iterator pos, list<T>& lst, iterator first, iterator last) {
	//insert(pos, first, last);	 //error
	Node* first_prev = first->_it->_prev;
	Node* pos_node = pos->_it;
	for (iterator it = first; it != last; it++) {
		Node* it_node = it->_it;
		it_node->_prev = pos_node->_prev;
		pos_node->_prev->_next = it_node;
		it_node->_next = pos_node;
		pos_node->_prev = it_node;
	}
	//删除 lst 中已经拼接的元素
	first_prev->_next = last._it;
	last._it->_prev = first_prev;
}

template <typename T>
void list<T>::splice(iterator pos, list<T>& lst, iterator it) {
	splice(pos, lst, it, it + 1);
}

template <typename T>
void list<T>::splice(iterator pos, list<T>& lst) {
	splice(pos, lst.begin(), lst.end());
}

🍀说明：

  1. 我们不能使用 insert(pos, first, last)，因为该函数的节点是在插入时临时 new 出来的，而 splice() 中的插入到容器中的节点是另外一个容器中已经存在的节点

  2. 当容器被拼接后，需要删除被拼接的元素节点，但并不是真的删除（delete），而是改变相应的节点 next 和 prev 指针指向

remove 和 remove_if
template <typename T>
void list<T>::remove(const T& val) {
	for (iterator it = begin(); it != end(); it++) {
		if (*it == val) {
			erase(it);
		}
	}
}

template <class T>
class list {
public:
	//else...
	template <class Compare = bool(const T&)>
	void remove_if(Compare comp);
private:
	//else...
};
template <typename T>
template <typename Compare>
void list<T>::remove_if(Compare comp) {
	for (iterator it = begin(); it != end(); it++) {
		if (comp(*it)) {
			erase(it);
		}
	}
}
unique()
template <class T>
class list {
public:
	template <class Compare = bool(const T&, const T&)>
	void unique(Compare comp = compare_unique);
private:
	bool compare_unique(const T& val1, const T& val2) {
		return val1 == val2;
	}
	//else...
}

template <typename T>
template <typename Compare>
void list<T>::unique(Compare comp) {
	for (iterator it = begin() + 1; it != end();) {
		iterator target = it++;
		if (comp(*it, *(it - 1))) {
			erase(target);
		}
	}
}
merge()
template <typename T>
template <typename Compare>
void list<T>::merge(list& lst, Compare comp) {
	iterator start = lst.begin();
	while (start != lst.end()) {
		iterator it = begin();
		while (it != end()) {
			if (comp(*start, *it)) {
				splice(it, lst, start);
				break;
			}
		}
		if (it == end()) {
			insert(end(), start, lst.end());
			break;
		}
		start++;
	}
}
reverse()
template <typename T>
void list<T>::reverse() {
	size_t size = size();
	Node* last = _node->_prev;
	Node* first = _node->_next;
	for (size_t i = 0; i < size; i++) {
		first->_prev = last;
		last->_next = first;
		first = last;
		last = last->_prev;
	}
	_node->_next = first;
	_node->_prev = last;
}
assign()
template <typename T>
void list<T>::assign(size_t n, const T& val) {
	clear();
	resize(n, val);
}

template <typename T>
template <typename InputIterator>
void list<T>::assign(InputIterator first, InputIterator last) {
	clear();
	insert(begin(), first, last);
}
swap()
template <typename T>
void list<T>::swap(list& lst) {
	::swap(_node, lst._node);
}

完整代码

list.h 文件

#pragma once
#include <cassert>
namespace yw {
	//节点类
	template <class T>
	struct ListNode {
		ListNode(const T& val = T()) :_val(val), _next(nullptr), _prev(nullptr) {}
		T _val;
		ListNode* _next;
		ListNode* _prev;
	};
	//正向迭代器
	template <class T, class Ref, class Ptr>
	struct Iterator {
		typedef ListNode<T> Node;
		typedef Iterator<T, Ref, Ptr> self;
		Iterator(Node* it) :_it(it) {}

		self& operator++() {
			_it = _it->_next;
			return*this;
		}
		self operator++(int) {
			Node* tmp = _it;
			_it = _it->_next;
			return self(tmp);
		}
		self& operator--() {
			_it = _it->_prev;
			return *this;
		}
		self operator--(int) {
			Node* tmp = _it;
			_it = _it->_prev;
			return self(tmp);
		}
		Ref operator*() {
			return _it->_val;
		}
		Ptr operator->() {
			return _it;
		}
		bool operator==(const self& it) {
			return it._it == _it;
		}
		bool operator!=(const self& it) {
			return it._it != _it;
		}
		Node* _it;
	};
	//反向迭代器
	template <class Iterator, class Ref, class Ptr>
	struct Reverse_Iterator {
		typedef Reverse_Iterator<Iterator, Ref, Ptr> self;
		Reverse_Iterator(Iterator it) :_it(it) {}

		self& operator++() {
			++_it;
			return *this;
		}
		self operator++(int) {
			self tmp(_it++);
			return tmp;
		}
		self& operator--() {
			--_it;
			return *this;
		}
		self operator--() {
			self tmp(_it--);
			return tmp;
		}
		Ref operator*() {
			return *_it;
		}
		Ptr operator->() {
			return _it;
		}
		bool operator==(const self& it) {
			return it._it == _it;
		}
		bool operator!=(const self& it) {
			return it._it != it;
		}
		
		Iterator _it;
	};
	//list 容器
	template <class T>
	class list {
	public:
		typedef ListNode<T> Node;
		typedef Iterator<T, T&, T*> iterator;
		typedef Iterator<T, const T&, const T*> const_iterator;
		typedef Reverse_Iterator<iterator, T&, T*> reverse_iterator;
		typedef Reverse_Iterator<const_iterator, const T&, const T*> const_reverse_iterator;

		//默认函数
		list();
		list(size_t n, const T& val = T());
		template <class InputIterator>
		list(InputIterator first, InputIterator last);
		list(const list<T>& lst);
		list<T>& operator=(const list<T>& lst);
		~list();

		//插入和删除
		void push_back(const T& val);
		void pop_back();
		void push_front(const T& val);
		void pop_front();
		iterator insert(iterator pos, const T& val);
		void insert(iterator pos, size_t n, const T& val);
		template <class InputIterator>
		void insert(iterator pos, InputIterator first, InputIterator last);
		iterator erase(iterator pos);
		iterator erase(iterator first, iterator last);

		//迭代器相关函数
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;
		const_iterator cbegin()const;
		const_iterator cend()const;
		reverse_iterator rbegin();
		reverse_iterator rend();
		const_reverse_iterator rbegin()const;
		const_reverse_iterator rend()const;
		const_reverse_iterator crbegin()const;
		const_reverse_iterator crend()const;

		//访问元素函数
		T front()const;
		T back()const;

		//容器大小控制
		size_t size()const;
		void resize(size_t n, const T& val = T());
		bool empty()const;
		void clear();

		//容器操作函数
		template <class Compare = bool(const T&, const T&)>
		void sort(Compare comp = compare_sort);
		void splice(iterator pos, list<T>& lst);
		void splice(iterator pos, list<T>& lst, iterator it);
		void splice(iterator pos, list<T>& lst, iterator first, iterator last);
		void remove(const T& val);
		template <typename Compare>
		void remove_if(Compare comp = bool(const T&));

		template <class Compare = bool(const T&, const T&)>
		void unique(Compare comp = compare_unique);

		template <class Compare = compare_sort>
		void merge(list& lst, Compare comp);

		void reverse();

		void assign(size_t n, const T& val);
		template <class InputIterator>
		void assign(InputIterator first, InputIterator last);

		void swap(list& lst);

		template<class... Arg>
		iterator emplace(iterator pos, Arg&&... args);
		
	private:
		bool compare_sort(const T& val1, const T& val2) {
			return val1 <= val2;
		}
		bool compare_unique(const T& val1, const T& val2) {
			return val1 == val2;
		}
		Node* _node;		//头结点
	};
	//成员函数类外实现
	template <typename T>
	list<T>::list() :_node(nullptr) {
		_node = new Node;
		_node->_next = _node;
		_node->_prev = _node;
	}

	template <typename T>
	list<T>::list(size_t n, const T& val) :_node(nullptr) {
		_node = new Node;
		_node->_next = _node;
		_node->_prev = _node;
		resize(n, val);
	}
	
	template <typename T>
	template <typename InputIterator>
	list<T>::list(InputIterator first, InputIterator last) {
		_node = new Node;
		Node* prev = _node;
		for (InputIterator it = first; it != last; it++) {
			Node* cur = new Node(*it);
			prev->_next = cur;
			cur->_prev = prev;
			prev = cur;
		}
		prev->_next = _node;
		_node->_prev = prev;
	}

	template <typename T>
	list<T>::list(const list<T>& lst) {
		_node = new Node;
		_node->_next = _node;
		_node->_prev = _node;
		for (const auto& e : lst) {
			push_back(e);
		}
	}

	/*template <typename T>
	list<T>& list<T>::operator=(const list<T>& lst) {
		if (&lst != this) {
			clear();
			for (const auto& e : lst) {
				push_back(e);
			}
		}
		return *this;
	}*/

	template <typename T>
	list<T>& list<T>::operator=(const list<T>& lst) {
		if (&lst != this) {
			list<T> tmp(lst);
			::swap(_node, tmp._node);
		}
		return *this;
	}

	template <typename T>
	list<T>::~list() {
		clear();
		delete _node;
		_node = nullptr;
	}

	template <typename T>
	void list<T>::push_back(const T& val) {
		Node* new_node = new Node(val);
		_node->_prev->next = new_node;
		new_node->_prev = _node->_prev;
		_node->_prev = new_node;
		new_node->_next = _node;
	}

	template <typename T>
	void list<T>::pop_back() {
		if (!empty()) {
			Node* target = _node->_prev;
			_node->_prev = target->_prev;
			target->_prev->_next = _node;
			delete target;
			target = nullptr;
		}
	}

	template <typename T>
	void list<T>::push_front(const T& val) {
		Node* new_node = new Node(val);
		_node->_next->_prev = new_node;
		new_node->_next = _node->_next;
		new_node->_prev = _node;
		_node->_next = new_node;
	}

	template <typename T>
	void list<T>::pop_front() {
		if (!empty()) {
			Node* target = _node->_next;
			_node->_next = target->_next;
			target->_next->_prev = _node;
			delete target;
			target = nullptr;
		}
	}

	template <typename T>
	typename list<T>::iterator list<T>::insert(iterator pos, const T& val) {
		Node* new_node = new Node(val);
		Node* pos_node = pos._it;
		pos_node->_prev->_next = new_node;
		new_node->_prev = pos_node->_prev;
		pos_node->_prev = new_node;
		new_node->_next = pos_node;
		return iterator(new_node);
	}

	template <typename T>
	void list<T>::insert(iterator pos, size_t n, const T& val) {
		for (size_t i = 0; i < n; i++) {
			pos = insert(pos, val);
		}
	}

	template <typename T>
	template <typename InputIterator>
	void list<T>::insert(iterator pos, InputIterator first, InputIterator last) {
		for (InputIterator it = first; it != last; it++) {
			insert(pos, *it);
		}
	}

	template <typename T>
	typename list<T>::iterator list<T>::erase(iterator pos) {
		Node* pos_node = pos->_it;
		pos_node->_prev->_next = pos_node->_next;
		pos_node->_next->_prev = pos_node->_prev;
		Node* ret = pos_node->_next;
		delete pos_node;
		pos_node = nullptr;
		return iterator(ret);
	}

	template <typename T>
	typename list<T>::iterator list<T>::erase(iterator first, iterator last) {
		for (iterator it = first; it != last;) {
			it = erase(it);
		}
	}

	template <typename T>
	typename list<T>::iterator list<T>::begin() {
		return iterator(_node->_next);
	}

	template <typename T>
	typename list<T>::iterator list<T>::end() {
		return iterator(_node);
	}

	template <typename T>
	typename list<T>::const_iterator list<T>::begin()const {
		return const_iterator(_node->_next);
	}

	template <typename T>
	typename list<T>::const_iterator list<T>::end()const {
		return const_iterator(_node);
	}

	template <typename T>
	typename list<T>::const_iterator list<T>::cbegin()const {
		return const_iterator(_node->_next);
	}

	template <typename T>
	typename list<T>::const_iterator list<T>::cend()const {
		return const_iterator(_node);
	}

	template <typename T>
	typename list<T>::reverse_iterator list<T>::rbegin() {
		return reverse_iterator(iterator(_node->_prev));
	}

	template <typename T>
	typename list<T>::reverse_iterator list<T>::rend() {
		return reverse_iterator(iterator(_node));
	}

	template <typename T>
	typename list<T>::const_reverse_iterator list<T>::rbegin()const {
		return const_reverse_iterator(const_iterator(_node->_prev));
	}

	template <typename T>
	typename list<T>::const_reverse_iterator list<T>::rend()const {
		return const_reverse_iterator(const_iterator(_node));
	}

	template <typename T>
	typename list<T>::const_reverse_iterator list<T>::crbegin()const {
		return const_reverse_iterator(const_iterator(_node->_prev));
	}

	template <typename T>
	typename list<T>::const_reverse_iterator list<T>::crend()const {
		return const_reverse_iterator(const_iterator(_node));
	}

	template <typename T>
	T list<T>::front()const {
		assert(!empty());
		return _node->_next->_val;
	}
	template <typename T>
	T list<T>::back()const {
		assert(!empty());
		return _node->_next->_val;
	}

	template <typename T>
	size_t list<T>::size()const {
		Node* first = _node->_next;
		size_t size = 0;
		while (first != _node) {
			++size;
			first = first->_next;
		}
		return size;
	}

	template <typename T>
	void list<T>::resize(size_t n, const T& val) {
		if (size() <= n) {
			insert(end(), n - size(), val);
		}
		else {
			//未重载 iterator 的 - 操作，会报错
			erase(end() - size() + n, end());		
		}
	}

	template <typename T>
	bool list<T>::empty()const {
		return _node->_next == _node;
	}

	template <typename T>
	void list<T>::clear() {
		erase(begin(), end());
	}

	template <typename T>
	bool compare(const T& val1, const T& val2) {
		return val1 < val2;
	}
	template <typename T>
	template <typename Compare>
	void list<T>::sort(Compare comp) {
		//使用选择排序这里只交换元素值，不交换整个节点
		for (iterator first = begin(); first != end(); first++) {
			for (iterator it = first; it != end(); it++) {
				if (!comp(first._it->_val, it._it->_val)) {
					::swap(first._it->_val, it._it->_val);
				}
			}
		}
	}

	template <typename T>
	void list<T>::splice(iterator pos, list<T>& lst, iterator first, iterator last) {
		//insert(pos, first, last);		//error
		Node* first_prev = first->_it->_prev;
		Node* pos_node = pos->_it;
		for (iterator it = first; it != last; it++) {
			Node* it_node = it->_it;
			it_node->_prev = pos_node->_prev;
			pos_node->_prev->_next = it_node;
			it_node->_next = pos_node;
			pos_node->_prev = it_node;
		}
		//删除 lst 中已经拼接的元素
		first_prev->_next = last._it;
		last._it->_prev = first_prev;
	}

	template <typename T>
	void list<T>::splice(iterator pos, list<T>& lst, iterator it) {
		splice(pos, lst, it, it + 1);
	}

	template <typename T>
	void list<T>::splice(iterator pos, list<T>& lst) {
		splice(pos, lst.begin(), lst.end());
	}

	template <typename T>
	void list<T>::remove(const T& val) {
		for (iterator it = begin(); it != end(); it++) {
			if (*it == val) {
				erase(it);
			}
		}
	}

	template <typename T>
	template <typename Compare>
	void list<T>::remove_if(Compare comp) {
		for (iterator it = begin(); it != end(); it++) {
			if (comp(*it)) {
				erase(it);
			}
		}
	}

	template <typename T>
	template <typename Compare>
	void list<T>::unique(Compare comp) {
		for (iterator it = begin() + 1; it != end();) {
			iterator target = it++;
			if (comp(*it, *(it - 1))) {
				erase(target);
			}
		}
	}

	template <typename T>
	template <typename Compare>
	void list<T>::merge(list& lst, Compare comp) {
		iterator start = lst.begin();
		while (start != lst.end()) {
			iterator it = begin();
			while (it != end()) {
				if (comp(*start, *it)) {
					splice(it, lst, start);
					break;
				}
			}
			if (it == end()) {
				insert(end(), start, lst.end());
				break;
			}
			start++;
		}
	}

	template <typename T>
	void list<T>::reverse() {
		size_t size = size();
		Node* last = _node->_prev;
		Node* first = _node->_next;
		for (size_t i = 0; i < size; i++) {
			first->_prev = last;
			last->_next = first;
			first = last;
			last = last->_prev;
		}
		_node->_next = first;
		_node->_prev = last;
	}

	template <typename T>
	void list<T>::assign(size_t n, const T& val) {
		clear();
		resize(n, val);
	}

	template <typename T>
	template <typename InputIterator>
	void list<T>::assign(InputIterator first, InputIterator last) {
		clear();
		insert(begin(), first, last);
	}

	template <typename T>
	void list<T>::swap(list& lst) {
		::swap(_node, lst._node);
	}
}

test.cpp（测试）

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include "list.h"
using namespace yw;
int main() {
	list<int> lst;
	lst.push_back(1);
	lst.push_back(2);
	lst.push_back(3);
	lst.push_back(4);
	for (auto e : lst) {
		std::cout << e;
	}
	return 0;
}

说明：

  1. 本篇文章对 list 的实现并没有和前面 vector 和 string 一样，对每个接口进行详细的实现说明，因为其实现方法和前面相差不大

  2. 由于时间有限，该测试只是对模拟实现的 list 进行了编译运行，对于一些函数实现细节考虑欠缺

本篇文章到这里就结束啦，欢迎批评指正！

我只想睡懒觉
关注
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3235
简易版list模拟实现超详解
C++ 模拟实现list(迭代器)实现代码
01-01
C++ 模拟实现list(迭代器) 实现代码： #pragma once; #include #include #include using namespace std; template struct __ListNode { T _data; __ListNode* _next; __ListNode* _prev; __ListNode(const T&...
C++ list模拟实现
Han同学
12-25 3118
C++模拟实现list
【C++】list模拟实现
chuxinchangcun的博客
01-10 6271
由源码可以得知,list的底层是带头双向循环链表—list实际上是一个带头双向循环链表,要实现list,则首先需要实现一个结点类,而一个结点需要存储的信息为:数据、前驱指针、后继指针而对于该结点类的成员函数来说,我们只需实现一个构造函数即可,因为该结点类只需要根据数据来构造一个结点即可,而结点的释放则由list的析构函数来完成, 构造函数 构造函数直接根据所给数据构造一个结点即可,构造出来的结点的数据域存储的就是所给数据,而前驱指针和后继指针均初始化为空指针即可 若构造结点时未传入数据,则默认以list
C++ —— 模拟实现list
weixin_59913110的博客
12-03 890
模拟实现了list容器的常用接口，初步认识模板的用法。
【C++】list的模拟实现
qq_62939852的博客
03-11 1638
C++中，Listnode作为类名，而next和prev都是类指针，指针引用成员时使用->，而对象引用成员时使用 .若在数组上有一个int类型的指针，解引用是int类型的数据，再++可以加载下一个位置，因为物理空间是连续的。erase函数执行后，it所指向的节点被删除，因此it无效，在下一次使用it时，必须先给it赋值。同样若在链表上，解引用类型为 node，再++不能到下一个节点，因为物理空间不连续。++pnode，找到下一个节点的地址，但是下一个节点不一定是要的节点。
【C++】list的模拟实现【完整理解版】
m0_74044018的博客
09-10 1191
list的模拟实现，主讲你不理解的地方，每个地方都会详细解释，重在理解
【C++】List模拟实现
Renswc的博客
05-31 3141
C++中的list是一种双向链表（doubly linked list）的实现。它是C++标准库中的一种容器，可以存储一系列元素，并且允许在任意位置插入、删除和访问元素。对于双向链表有疑问的可以点击查看数据结构——带头双向循环链表详解对于list大部分和前面学习过的vector类似，关键点在于理解list的迭代器的封装以及const迭代器，还有list实现包括了三个类，它们分别都有类模板，容易绕晕，需要好好理解清楚
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 4744
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
【C++】list类模拟实现
qq_66314292的博客
11-09 2245
list类的模拟实现
C++——list的使用及其模拟实现
Forward♞的博客
01-28 1697
作为标准模板库中的容器，list同样也是一个类模板如果要定义一个list对象，就需要指定其存储的数据类型T。list
C++模拟实现list
03-11
C++模拟实现list
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 871
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 150
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 904
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C++：图的最短路径问题
han2205277149的博客
10-04 714
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 661
【C++】stack和queue的使用及注意事项
C - Separated Lunch
m0_74304371的博客
10-05 212
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
涂色问题 乘法原理（2024CCPC 山东省赛 C）
最新发布
2301_81888203的博客
10-05 518
乘法原理 涂色问题
C++模拟list实现与迭代器详解
C++ 模拟实现list（迭代器）是一种数据结构，用于管理动态大小的双向链表。在C++中，`list`通常由`std::list`库提供，但为了教学或理解底层工作原理，我们可以自定义一个简单的模拟实现。本文档主要关注两个关键部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值