C++手动实现list

最新推荐文章于 2024-05-28 18:17:21 发布
最新推荐文章于 2024-05-28 18:17:21 发布
阅读量1.3k 收藏 9
点赞数
分类专栏： c/c++ 文章标签： c++ list 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50941083/article/details/122373335
版权

文章目录

在该部分我们将会实现C++中的list，如果对list相关知识不太了解，可以看一下之前总结过list的相关知识：C++容器：list

list中的成员函数总结

函数名功能
list()构造函数
~list()析构函数
list(const list& li)拷贝构造函数
list& operator=(const list& li)赋值运算符重载函数
void push_back(value_type val)向list对象尾部增添元素
void pop_back()删除list对象最后一个元素
void push_front(const_reference val)向list对象头部增添元素
void pop_front()删除list对象第一个元素
data_type front()const取出list对象中的第一个元素
data_type back()const取出list对象中的最后一个元素
iterator begin()获取list实例化对象的元素首地址
iterator end()获取list实例化对象的最后一个元素的下一个地址
size_t size()const获取list实例化对象的元素个数
bool empty() const判断list实例化对象是否为空
void clear()清空list中的元素

list中的成员变量

首先为了实现list可以实例化任意数据类型的对象，我们需要对它进行模板化，在类的定义之前增加如下语句：

template<typename T>

如我们想要实例化一个int型list的时候，使用list<int> li，此时模板中的T就是指int型数据类型，那么T*就是指int*数据类型。

我们可以在类中给这些和T相关的类型使用typedef起别名，代码如下：

public:
    typedef T data_type;
    typedef size_t  size_type;
    typedef T& refernce;
    typedef T* pointer;
    typedef const T& const_reference;
    typedef const T* const_pointer;

list本质上其实就是我们链表，以下就是我们实现list所用到的成员变量：

  • node: 节点，一个结构体，用于存放数据
  • _head: 头指针，指向list中的第一个节点
  • _tail : 尾指针，指向list中的最后一个节点
  • _size: list对象中的含有数据的节点个数

该部分相关代码如下：

private:
    struct node{  // 嵌套类结构体
        data_type data;
        node* _next;
        node* _prev;
        node():_next(NULL), _prev(NULL) {}
    };
    node* _head;
    node* _tail;
    size_type _size;

list的迭代器iterator

容器的迭代器用于遍历容器中的每一个元素，同时避免容器的内部数据结构和实现细节。迭代器的意义就是将容器与算法解除耦合，或者说是让数据与操作解除耦合。算法可以利用迭代器作为输入从而摆脱对容器具体数据的访问。

我们主要讲解一下关于对于迭代器it，自加和自减的具体实现，以前缀和后缀为两类。对于前缀即++it, --it，该表达式的值和it的值保持统一，我们直接改变该结点_cur的指向，返回this指针即可；但是对于后缀it++, it--，表达式的值是未改变前it的值，it将会进行更新，故而我们需要将_cur的值保存进一个临时变量，再更新_cur，返回临时变量。在实现的过程中，函数名中的圆括弧中有int的为后缀加减。

具体实现如下：

    class iterator {
        node* _cur;
    public:
        iterator(node* cur):_cur(cur){}
        data_type& operator*(){
           return _cur->data;
        }

        data_type* operator->(){
           return &_cur->data;
        }
        iterator operator++(){
           _cur = _cur->_next;
           return *this;
        }
        iterator operator--(){
           _cur = _cur->_prev;
           return *this;
        }
        iterator operator++(int){
           iterator temp(_cur);
           _cur = _cur->_next;
           return temp;
        }
        iterator operator--(int){
           iterator temp(_cur);
           _cur = _cur->_prev;
           return temp;
        }
        bool operator==(const iterator& it)const{
            return _cur == it._cur;
        }
        bool operator!=(const iterator& it)const{
            return _cur != it._cur;
        }
};

重要代码图解

我们在对list对象进行初始化的时候增加一个temp节点，使得链表的处理更加的简单统一。

    list(): _size(0){
        _head = _tail = new node;
    }

这一部分主要涉及双向链表的插入和删除问题，指针改向的顺序需要注意，如果顺序错误，就会挂链失败。

头插 – push_front

头插具体过程如图所示：下图第一个节点是temp节点，我们进行头插的时候将新的节点挂在该结点和下一个节点中间即可。

在这里插入图片描述

