MySTL实现之MyList

最新推荐文章于 2024-09-07 23:57:29 发布
原创 最新推荐文章于 2024-09-07 23:57:29 发布 · 1k 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#链表 #c++ #数据结构 #stl #学习
本文介绍了如何实现STL中的List容器，包括结点基类、迭代器和MyList类的详细设计。通过实例展示了插入、删除、遍历等操作，并提供了测试代码以验证功能的正确性。着重讨论了类的继承结构和指针操作，以及在实现过程中遇到的问题和解决方案。

MySTL实现

实现STL库中的基础容器及基本函数

文章目录

MyList

平时很少使用STL中的List容器，因此在实现的时候走了很多弯路，也借鉴了不少博主的实现方式，在结合自己的理解进行了实现。这个容器使用了多个类结合的方式，主要有三大部分，结点基类，迭代器，MyList类，最终MyList类提供对外接口，实现容器的构造，析构和一些基本成员函数。

MyList类图

一、结点的基类

​ 考虑到头节点不需要生成数据域，将结点拆分为指针域和数据域两个结构体表示，结构体内的变量默认为public，继承也是默认public。实现_list_base作为结点的基类，由该类实现对结点的操作。

/// <summary>
/// 指针域
/// </summary>
struct _list_node_pointer {
	_list_node_pointer* _m_next;//指向下一个
	_list_node_pointer* _m_pre;//指向上一个
};
/// <summary>
/// 数据域
/// struct中的变量默认public，继承默认public
/// </summary>
template <typename _T>
struct _list_node_data : public _list_node_pointer {//公有继承指针域
	_T _m_data;
};

template <typename _T>
class _list_node_base {
public:
	_list_node_data<_T>* m_head;
	_list_node_base() {
		m_head = new _list_node_data<_T>();
		m_head->_m_next = m_head;
		m_head->_m_pre = m_head;
	}
	_list_node_base(const _T& val) {
		m_head = new _list_node_data<_T>();
		m_head->_m_next = nullptr;
		m_head->_m_pre = nullptr;
		m_head->_m_data = val;
	}
	~_list_node_base() {
		m_head->_m_next = nullptr;
		m_head->_m_pre = nullptr;
		delete m_head;
	}
};

二、迭代器

迭代器是对指针的操作，为了实现对容器内的访问，在迭代器的实现中，只用指针域作为成员变量即可。实现了构造函数和多种符号的重载。存入基类指针，当需要访问数据域时，基类指针转为子类指针进而访问数据域。

/// <summary>
/// 迭代器的实现
/// 仅需包含一个指针域
/// 对指针进行操作
/// 重载一系列运算符号
/// </summary>
/// <typeparam name="_T"></typeparam>
template<typename _T>
class _list_iterator {
public:
	_list_node_pointer* _m_node;
	_list_iterator():_m_node(nullptr) {}
	_list_iterator(_list_node_pointer* _x) :_m_node(_x){}
	_list_iterator& operator++();//前++
	_list_iterator& operator++(int);//后++
	_list_iterator& operator--();//前--
	_list_iterator& operator--(int);//后--
	_T operator*()const;
	_list_node_data<_T>* operator->()const;
	bool operator!=(const _list_iterator& it) const;
	bool operator==(const _list_iterator& it) const;
};
template<typename _T>
_list_iterator<_T>& _list_iterator<_T>::operator++() {
	_m_node = _m_node->_m_next;
	return *this;
}
template<typename _T>
_list_iterator<_T>& _list_iterator<_T>::operator++(int) {
	_list_iterator old = *this;
	++(*this);
	return old;
}
template<typename _T>
_list_iterator<_T>& _list_iterator<_T>::operator--() {
	_m_node = _m_node->_m_pre;
	return *this;
}
template<typename _T>
_list_iterator<_T>& _list_iterator<_T>::operator--(int) {
	_list_iterator old = *this;
	--(*this);
	return old;
}
template<typename _T>
_T _list_iterator<_T>::operator*() const{
	return ((_list_node_data<_T>*)_m_node)->_m_data;
}
template<typename _T>
_list_node_data<_T>* _list_iterator<_T>::operator->() const {
	return ((_list_node_data<_T>*)_m_node);
}
template<typename _T>
bool _list_iterator<_T>::operator!=(const _list_iterator& it) const {
	return _m_node != it._m_node;
}
template<typename _T>
bool _list_iterator<_T>::operator==(const _list_iterator& it) const {
	return _m_node == it._m_node;
}

三、MyList类

STL中的List是双链表，有一个头节点不存任何数据，仅作为标识。begin()是返回头节点的下一个，end()是返回头节点。发生删除时需要考虑当前List是否为空，并且不能删掉头节点。

