list的模拟实现（一）

已于 2024-06-01 22:00:57 修改
阅读量816 收藏 7
点赞数 19
分类专栏： c++ 文章标签： list c++
于 2024-05-27 00:51:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83052144/article/details/139216557
版权

在这里插入图片描述

嗨喽大家好，时隔许久阿鑫又给大家带来了新的博客，list的模拟实现（一），下面让我们开始今天的学习吧！

list的模拟实现（一）

1.list splice接口的使用

2.list尾插的实现

3.list的迭代器模拟实现

4.const迭代器

5.insert和erase的模拟实现

1.list splice接口的使用

在这里插入图片描述

int main()
{
    std::list<int> mylist1;
    mylist1.push_back(1);
    mylist1.push_back(2);
    mylist1.push_back(3);
    mylist1.push_back(4);

    auto it = find(mylist1.begin(), mylist1.end(), 3);
    mylist1.splice(++mylist1.begin(), mylist1, it);//1324
    for (auto ch: mylist1)
    {
        cout << ch << " ";

    }
    cout << endl;
	return 0;
}

在这里插入图片描述

2.list尾插的实现

在这里插入图片描述

3.list的迭代器模拟实现

原生指针的++是连续的物理空间的++。
因为类能进行运算符重载，我直接对节点进行++达不到我的要求，所以我就将节点指针封装成一个类，这个类的行为就是遍历双向循环列表。
每一个类都有自己需要完成的事情，也可以是几个类互相搭配完成一件事情。

在这里插入图片描述

模板是不会被编译的，只有实例化的时候才会被编译
按需实例化，调用哪个函数才会实例化哪个函数
每个template定义的模板参数T都只能供当前类用


	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _date;

		ListNode(const T& date = T())
		:_next(nullptr)
		,_prev(nullptr)
		,_date(date)
		{}
	};

	template<class T>
	class ListIterator
	{
		typedef ListNode<T> Node;//此处传T的时候就相当于实例化
		typedef ListIterator<T> self;
	public:
		ListIterator(Node* node)//用一个节点的指针来构造
			:_node(node)
		{}
		//++it
		self& operator++()
{
	_node = _node->_next;
	return *this;
}

self operator++(int)//后置
{
	self tmp(*this);
	_node = _node->_next;
	return tmp;
}

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

self operator--(int)//后置
{
	self tmp(*this);
	_node = _node->_prev;
	return tmp;
}



T& operator*()
{
	return _node->_date;
}

T* operator->()
{
	return &_node->_date;
}


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

	private://成员是一个节点的指针，将指针封装成类来达到我们想要实现的操作
		Node* _node;
	};



	template<class T>
	class list
	{
		
	public:

		typedef ListNode<T> Node;
		typedef ListIterator<T> iterator;//若T为int相当于实例化了一个int类型的iterator

		iterator begin()
		{
			return iterator(_head->_next);
		}

		iterator end()
		{
			return iterator(_head);
		}
		
		list()
		{
			_head = new Node();
			_head->_next = _head;
			_head->_prev = _head;
		}

		void push_back(const T& x)
		{
			Node* newnode = new Node(x);
			Node* tail = _head->_prev;
			//head  2  3   tail  newnode
			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
		}

	private:
		Node* _head;

	};

iterator类不需要写析构函数，构造函数。节点是由链表管理的。（一般一个类不写析构函数，就不用写拷贝构造和赋值）

在C、C++等语言中，指针访问结构体（struct）或联合体（union）的成员时，我们使用箭头（->）操作符。而当我们**直接访问结构体或联合体的成员（即不通过指针）时，我们使用点（.）**操作符。

注意：对于->操作符，可以得到一个指向节点有效数据的指针（下图pos坐标（中存储的是行和列）类似于节点中的_date），应该如下图注释所进行调用，但是编译器为了可读性，强行省略了一个箭头

在这里插入图片描述

struct pos
{
	int _row;
	int _col;

	pos(int row = 0,int col = 0 )
		:_row(row)
		,_col(col)
	{}

};


void list_test2()
{

	list<pos> it1;
	it1.push_back(pos(100,200));
	it1.push_back(pos(200,300));
	it1.push_back(pos(300,400));

	list<pos>::iterator it = ++it1.begin();
	while (it != it1.end())
	{
		cout << it->_col << ":" << it->_row <<endl;
		it++;
	}
	cout << endl;
}