代码如下：

    void push_front(const_reference val) {
        node* cur = new node;
	    cur->data = val;
	    cur->_next = _head->_next;
	    cur->_prev = _head;
	    if(NULL == _head->_next) _tail = cur;
	    else _head->_next->_prev = cur;
	    _head->_next = cur;
	    ++_size;
    }

头删 – pop_front

头删具体过程如图所示：图第一个节点是temp节点，我们进行头删的时候删除的是该结点的下一个节点。

在这里插入图片描述
代码如下：

    void pop_front() {
        if(empty())  return;
	    node* first = _head->_next;
	    _head->_next = first->_next;
	    if(NULL == first->_next) _tail = _head;
	    else first->_next->_prev = _head;
	    delete first;
	    --_size;
    }

尾插 – push_back

具体过程如图所示：

在这里插入图片描述

代码如下：

    void push_back(const_reference val){
        node* cur = new node;
	    cur->data = val;
	    cur->_next = NULL;
	    cur->_prev = _tail;
	    _tail->_next = cur;
	    _tail = cur;
	    ++_size;
    }

尾删 – pop_back

在这里插入图片描述

    void pop_back() {
	    if(empty()) return;
        node* _prev = _tail->_prev;
        delete _tail;
        _prev->_next = NULL;
	    _tail = _prev;
	    --_size;
    }

代码总结

#include <iostream>
using namespace std;

namespace miniSTL{
template<typename T>
class list{
public:
    typedef T data_type;
    typedef size_t  size_type;
    typedef T& refernce;
    typedef T* pointer;
    typedef const T& const_reference;
    typedef const T* const_pointer;
private:   
    struct node{  // 嵌套类结构体
        data_type data;
	    node* _next;
	    node* _prev;
	    node():_next(NULL), _prev(NULL) {}
    };
    node* _head;
    node* _tail;
    size_type _size;
public:
    list(): _size(0){
        _head = _tail = new node;
    }
    list(const list& li){
        _head = _tail = new node;
	    node* p = li._head->_next;
	    while(p!=NULL){
	        push_back(p->data);
	        p = p->_next;
	    }
    }
    list& operator=(const list& li){
        if(this == &li) return *this;
	    clear();
	    node* p = li._head->_next;
	    while(p!=NULL){
	        push_back(p->data);
	        p = p->_next;
	    }
	    return *this;
    }
    void clear(){
	    node* p = _head->_next;
	    while(p!=NULL){
	        node* del = p;
	        p = p->_next;
	        delete del;
	    }
	    _tail = _head;
	    _size = 0;
    }
    ~list(){
        node* p = _head;
	    while(p!= NULL){
	        node* del = p;
	        p = p->_next;
	        delete del;
	    }
	    _size = 0;
    }
    size_type size() const { return _size; }
    bool empty() const { return _size == 0; }
    data_type front()const{ return _head->_next->data; }
    data_type back()const{ return _tail->data;}
    void push_back(const_reference val){
        node* cur = new node;
	    cur->data = val;
	    cur->_next = NULL;
	    cur->_prev = _tail;
	    _tail->_next = cur;
	    _tail = cur;
	    ++_size;
    }

    void pop_back() {
	    if(empty()) return;
        node* _prev = _tail->_prev;
        delete _tail;
        _prev->_next = NULL;
	    _tail = _prev;
	    --_size;
    }

    void push_front(const_reference val) {
        node* cur = new node;
	    cur->data = val;
	    cur->_next = _head->_next;
	    cur->_prev = _head;
	    if(NULL == _head->_next) _tail = cur;
	    else _head->_next->_prev = cur;
	    _head->_next = cur;
	    ++_size;
    }

    void pop_front() {
        if(empty())  return;
	    node* first = _head->_next;
    	_head->_next = first->_next;
    	if(NULL == first->_next) _tail = _head;
	    else first->_next->_prev = _head;
	    delete first;
	    --_size;
    }


    void Print()const{
        node* p = _head->_next;
	    while(NULL != p){
	        cout << p->data << " ";
	        p = p->_next;
	    }
	    cout << endl;
	    p = _tail;
	    while(_head!= p){
	        cout << p->data << " ";
	        p = p->_prev;
	    }
	    cout << endl;
    }

    // 迭代器
    
    class iterator {
        node* _cur;
    public:
	    iterator(node* cur):_cur(cur){}
        data_type& operator*(){
           return _cur->data;  
	    }