删除很好理解，跳过pos结点，前后结点相连即可。对于插入则需要小心，先连好一边再连最后一个，不然中间会断开找不到前驱结点或后继结点，按图中步骤即可在pos前插入val结点。

双链表插入

在MyList类保护继承结点基类（ _list_node_base），类中实现了构造函数、析构函数和基本的成员函数，为了方便得到容器的size，将容器长度设为变量，初始化为0。头节点引用基类成员m_head，生成新结点时调用基类构造函数，并由数据域类型（ _list_node_data）的指针指向。

template<typename _T>
class MyList :protected _list_node_base<_T> {
public:
	typedef _list_node_data<_T> list_node;
	typedef _list_iterator<_T> iterator;
	typedef _list_node_base<_T> _Base;
protected:
	using _Base::m_head;//结点的指针表示一个双链表
	size_t len;//结点数量
public:
	MyList() :_list_node_base<_T>(),len(0) {};//调用父类默认构造函数
	//有参构造函数
	MyList(size_t _n, const _T& val = _T()) :_list_node_base<_T>(), len(0) {
		for (size_t i = 0; i < _n; i++) {
			insert(begin(), val);
		}
	}
	~MyList() {
		clear();
	}
	/// <summary>
	/// 清空容器
	/// </summary>
	void clear() {
		while (!empty()) {
			pop_back();
		}
	}
	/// <summary>
	/// 返回头结点的下一个
	/// </summary>
	/// <returns></returns>
	iterator begin() {
		return (list_node*)m_head->_m_next;//最后结果为list_node*类型，将其包装为迭代器类型，通过父类指针调用子类构造函数
	}
	/// <summary>
	/// 返回头节点
	/// </summary>
	/// <returns></returns>
	iterator end() {
		return (list_node*)m_head;
	}
	/// <summary>
	/// 获取list长度
	/// </summary>
	/// <returns></returns>
	size_t size() const {
		return len;
	}
	/// <summary>
	/// 判断list是否为空
	/// </summary>
	/// <returns></returns>
	bool empty() const {
		return len == 0;
	}
	/// <summary>
	/// 在pos位插入值为val的结点
	/// </summary>
	/// <param name="pos"></param>
	/// <param name="val"></param>
	/// <returns></returns>
	iterator insert(iterator pos, const _T& val) {
		_Base* b = new _Base(val);
		list_node* _tmp = b->m_head;
		_tmp->_m_next = pos._m_node;
		pos._m_node->_m_pre->_m_next = _tmp;
		_tmp->_m_pre = pos._m_node->_m_pre;
		pos._m_node->_m_pre = _tmp;
		++len;
		return _tmp;
	}
	/// <summary>
	/// 删除pos位的结点
	/// </summary>
	/// <param name="pos"></param>
	/// <returns></returns>
	iterator erase(iterator pos) {
		if (!empty()) {
			list_node* node_next = (list_node*)pos._m_node->_m_next;
			pos._m_node->_m_pre->_m_next = pos._m_node->_m_next;
			pos._m_node->_m_next->_m_pre = pos._m_node->_m_pre;
			//清除结点
			--len;
			return (iterator)node_next;
		}
		else {
			throw "超出list长度！";
		}
	}
	/// <summary>
	/// 在begin位置插入结点
	/// </summary>
	/// <param name="val"></param>
	void push_front(const _T& val = _T()) {
		insert(begin(), val);
	}
	/// <summary>
	/// 在end位置插入结点
	/// </summary>
	/// <param name="val"></param>
	void push_back(const _T& val = _T()) {
		insert(end(), val);
	}
	/// <summary>
	/// 删除begin位置结点
	/// </summary>
	void pop_front() {
		erase(begin());
	}
	/// <summary>
	/// 删除end位置的上一个结点
	/// </summary>
	void pop_back() {
		erase(--end());
	}
};

四、测试

对于MyList中实现的函数进行了简单测试

#include"MyList.h"
#include<iostream>
int main() {
	MyList<int> list1;
	list1.insert(list1.begin(), 1);
	list1.insert(list1.begin(), 2);
	list1.push_back(3);
	list1.push_back(4);
	list1.push_front(5);
	list1.push_front(6);
	std::cout << "List1：" << std::endl;
	std::cout << "List1.size：" << list1.size() << std::endl;
	for (auto it = list1.begin(); it != list1.end(); ++it) {
		std::cout << *it << std::endl;
	}
	list1.erase(list1.begin());
	list1.pop_back();
	list1.pop_front();
	std::cout << "删除后List1.size：" << list1.size() << std::endl;
	std::cout << "删除后List1：" << std::endl;
	for (auto it = list1.begin(); it != list1.end(); ++it) {
		std::cout << *it << std::endl;
	}
	MyList<int> list2(10, 2);
	std::cout << "List2.size：" << list2.size() << std::endl;
	std::cout << "List2：" << std::endl;
	for (auto it = list2.begin(); it != list2.end(); ++it) {
		std::cout << *it << std::endl;
	}
	if (list2.empty()) {
		std::cout << "List2为空" << std::endl;
	}
	else {
		std::cout << "List2不为空" << std::endl;
	}
	return 0;
	
}