匿名对象的临时对象可以调用非const的成员函数

4.const迭代器

const迭代器不能是普通迭代器前加const
const迭代器目标本身可以修改，指向的内容不能修改，类似const T* p

注意：不能在模板参数T前加上const

在这里插入图片描述

第一种方式：

template<class T>
class ListConstIterator
{
	typedef ListNode<T> Node;//此处传T的时候就相当于实例化
	typedef ListConstIterator<T> self;
public:
	ListConstIterator(Node* node)//用一个节点的指针来构造
		:_node(node)
	{}
	//++it
	self& operator++()
	{
		_node = _node->_next;
		return *this;
	}

	self operator++(int)//后置
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	self operator--(int)//后置
	{
		self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}



	const T& operator*()
	{
		return _node->_date;
	}

	const T* operator->()
	{
		return &_node->_date;
	}


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

private://成员是一个节点的指针，将指针封装成类来达到我们想要实现的操作
	Node* _node;
};


template<class T>
class list
{
	
public:

	typedef ListNode<T> Node;
	typedef ListIterator<T> iterator;//若T为int相当于实例化了一个int类型的iterator
	typedef ListConstIterator<T> const_iterator;


	iterator begin()
	{
		return iterator(_head->_next);
	}

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

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

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

在这里插入图片描述

第二种方式：不同的模板参数表达的是不同的类，正如vector< int>和vector< double>表达的是两个不同的类

template<class T,class Ref,class Ptr>
class ListIterator
{
	typedef ListNode<T> Node;//此处传T的时候就相当于实例化
	typedef ListIterator<T,Ref,Ptr> self;
public:
	ListIterator(Node* node)//用一个节点的指针来构造
		:_node(node)
	{}
	//++it
	self& operator++()
	{
		_node = _node->_next;
		return *this;
	}