        data_type* operator->(){
           return &_cur->data;  
	    }
	    iterator operator++(){
	       _cur = _cur->_next;
	       return *this;
	    }
	    iterator operator--(){
	       _cur = _cur->_prev;
	       return *this;
	    }
	    iterator operator++(int){
	       iterator temp(_cur);
	       _cur = _cur->_next;
	       return temp;
	    }
	    iterator operator--(int){
	       iterator temp(_cur);
	       _cur = _cur->_prev;
	       return temp;
	    }
	    bool operator==(const iterator& it)const{
	        return _cur == it._cur;
	    }    
	    bool operator!=(const iterator& it)const{
	        return _cur != it._cur;
	    }
  };

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

using namespace miniSTL;
int main(){
    list<string> li;
    string n;
    while(cin >> n){
        // li.push_back(n);
        li.push_front(n);
    }

    list<string>::iterator it = li.begin();
    // cout << (it->data) << endl;
    while(it!=li.end()){
        cout << *it << " ";
	++it;
    }
    cout << endl;

    for(auto n:li){
        cout << n << " ";
    }
    cout << endl;

    list<string> li2 = li;
    list<string> li3;
    li3 = li;
    for(auto n:li3){
        cout << n << " ";
    }
    cout << endl;


    /*
    li.Print();

    while(!li.empty()){
        // li.pop_front();
	li.pop_back();
	li.Print();
    }
    */
}
大家好，我是好同学
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
list的讲解及模拟实现(c++)
weixin_49312527的博客
05-08 1789
与介绍vector时相同为了方便大家理解, 我们采用便模拟实现便讲解使用方式的方式, 展开对list容器的讲解. 一.list的介绍 使用时注意包含头文件: #include<list> list相关特性介绍: 1.list的底层是一个带头结点的双向循环链表. 2.list是可以在常数范围内在任意位置进行插入和删除的序列式容器, 并且该容器可以前后双向迭代. 3.list的底层是双向链表结构, 双向链表中每个元素存储在互不相关的独立节点中, 在节点中通过指针指向其前一个元素..
python调用c++ ctype list传数组或者返回数组的方法
09-19
需要注意的是，当处理数组时，Python的list和C++的数组是不同的数据结构。在Python中，列表可以动态扩展，但在C++中，数组长度是固定的。因此，如果C++函数需要返回一个数组，通常会通过指针参数来传递数组，由C++...
详解c++---list模拟实现
qq_68695298的博客
05-02 786
模拟实现c++中的list
C++入门篇(13)之list的实现
m0_51723227的博客
11-24 4175
文章目录前言list的结构搭建两种构造函数① 默认构建函数② 迭代器区间构建函数拷贝构造函数赋值重载数据的头尾删插① 尾插push_back()② 尾删pop_back()③ 头插push_front()④ 头删pop_front()迭代器的实现迭代器接口clear()清理析构函数erase和insert的实现and简化头尾数据删除最终list代码 前言 上一节我们简单叙述了一下list的概念,知道其底层是一个带头结点的双向循环链表,并且介绍了其使用方法,**但是!**知其然未必知其所以然,我们不但应该知其
实现C++中的list
最新发布
weixin_73757824的博客
05-28 640
实现 C++ 中的 list
C++--list简单实现
weixin_66828150的博客
07-18 717
vector:为动态顺序表，支持随机访问，空间利用率高，为原生指针，底层直接使用指针进行指针的加加，在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效。list: 为链式存储，不支持随机访问，空间利用率不高，为原生指针的封装，在插入元素使，迭代器不会失效，但在删除元素是，迭代器需要重新赋值，否则会失效，多应用于大量插入和删除操作，不关心随机访问。ps:要模拟实现list，必须要熟悉list的底层结构以及其接口的含义。
【 C++ 】list的模拟实现
bit_zyx的博客
08-21 600
目录 1、list三个基本模板类 2、结点类接口实现 基本框架 构造函数 3、迭代器类接口实现 3.1、正向迭代器 基本框架 默认成员函数 构造函数 * 运算符重载 ->运算符重载 ++运算符重载 --运算符重载 ...
c模拟c++ stl list
06-18
然而，为了在C语言中模拟`std::list`的功能，我们需要手动创建一个类似的结构并实现其核心操作。 以下是一个简化的C语言实现`std::list`的概述： 1. **数据结构**：首先，我们需要定义一个节点结构来存储数据以及...
C++完全学习资料 手动笔记！
02-25
这份"C++完全学习资料 手动笔记"包含了多个关键主题，旨在帮助初学者和有经验的开发者深入理解和掌握C++的核心概念。 首先，让我们从基础开始。C++的数组是存储相同类型元素集合的数据结构。在`13_C++的数组.md`中...
C++ STL实现包含常用stl模板的手动实现.zip
10-25
学习和手动实现STL模板，不仅可以锻炼你的编程能力，还能让你更好地掌握C++的面向对象特性、模板元编程和泛型编程。在实际工作中，理解并熟练运用STL能够提高代码质量，减少错误，使程序更加健壮和高效。因此，这个...
c++实现的模板队列
10-27
在C++中，我们可以利用STL（Standard Template Library）中的`queue`容器来实现队列，但为了理解队列的工作原理并实现自己的模板队列，我们需要手动创建一个模板类。以下是一个基本的模板队列实现： ```cpp #...
STL——list
原来45的博客
08-06 756
list的介绍 list的构造 list iterator的使用 list capacity list element access list modififiers list的迭代器失效 关于迭代器 list的模拟实现 main.cpp List.h
【C++】list的模拟实现
m0_62179366的博客
09-25 648
list的简单模拟实现
java中List的用法和实例详解
热门推荐
vaniice的专栏
12-28 27万+
<br />java中List的用法和实例详解<br />List的用法<br />List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口，所以List接口拥有Collection接口提供的所有常用方法，又因为List是列表类型，所以List接口还提供了一些适合于自身的常用方法，如表1所示。<br /><br />表1 List接口定义的常用方法及功能<br />从表1可以看出，List接口提供的适合于自身的常用方法均与索引有关，这是因为List集合为列表类型，
List接口如何实例化？（Java）
swordsmanye的博客
09-15 3331
List接口初始化 错误写法 List<String> supplierNames = new List<String>(); supplierNames.add("sup1"); supplierNames.add("sup2"); supplierNames.add("sup3"); System.out.println(supplierNames.get(1)); ...
手动实现List集合(ArrayList、LinkedList) 数组扩容和双向链表
coderlzy的博客
03-21 393
文章目录模拟实现List集合特别注意一、ArrayList实现二、LinkedList实现 模拟实现List集合 个人理解，大佬勿喷！为了巩固集合的基础，模拟一下List集合的实现过程(ArrayList和LinkedList都是线程不安全的，Vector实现步骤和ArrayList差不多，只是多了同步的操作，这里不做实现) 特别注意 这个手动实现的ArrayList和LinkedList的查询和删除都是 以当前第某个元素来操作，源码中以下标为第某个元素来操作的 。想要实现一样的，可以根据源码改。例如：查
List容器练习 排序案例
ネロ・クラウディウス
02-23 199
要求：将Person自定义数据类型进行排序，Person中有姓名，年龄，身高 排序规则：年龄升序，如果年龄相同在按照身高进行降序。 源码： #include <iostream> #include <list> #include <algorithm> using namespace std; class Person { public: Person(string name,int age,int height):m_Name(name),m_Age(age),m
【C++从入门到踹门】 第九篇：list的实现
qq_43041053的博客
03-18 1197
目录list的实现简单造个轮子（版本：1.0）🚩迭代器🚩list的迭代器 iterator🚩const_iterator针对const对象的迭代器合并两个迭代器版本 2.0🚩造一个好用的轮子（版本3.0）构造函数拷贝构造赋值运算符重载clear 函数insert 函数earse 函数push_front pop_back pop_front 函数🚩反向迭代器 （版本4.0）代码全貌 list的实现 简单造个轮子（版本：1.0） list在STL中的结构是一个带头双向链表，首先创建结点结构体作为链表单元：
自己实现c++ list模板类，亲测可用
Sun_tian的博客
07-19 1639
双向链表模板类 dlist.h #ifndef DLIST_H #define DLIST_H #include <iostream> #include <string> #include <stdexcept> using namespace std; template<typename T> class DList { struct node{ T data; node* next; node* prev; };
c++ 手动实现normalize
09-02
在C语言中，手动实现normalize操作可以通过计算向量的模长，并将向量的每个分量除以模长来实现。以下是一个实现normalize的代码示例： ```c #include void normalize(float vector * vector + vector * vector + ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值