总结

简单实现了List容器，对于这个容器使用不多，理解不深，很多概念还是在实现中学到的，其中一些类的设计方法理解还不够深入，发现自己对于指针的使用还有一些问题。在这次实现中，类的成员变量都声明为public了，为了在MyList中可以使用基类对象指针调用其变量，进而可以让数据域指针指向。

_Base* b = new _Base(val);
list_node* _tmp = b->m_head;

该句通过基类构造函数统一构造结点，但是牺牲了安全性，基类成员变量都改为public了。
接下来会实现deque容器及相关函数，MyList类的完整文件在该仓库（如果对你有帮助欢迎star和fork或者你发现了问题都可以在仓库提交问题）也可以从这里下载。

MyList.rar
10-24
c++实现双向链表，新增节点，修改节点，删除节点，打印链表，冒泡排序
java代码实现mapreduce中的map、reduce、filter方法
qianyulin
01-18 1885
实现代码如下： public class MyList { public static void main(String[] args) { List&lt;Integer&gt; aa =new ArrayList&lt;&gt;(); aa.add(1); aa.add(2); aa.add(3); ...
Scala-模拟 Map 映射、Filter 过滤、Reduce 聚合
文文x的博客
09-06 372
package com.scala.A /** * 函数作为值、参数、返回值传递 * */ object scala_function_01 { def main(args: Array[String]): Unit = { def f(x: Int): Int = { //有参数，有返回值 println("f1被调用") x + 1 } //---------------------------------------------------------
Scala 集合类的应用【Map映射、filter过滤、化简、折叠、扫描、拉链、迭代器、stream流、View试图、并行集合、操作符】
shuyv的博客
11-25 1204
文章目录Map 映射的操作应用1. 实际需求2. 高阶函数解决实际需求3. 使用map映射来解决 Map 映射的操作应用 1. 实际需求 一个实际需求：请将 List(3, 5, 7) 中的所有元素都 * 2，将其结果放到一个新的集合中返回，即返回一个新的 List(6, 10, 14) 。 传统方法代码如下： object MapOperateDemo01 { def main(args: Array[String]): Unit = { val list1 = List(3, 5, 7)
java8 stream List集合的常用流操作
lucky_fd的博客
03-27 3424
filter方法用于通过设置条件过滤出满足条件的元素。以下代码片段使用filter方法过滤出空字符串。count 方法用于统计集合内对象的数量，以下代码片段使用filter方法过滤出空字符串并计数。distinct 方法用于去掉重复数据。以下代码片段使用filter方法过滤出空字符串并去重。sorted方法用于对流进行排序。以下代码片段使用sorted方法对集合中的数字进行排序。分组的字段按照TreeMap的规则进行排序放入Map，底层是TreeMap。map方法用于映射每个元素到对应的结果。
自定义 STL list模板类 —— MyList 实现
浪子花梦
12-16 1344
MyList 实现 STL 中list 将元素按顺序储存在链表中，与 向量 相比，它允许快速的插入和删除，但是随机访问却比较慢。本文将实现简单的 list功能。 头文件及其命名空间 #include <iostream> #include <memory> // 内存配置器包含的头文件 需要用到 using namespace std; 内存适配器可以点击 all...
Python 列表(list)的使用
威风的风的博客
03-25 8555
创建list myList = [2,3,1,5,6,8] print(myList) #可以存储不同类型元素 myList1 = ['ab','bed',34,2,3.23] print(myList1) 运行结果： 访问list中元素 #访问list中元素 myList = [2,3,1,5,6,8] #访问第二个元素 second_num = myList[1] print(second...
Python列表List
最新发布
weixin_72431427的博客
09-07 769
如何创建、访问、修改和操作Python中的列表。
list模拟实现
l2894的博客
01-24 460
list底层是一个个的节点相互连接的，物理空间不连续，不能像vector一样使用原生指针，所以必须封装底层的节点指针，再重载对应的操作符达到我们想要的效果。stl容器中的list底层是双向循环带头链表，所以插入删除效率很高，但不支持随机访问，而vector支持随机访问，但除了尾插尾删的其他插入删除效率低。
C++实现MyList
LSFAN0213的博客
08-26 1241
上篇文章我们用C++封装了一个动态顺序表： https://blog.csdn.net/LSFAN0213/article/details/82082436 这次，我们用C++的方式来封装一个双向循环链表 与我们之前提到的单链表不同的是，双向循环链表的指针域中又多了一个指向前一个结点的pPre指针。这就是双向的意思 循环的意思是，链表的最后一个结点的下一个结点是头结点，头结点的前一个结点是...
python学习（二）
chlik的博客
07-16 401
元组，列表，字典，set，检测参数，X进制转换为10进制。。。
一文学会Python 数据结构：详解list、tuple、set、dict 和字符串的高级操作
weixin_43263566的博客
02-19 1490
Python数据容器、list列表、tuple元组、str字符串、数据容器（序列）切片、set集合
Flutter学习笔记之Dart集合类型详解
程序媛
03-31 853
前言 学习教程地址 系统：macOS 软件：Android Studio 4.1.2 Dart的语法类似C语言，可以转译为JavaScript。 一、List 1、List常用属性 List myList=['香蕉','苹果','西瓜']; print(myList.length);//length长度--3 print(myList.isEmpty);//isEmpty是否为空--true print(myList.isNotEmpty);//isNotEmpty是否不
vue系列组件篇（二）
debug
05-22 780
本文通过一个实例来介绍vue组件的用法，有父子组件传参，函数调用，组件插槽等。
python进阶之路——list(列表)
qq_60899598的博客
04-14 1415
1.列表的概念 列表是ptyhon里的一种可以储存多种数据的数据类型，列表里的元素可以不同：数字，字符串，元组，字典，甚至是列表,各个元素间用逗号分隔，一同放在括号[]里。 2.列表的创建 列表的创建很简单： my_list=[] #建立一个空列表 print(my_list) #输出[] my_list=['age',17,'LIKE'] #给列表赋值 print(my_list) #输出['age', 17, 'LIKE'] 3.列表的操作 1.访问 类似于c++的数组，列表也可以用下标
c# --- 实现MyList列表
qq_51947882的博客
08-18 522
建立两个数组引用，把一个置为Null另一个不置为NULL，不置为NULL的存储数据，当存满的时候我们通过新容量数据来创建新的数组然后将新数组的引用传给置为NULL的数组引用，然后把就数据拷贝到新数组中，然后再将指向就数组的引用置为Null，下次容量再更新的时候就变成它承接新数组的引用了，就这样不断循环，至于开辟的内存空间的释放问题不需要我们担心，系统会自动帮我们释放。其实也可以不用上面这么麻烦。然后，Equals方法中能够传的比较参数的类型必须和调用它的对象的类型一致，这是在方法设计的时候就规定好的。...
Python基础-Python列表
嗷嗷卷的博客
01-09 2764
Python列表基础知识
任务卡_02-面向对象_第4节 面向对象高级
&再见萤火虫&的博客
09-21 769
目录 一，面向对象高级训练任务 1， 代码 2， 代码 二，猜拳游戏训练任务 描述 代码 一，面向对象高级训练任务 1， 假设用户账号为：admin，密码为 123，编写用户登陆案例。 要 求：请将登陆定义为 login 方法， 并将 login 方法写在 UserService 类中 代码 UserService.java package com.kaikeba.demo1; public class UserService { private String use.
实现MyList类
万里归来少年心
07-30 4483
   自己动手实现了MyList类，主要包含的操作有： Capacity 获取容量大小 Count 获取元素个数 Add 添加元素 Insert 插入元素 RemoveAt 删除指定位置的元素 [] 索引器访问元素 IndexOf 取得元素的索引位置，从前向后搜索，找到元素时即返回。找不到元素时，返回-1。 LastIndexOf 取得元素的索引位置，从后向前搜索，找到元素时即返回...
【Godot4.2】有序和无序列表函数库 - myList
巽的博客
04-27 1659
在打印输出或其他地方可能需要构建有序或无序列表。本质就是构造和维护一个纯文本数组。并用格式化文本形式，输出带序号或前缀字符的多行文本。为此我专门设计了一个类myList，来完成这项任务。有一个参数，可以传入自定义的列表符号：print(list.get_UL_string("*")) # 自定义无序列表符号* 这是一个无序列表项 * 这是一个无序列表项 * 这是一个无序列表项 * 这是一个无序列表项 * 这是一个无序列表项 * 这是一个无序列表项 * 这是一个无序列表项 * 这是一个无序列表项。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jiaoooooo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值