	self operator++(int)//后置
	{
		self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

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

	self operator--(int)//后置
	{
		self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}



	Ref operator*()
	{
		return _node->_date;
	}

	Ptr operator->()
	{
		return &_node->_date;
	}


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

private://成员是一个节点的指针，将指针封装成类来达到我们想要实现的操作
	Node* _node;
};

5.insert和erase的模拟实现

链表的insert没有迭代器失效，erase迭代器有失效

void push_back(const T& x)//尾插
{
	//Node* newnode = new Node(x);
	//Node* tail = _head->_prev;
	head  2  3   tail  newnode
	//tail->_next = newnode;
	//newnode->_prev = tail;
	//newnode->_next = _head;
	//_head->_prev = newnode;
	insert(end(), x);
}

iterator insert(iterator pos, const T& x)//插入
{
	//在pos位置之前插入节点
	//随机插入,先获得这个位置的指针
	Node* cur = pos._node;
	Node* prev = cur->_prev;
	Node* newnode = new Node(x);

	//prev  newnode cur  
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	//匿名对象
	//返回x的下一个节点的迭代器
	return iterator(newnode);
}

iterator erase(iterator pos)//删除
{//删除pos位置的节点
	assert(pos != end());//为1就不断言
	Node* cur = pos._node;
	//prev  cur  next
	Node* prev = cur->_prev;
	Node* next = cur->_next;
	 
	//prev cur next
	prev->_next = next;
	next->_prev = prev;
	delete cur;

	//返回删除位置的下一个迭代器
	return iterator(next);
}
//头插，尾删
//_head(end()) begin()
void pop_back()//尾删
{
	erase(--end());
}

void push_front(const T& x)//头插
{
	insert(begin(), x);
}

好啦，今天的内容我们就学习到这里，如果大家觉得阿鑫写的不错的话，记得留下你的一键三连哦，期待我们的下一次相遇！

筑基.
关注
  • 19
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3134
简易版list模拟实现超详解
C++模拟实现list
03-11
C++模拟实现list
【C++】list模拟实现
Suk_god的博客
04-23 1964
list容器的模拟实现
模拟实现list
weixin_58867976的博客
03-27 1678
目录 一、初始准备 二、迭代器 三、构造函数与析构函数 四、插入与删除数据 五、全部代码 一、初始准备 为了防止与库里的命名发生冲突，所以首先得定义一个命名空间 list是通过一个个节点连接而成的，所以得先定义一个自定义变量，采用模板的方式 这里实现的是带头双向循环链表，所以有前后指针成员，以及数据成员，共三个成员 同时定义构造函数，将其初始化 定义一个list类，同样采用模板，同时将其将要使用的正反迭代器，节点名称用typedef定义一个新名称，将其简化 成员就一个头.
C++ STL学习之【list的模拟实现】
北 海的博客
04-13 4281
STL中的list是一个双向带头循环链表，作为链表的终极形态，各项操作性能都很优秀，尤其是list中迭代器的设计更是让人拍案叫绝，如此优秀的容器究竟是如何实现的？本文将带你共同揭晓
【STL】list剖析及模拟实现
阿润菜菜的博客
03-11 3008
STL---list的剖析及模拟实现
【C++】STL容器：list的模拟实现
ermu的博客
01-14 5205
STL容器：list的模拟实现
C++中的list类【详细分析及模拟实现】
kevvviinn的博客
03-26 2908
本文介绍C++STL中的第三个容器——list类，详细介绍并使用库中为我们提供的接口，并配以多道测试实例帮助运用，然后我们深度剖析了如何模拟实现list类，包括设计思路以及方法的实现；最后比较了vector和list两种容器的优劣
【C++初阶】list模拟实现
weixin_47132900的博客
12-13 1059
Gitee：list模拟实现
C++ [STL之list模拟实现]
ARMCSKGT的博客
06-15 6372
list的底层与vector和string不同，实现也有所差别，特别是在迭代器的设计上，本节将为大家介绍list简单实现，并揭开list迭代器的底层！list模拟实现到这里就介绍了，本篇我们简单介绍了一下list的增删功能实现(与链表差别不大)，重点介绍了list的迭代器思想，深入理解list的迭代器可以让我们对类和对象又有进一步的认识，如果我们可以理解list迭代器思想，那么list的其他函数对于我们来说都不成问题！
List迭代器的模拟实现
weixin_46383092的博客
03-23 1714
list迭代器 反向迭代器 复用
List各个接口模拟实现
08-27
List各个接口模拟实现
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
C++ 模拟实现list(迭代器)实现代码
08-30
主要介绍了C++ 模拟实现list(迭代器)实现代码的相关资料,需要的朋友可以参考下
【CRASH】freelist异常导致的异常地址访问
最新发布
06-16 515
slab分配器的freelist异常导致的crash问题分析
Oracle 系列数据库使用 listagg去重，删除重复数据的几种方法
weimeilayer的博客
06-13 532
第三种：xmlagg(xmlparse(content t.tag_level || ‘,’ wellformed) order by t.tag_level)：使用 xmlagg 和 xmlparse 函数将 tag_level 字段聚合为一个用逗号分隔的字符串，并按 tag_level 排序。字符串长度更大：XMLAGG 可以处理比 LISTAGG 更大的字符串，因为生成的结果是 CLOB 类型，不受 4000 字符的限制。灵活性：支持更复杂的 XML 处理和格式化功能，适合需要复杂字符串操作的场景。
UniVue更新日志：使用ObservableList优化LoopList/LoopGrid组件的使用
m0_62135731的博客
06-11 994
在UniVue中使用两行代码实现UGUI中的最基操的操作：循环滚动、无限滚动。配上UniVue的数据模式双向绑定实现王炸效果。以及使用ObervableList实现基于数据驱动的UI实时响应的MVVM设计理念。
使用foreach和stream遍历并修改List列表
早安，朝气蓬勃的你
06-12 750
【代码】使用foreach和stream遍历并修改List列表。
Django ListView 列表视图类
人生苦短，何妨一试
06-10 904
这个命令会检查你的模型定义，并创建一个迁移文件，这个文件包含了将数据库从当前状态更新到新的模型定义所需的SQL命令。这个命令会执行迁移文件中的SQL命令，更新数据库的结构。打开命令行，进入你的Django项目的根目录。说明数据库表语句创建好了。django会自动创建好这些表，
c++模拟实现vector
09-01
引用和提供了关于实现vector的两种方法。其中，引用展示了一个使用reserve和push_back方法的示例，而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中，通过reserve函数可以预留足够的内存空间，然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配，提高了效率。 而第二种方法使用new操作符在堆上分配内存空间，并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式，可以实现深拷贝，即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法，还可以使用其他方式实现vector类。例如，可以使用动态数组来实现vector的底层数据结构，然后通过成员函数实现vector的各种操作，如增加、删除、查找等。 总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值