10.list的模拟实现(普通迭代器和const迭代器的类模板)

1. list的介绍及使用

1.1 list的介绍

list的文档介绍

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器,并且该容器可以前后双向迭代。

  2. list的底层是双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向其前一个元素和后一个元素。

  3. listforward_list非常相似:最主要的不同在于forward_list是单链表,只能朝前迭代,已让其更简单高效。

  4. 与其他的序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率更好。

  5. 与其他序列式容器相比,list和forward_list最大的缺陷是不支持任意位置的随机访问,比如:要访问list的第6个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间开销;list还需要一些额外的空间,以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)

1.2 list的使用

头插、尾插、尾删、头删

#include <vector>
#include <algorithm>
#include <time.h>
#include <set>
using namespace std;#include "List.h"void test_list1()
{// 尾插list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);list<int>::iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";++it;}cout << endl;// 头插lt.push_front(10);lt.push_front(20);lt.push_front(30);lt.push_front(40);for (auto e : lt){cout << e << " ";}cout << endl;// 尾删lt.pop_back();lt.pop_back();// 头删lt.pop_front();lt.pop_front();for (auto e : lt){cout << e << " ";}cout << endl;lt.pop_back();lt.pop_back();lt.pop_back();lt.pop_back();//lt.pop_back();for (auto e : lt){cout << e << " ";}cout << endl;
}

insert的用法

void test_list2()
{list<int> lt;// 尾插lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);auto pos = find(lt.begin(), lt.end(), 3);if (pos != lt.end()){// insert就是在pos位置前插入一个节点// insert以后pos是否失效呢?(此处不存在失效)// 在vector中,扩容后,pos的形参发生改变,但是实参不会发生改变// 但是list是用链表结构,就算扩容,也不会使pos的形参发生变化lt.insert(pos, 30);}// 下面两个代码的测试可以发现,pos并不会失效cout << *pos << endl;(*pos)++;for (auto e : lt){cout << e << " ";}cout << endl;// 此处pos失效,因为pos指向的节点都被释放了,那么再访问pos指向的空间,就会造成野指针lt.erase(pos);//cout << *pos << endl;for (auto e : lt){cout << e << " ";}cout << endl;
}

remove的用法

void test_list3()
{list<int> lt;lt.push_back(10);lt.push_back(2);lt.push_back(5);lt.push_back(3);lt.push_back(4);lt.push_back(4);lt.push_back(6);lt.push_back(4);lt.push_back(3);for (auto e : lt){cout << e << " ";}cout << endl;// 打印结果为:10 2 5 3 4 4 6 4 3// void remove (const value_type& val);// 从容器中删除所有与 val 相等的元素。这将调用这些对象的析构函数,并按删除的元素数减小容器大小。// 因此,会将链表中val值为3的节点全部删除,并缩小容器的大小lt.remove(3);for (auto e : lt){cout << e << " ";}cout << endl;// 打印结果为:10 2 5 4 4 6 4lt.remove(30);for (auto e : lt){cout << e << " ";}cout << endl;// 打印结果为:10 2 5 4 4 6 4lt.sort();   // 链表自带的排序功能/*sort(lt.begin(), lt.end());   // 库里面自带的排序功能,参数为迭代器的起始和结束位置*/for (auto e : lt){cout << e << " ";}cout << endl;// 先排序,才能实现去重/*void unique();没有参数的版本从容器中每个连续的相等元素组中删除除第一个元素之外的所有元素。请注意,只有当元素与紧接其前面的元素相等时,才会从列表容器中删除该元素。因此,此函数对于排序列表特别有用。*/lt.unique();for (auto e : lt){cout << e << " ";}cout << endl;
}

vector和list排序速度的比较

void test_op()
{srand(time(0));const int N = 100000;// 创建一个vector对象,并提前预留足够大的空间vector<int> v;v.reserve(N);// 创建两个list对象list<int> lt1;list<int> lt2;for (int i = 0; i < N; ++i){// 将生成的随机数,尾插到两个链表中auto e = rand();//v.push_back(e);lt1.push_back(e);lt2.push_back(e);}// 将链表lt1中的数据,拷贝到vector对象v中int begin1 = clock();for (auto e : lt1){v.push_back(e);}// 使用std::sort对vector对象v中的数据进行排序sort(v.begin(), v.end());size_t i = 0;for (auto& e : lt1){// e是lt1数据的引用// 所以对e进行赋值,就是拷贝v中的数据到lt1中e = v[i++];}int end1 = clock();// 直接使用链表中自带的排序函数,对链表2中的数据进行排序int begin2 = clock();// sort(lt.begin(), lt.end());lt2.sort();int end2 = clock();printf("vector sort:%d\n", end1 - begin1);printf("list sort:%d\n", end2 - begin2);/*// 打印结果为:vector sort : 246list sort : 118*/// 综上可知,vector的排序速度是远大于list的排序速度的
}

2. list的模拟实现

list的私有成员变量

private:node* _head;  // 链表的头节点size_t _size; // 链表的大小

list_node(节点的类)

// 此处的T和list<T>是同一个模板参数
template<class T>
struct list_node
{// _next指向下一个节点list_node<T>* _next;// _prev指向前一个节点list_node<T>* _prev;// 该节点存放的数据T _data;// 节点的构造函数list_node(const T& x)   :_next(nullptr) , _prev(nullptr), _data(x){}
};

__list_iterator(迭代器的类)

迭代器的价值:
1.封装底层实现,不暴露底层实现的细节。
2.提供统一的访问方式,降低使用成本。
// 迭代器的类类型就是__list_iterator<T>
// 类名就是__list_iterator
template<class T>
struct __list_iterator        
{// list_node<T> 就是节点的类类型,将节点的类类型定义为nodetypedef list_node<T> node;// 定义了一个节点指针,但是并没有进行初始化node* _pnode;          // 迭代器的构造函数__list_iterator(node* p)   :_pnode(p)              // 使用传递的节点p来初始化_pnode{}// 迭代器的解引用// it为迭代器,(*it)++ 其实就是对_pnode->_data进行++, 因为是传引用返回// T会根据_pnode->_data的类型,实例化对应的类型T& operator*()              // 解引用,就是返回 _pnode->data{return _pnode->_data;}// 迭代器++// ++ 也就是返回_pnode->next指向节点的地址// 此处是传引用返回,因为_pnode->_next指向的节点存在于主函数中,// 所以传引用返回后依旧可以进行读写操作// __list_iterator<T>& 就是对迭代器对象的引用// __list_iterator<T>是迭代器的类型__list_iterator<T>& operator++()   {// 修改迭代器成员变量_pnode指向的节点_pnode = _pnode->_next;// this就是迭代器对象的指针// 返回*this,就是返回迭代器对象return *this;    }bool operator!=(const __list_iterator<T>& it){// 判断是否相等,也就是判断两个迭代器的_pnode是否相等,比较地址是否相等return _pnode != it._pnode;    }
};

__list_const_iterator(const迭代器的类)

// 跟普通迭代器的区别:遍历,不能用*it修改数据
// it就是迭代器对象,*it就是迭代器指向的节点的数据,
// 对于const迭代器,const修饰的是*it,因此对于*it只能读,不能够进行修改/*
1.const T* p1;   // const在*左侧,修饰的是*p1
2.T* const p2;   // const在*右侧,修饰的是p2
// const迭代器类似于第一种情况,保护指向的对象不被修改,但是迭代器本身是可以修改的注:普通迭代器前加const可不是const迭代器,如下:
const list<int>::iterator cit = lt.begin();
// 这里的const修饰的是cit,也就是保护迭代器本身不可以进行修改,那么就不可以对cit进行++,或者--的操作,这不符合迭代器的行为
*/
template<class T>
struct __list_const_iterator
{// list_node<T> 就是节点的类类型,将节点的类类型定义为nodetypedef list_node<T> node;// 定义了一个节点指针,但是并没有进行初始化node* _pnode;// const迭代器的构造函数__list_const_iterator( node* p):_pnode(p){}// const迭代器的解引用const T& operator*() {// 会根据_pnode->_data类型,来实例化const T& 的类型// const修饰的是返回值,因此返回值无法进行修改// 之所以可以进行引用返回,是因为_pnode->_data不会随着函数而结束自身的生命周期return _pnode->_data;}// const迭代器++// __list_const_iterator<T>是const迭代器的类型// __list_const_iterator<T>& 是对const迭代器对象的引用// 此处的返回值,可以被传引用返回__list_const_iterator<T>& operator++(){// 更新const迭代器对象的成员变量_pnode指向的节点_pnode = _pnode->_next;// 返回迭代器对象return *this;}// const迭代器--__list_const_iterator<T>& operator--(){_pnode = _pnode->_prev;return *this;}// const迭代器判断是否相等bool operator!=(const __list_const_iterator<T>& it){return _pnode != it._pnode;}
};

对普通迭代器和const迭代器的合并

// 我们发现迭代器和const迭代器,有大量的冗余代码,因此做出合并
/*
Ref 是reference的缩写
ref就是引用,ptr就是指针
template<class T, class Ref, class Ptr>同一个类模板实例化出的两个类型,
Ref可以被实例化为T&,也可以被实例化为const T&
Ptr可以被实例化为T*,也可以被实例化为const T*
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;如果是节点类型为 list<int>
则template<class T, class Ref, class Ptr>将被实例化为下面两种类类型
也就是将一个迭代器类模板,实例化为了两个类,一个普通迭代器的类,一个const迭代器的类
typedef __list_iterator<int, int&, int*> iterator;
typedef __list_iterator<int, const int&, const int*> const_iterator;
*/
template<class T, class Ref, class Ptr>
struct __list_iterator
{// 将节点的类类型定义为nodetypedef list_node<T> node;// 将迭代器的类类型定义为Selftypedef __list_iterator<T, Ref, Ptr> Self;// 定义了一个节点指针,但是并没有进行初始化node* _pnode;// 迭代器的构造函数__list_iterator(node* p):_pnode(p){}// 迭代器的->操作// 通过指针访问节点对象的成员变量data// 在主函数中,如果创建const迭代器,也就是 const_iterator cit(head->next)// 因为typedef __list_iterator<T, const T&, const T*> const_iterator;// template<class T, class Ref, class Ptr>// 所以Ptr对应的类型是const int*,// 如果链表的类类型是list<int>// 那么Ptr的类型是const int*,Ptr operator->(){ // _pnode是链表节点的指针// _pnode->_data,可以拿到链表节点存放的数据// &_pnode->_data,也就是取链表节点存放的数据的地址return &_pnode->_data;}/*// (详细看test_list5)下面这两种方法是等价的cout << it->_row << ":" << it->_col << endl;cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;// it-> 是一个函数调用,即it.operator->()// it.operator->() 的返回对象类类型是pos*,所以再次使用-> ,返回pos类型的成员变量row的值// 本来面貌:it->->_row,编译器为了可读性,做了特殊处理,省略了一个->*/// 同上,Ref的类型应该是const int&Ref operator*(){return _pnode->_data;}// ++it  前置// 因为typedef __list_iterator<T, Ref, Ptr> Self;所以Self就是一个迭代器的类类型Self& operator++(){_pnode = _pnode->_next;// 返回一个迭代器对象(++之后的迭代器对象)return *this;}// it++  后置:括号中的int为占位符Self operator++(int){// 使用this指针指向的迭代器对象构造一个临时的迭代器对象Self tmp(*this);_pnode = _pnode->_next;	// 返回++之前的迭代器对象,这个对象是一个临时对象,因此不可以进行传引用返回return tmp;}// 前置Self& operator--(){_pnode = _pnode->_prev;return *this;}// 后置:括号中的int为占位符Self operator--(int){Self tmp(*this);_pnode = _pnode->_prev;return tmp;}bool operator!=(const Self& it) const{return _pnode != it._pnode;}bool operator==(const Self& it) const{return _pnode == it._pnode;}
};

反向迭代器的类模板

// reverse_iterator.h
// 如果要使用反向迭代器,必须要使用反向迭代器的头文件
// 给我不同容器的正向迭代器,适配出对应的这个容器需要的反向迭代器
template<class Iterator, class Ref, class Ptr>
class ReverseIterator
{typedef ReverseIterator<Iterator, Ref, Ptr> Self;public:// 构造函数ReverseIterator(Iterator it):_it(it){}// 以list为例// begin() 对应的是 rend()  ;  begin() 指向首个元素 --> rend() 指向首个元素// end()   对应的是 rbegin() ; end() 指向的是哨兵位 --> rbegin() 指向的是哨兵位/*end()     begin()哨兵位        1      2      3      4rbegin()   rend()rend()                          rbegin()    进行--操作之后的位置*/// 因此  解引用指向的元素时,必须 --tmp// 因为begin() 进行--操作之后,与rbegin()对应的节点是一致的// 如 return reverse_iterator(begin()); 使用正向迭代器的开始迭代器 构造 反向迭代器的结束迭代器// 如果要进行解引用,--正向迭代器之后才是其正确的位置Ref operator*(){Iterator tmp = _it;return *(--tmp);}Ptr operator->(){return &(operator*());}Self& operator++(){// 反向迭代器的++对应正常迭代器的----_it;return *this;}Self& operator--(){++_it;return *this;}bool operator!= (const Self& s) const{return _it != s._it;}private:Iterator _it;
};

list双向链表的构造函数

/*
// 节点的构造函数
list_node(const T& x)   
:_next(nullptr) 
, _prev(nullptr)
, _data(x)
{}
*//*
list()
{// T()就是构造节点所需要的参数const T& x// T():也就是调用x的默认构造函数去初始化这个参数x // T():类型为x的一个匿名对象_head = new node(T());  _head->_next = _head;_head->_prev = _head;
}
*/void empty_initialize()
{_head = new node(T());_head->_next = _head;_head->_prev = _head;
}// 双向链表的无参构造函数
list()
{empty_initialize();
}

list::push_back, push_front, pop_front, pop_back

//尾插
void push_back(const T& x)
{// 方法一/*// 先创建一个新节点node* newnode = new node(x);   // _head->prev中存放的是tail节点的地址node* tail = _head->_prev;     // _head    newnode   tail// 将上面三个节点按顺序双向链接起来tail->_next = newnode;    newnode->_prev = tail;newnode->_next = _head;_head->_prev = newnode;*/// 方法二// 当我们实现insert()之后,我们就可以通过insert()来实现 push_back// 也就是在end()位置前插入insert(end(), x);
}
// 头插   
void push_front(const T& x)
{// 头插就是在begin()位置前插入insert(begin(), x);
}// 头删
void pop_front()
{// 头删就是删除begin()位置的节点erase(begin());
}// 尾删
void pop_back()
{// 尾删就是删除end()位置前的节点// --end() 会调用operator--erase(--end());
}    

list的拷贝构造函数的传统写法

void empty_initialize()
{_head = new node(T());_head->_next = _head;_head->_prev = _head;
}// lt3(lt1)
list(const list<T>& lt)
{// 初始化这个对象,也就是初始化lt3empty_initialize();// 将迭代器节点指向数据尾插到新对象中// lt是lt1的引用,也就是将lt1的数据尾插到lt3// 这样就实现了lt1到lt3的拷贝for (const auto& e : lt){push_back(e);}
}

list拷贝函数的现代写法

// 类名  类型
// 普通类  类名 等价于 类型
// 类模板  类名  不等价于  类型
// 如:list模板 类名是list  类型是list<T> 
// 类模板里面可以用类名代表类型,但是建议不要那么用//  构造函数(使用迭代器来构造对象)
// tmp(lt)
template <class InputIterator>  
list(InputIterator first, InputIterator last)   
{// 初始化这个对象,也就是初始化tmpempty_initialize();// first就是链表lt起始位置的迭代器对象// last就是链表lt结束位置的迭代器对象while (first != last){// 将迭代器的数据,尾插到新的链表tmp中push_back(*first);++first;}
}void swap(list<T>& lt)
{std::swap(_head, lt._head);std::swap(_size, lt._size);
}// 现代写法
// lt3(lt1)
list(const list<T>& lt)
{// 初始化这个对象,也就是初始化lt3empty_initialize();// 用it的迭代区间数据创建一个list的临时对象list<T> tmp(lt.begin(), lt.end());  // 再将临时对象与目标对象的_head,_size进行交换// 出了当前函数的作用域之后,tmp就会被销毁// 但是构造给tmp的资源都已经交给了lt3swap(tmp);                         
}

list对象的赋值重载

void clear()
{iterator it = begin();while (it != end()){// erase()会返回被删除节点的下一个节点的迭代器// 最后it就是end()位置的迭代器,那么就会跳出循环// end()位置的迭代器,也就是_head哨兵位节点的迭代器it = erase(it);   }
}// 传统写法
// lt2 = lt1
list<T>& operator=(const list<T>& lt)
{// lt就是lt1的传引用// this就是lt2的地址// this != &lt 就是判断lt2的地址是否与lt1的地址相等if (this != &lt)    {// 使用clear()清空双向循环链表中,除哨兵位的所有节点clear();for (const auto& e : lt)   // 此处使用传引用,就可以减少拷贝{// 将lt的数据,全部插入到lt2中push_back(e);}}// 返回lt2的迭代器对象return *this;
}// 现代写法
// lt3 = lt1
list<T>& operator=(list<T> lt)
//list& operator=(list lt) // 不建议
{swap(lt);return *this;
}

list::insert

// 在pos迭代器的节点位置前插入新节点
iterator insert(iterator pos, const T& x)
{node* newnode = new node(x);node* cur = pos._pnode;           // pos迭代器位置处的节点为 pos._pnodenode* prev = cur->_prev;          // 再找到cur的前一个节点// prev newnode cur          将这三个节点双向链接起来prev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;// 使用newnode构建一个迭代器,并返回这个迭代器对象return iterator(newnode);
}

list::erase

iterator erase(iterator pos)
{assert(pos != end());    // 保证链表不为空node* prev = pos._pnode->_prev;    // prev 为pos._pnode前一个节点的地址node* next = pos._pnode->_next;    // next 为pos._pnode后一个节点的地址// 将prev next双向链接起来prev->_next = next;next->_prev = prev;delete pos._pnode;    // 释放 pos._pnode节点// 返回 pos._pnode节点下一个节点的迭代器// 也就是返回,next节点构建的迭代器return iterator(next); 
}

list的析构函数

void clear()
{iterator it = begin();while (it != end()){// erase()会返回被删除节点的下一个节点的迭代器// 最后it就是end()位置的迭代器,那么就会跳出循环// end()位置的迭代器,也就是_head哨兵位节点的迭代器it = erase(it);   }
}~list()
{clear();delete _head;_head = nullptr;
}

list类的完整实现

template<class T>
class list
{typedef list_node<T> node;
public:// 迭代器的老版本// typedef __list_iterator<T> iterator;// typedef __list_const_iterator<T> const_iterator;// 迭代器的改良版本// typedef __list_iterator<T, T&> iterator;// typedef __list_iterator<T, const T&> const_iterator;// 再次改良迭代器// 此处的T和list<T>是同一个模板参数typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<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;reverse_iterator rbegin(){return reverse_iterator(end());}reverse_iterator rend(){return reverse_iterator(begin());}// 右侧的const修饰的是this指针const_iterator begin() const{// head是带头双向循环链表的哨兵位// _head->_next是双向链表的头节点// 使用头节点的指针构造一个迭代器的对象return const_iterator(_head->_next);}const_iterator end() const{// _head->next 是带头双向循环链表头节点// _head->prev 是带头双向循环链表的尾节点// end()是只迭代器的末尾位置,end是尾节点的下一个位置,也就是tail->next// tail->next就是哨兵位,也就是_headreturn const_iterator(_head);}iterator begin(){return iterator(_head->_next);}iterator end(){// iterator it(_head);// return it;return iterator(_head);   // 返回迭代器的匿名对象}void empty_initialize(){// 这里只能使用T的默认构造来对node进行构造// 因为此时,并不能确定T是什么类型// 如果T是int类型,那么T的默认构造,T()就是0_head = new node(T());_head->_next = _head;_head->_prev = _head;_size = 0;}// 链表的构造函数list(){empty_initialize();}// 传统的拷贝函数// lt2(lt1) /*list(const list<T>& lt){empty_initialize();for (const auto& e : lt){push_back(e);}}*/// 传统的赋值重载函数// lt1 = lt3//list<T>& operator=(const list<T>& lt)//{//	if (this != &lt)//	{//		clear();//		for (const auto& e : lt)//		{//			push_back(e);//		}//	}//	return *this;//}// 构造函数,通过迭代器来构造template <class InputIterator>  list(InputIterator first, InputIterator last){empty_initialize();while (first != last){push_back(*first);++first;}}// 自己写的交换函数void swap(list<T>& lt){std::swap(_head, lt._head);std::swap(_size, lt._size);}// 拷贝函数的现代写法// 普通类  类名 等价于 类型// 类模板  类名  不等价于  类型// 如:list模板 类名list  类型list<T> // 类模板里面(也就是类模板内部)可以用类名代表类型,但是建议不要那么用// 拷贝函数// lt2(lt1)list(const list<T>& lt)//list(const list& lt) // 不建议这么写,最好将类型写为list<T> {empty_initialize();list<T> tmp(lt.begin(), lt.end());swap(tmp);}// 赋值重载的现代写法// lt3 = lt1list<T>& operator=(list<T> lt)//list& operator=(list lt)    // 不建议这么写,最好将类型写为list<T> {swap(lt);return *this;}size_t size() const{return _size;}bool empty() const{return _size == 0;}~list(){clear();delete _head;_head = nullptr;}void clear(){iterator it = begin();while (it != end()){it = erase(it);}}void push_back(const T& x){//node* newnode = new node(x);//node* tail = _head->_prev; _head         tail   newnode//tail->_next = newnode;//newnode->_prev = tail;//newnode->_next = _head;//_head->_prev = newnode;insert(end(), x);}void push_front(const T& x){insert(begin(), x);}void pop_front(){erase(begin());}void pop_back(){erase(--end());}iterator insert(iterator pos, const T& x){node* newnode = new node(x);node* cur = pos._pnode;node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}iterator erase(iterator pos){assert(pos != end());node* prev = pos._pnode->_prev;node* next = pos._pnode->_next;prev->_next = next;next->_prev = prev;delete pos._pnode;--_size;return iterator(next);}private:node* _head;size_t _size;
};

3.测试

测试迭代器(test1)

void test_list1()
{list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);// iterator是类里面的类型,那么有如下两种情况// 1、内嵌类型     // 2、迭代器的行为是像指针一样// 对于vector的迭代器类型:typedef int* iterator;    // 迭代器++,跳过4个字节// 对于string的迭代器类型:typedef char* iterator;   // 迭代器++,跳过1个字节// vector和string的迭代器++,或者--之后,都可以找到对应的数据,因为其存储空间是连续的// 但是对于list却不能够像vector和list一样,因为每个节点的空间都是独立的,因此对于list的迭代器// 需要专门实现一个迭代器的类list<int>::iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";++it;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;
}

test_list5

struct Pos
{int _row;int _col;Pos(int row = 0, int col = 0):_row(row),_col(col){}
};void print_list(const list<Pos>& lt)
{// it就是链表的初始位置的迭代器// 在list类里面的定义:typedef __list_iterator<T, const T&, const T*> const_iterator;list<Pos>::const_iterator it = lt.begin();while (it != lt.end()){/*it-> 是一个函数调用,即it.operator->()it.operator->() 的返回对象类类型是const pos*,所以拿到的类型为pos的对象的值是不可以被修改的,因此const在*左侧,这个对象被const修饰再次使用-> ,返回pos类型的成员变量row的值本来面貌:it->->_row,编译器为了可读性,做了特殊处理,省略了一个->*/// 那么下面这行代码的使用就是错误的// it->_row++;cout << it->_row << ":" << it->_col << endl;++it;}cout << endl;
}void test_list5()
{// 创建一个链表对象,模版类型被实例化为pos类型list<Pos> lt;// 创建一个pos对象Pos p1(1, 1);// 将pos对象p1尾插到链表中lt.push_back(p1);lt.push_back(p1);lt.push_back(p1);// 构建一个匿名的pos对象,并将其尾插到链表中// 这个匿名的pos的生命周期,只在当前这一行,除了这一行,这个匿名对象就会被销毁lt.push_back(Pos(2,2));lt.push_back(Pos(3,3));// int* p  :  *p   可以通过解引用找到p指针所指向的数据// Pos* p  :  p->  可以通过-> 找到pos指针所指向的数据list<Pos>::iterator it = lt.begin();while (it != lt.end()){// pos为一个类,_row,_col为pos类的成员变量// 因为pos对象存放在链表中,所以*it 解引用就可以拿到类类型为pos的对象// 在通过这个对象来访问其成员变量cout << (*it)._row << ":" << (*it)._col << endl;// 当我们写了 ->的重载函数后// 使用-> 打印pos类中数据的三种方法/*cout << (&(*it))->_row << ":" << (*it)._col << endl;// *it 是pos; &(*it) 也就是pos*, 在通过pos*进行->操作找到_row的数据*//*// 下面这两种方法是等价的cout << it->_row << ":" << it->_col << endl;cout << it.operator->()->_row << ":" << it.operator->()->_col << endl;// it-> 是一个函数调用,即it.operator->()// it.operator->() 的返回对象类类型是pos*,所以再次使用-> ,返回pos类型的成员变量row的值// 本来面貌:it->->_row,编译器为了可读性,做了特殊处理,省略了一个->*/++it;}cout << endl;print_list(lt);
}

4.完整的模拟实现,并测试

namespace qwy
{// 链表的节点的类模板template<class T>struct list_node{list_node<T>* _next;list_node<T>* _prev;T _data;list_node(const T& x):_next(nullptr), _prev(nullptr), _data(x){}};// 迭代器的类模板// 同一个类模板实例化出的两个类,分别是普通迭代器的类和const迭代器的类// typedef __list_iterator<T, T&, T*> iterator;// typedef __list_iterator<T, const T&, const T*> const_iterator;template<class T, class Ref, class Ptr>struct __list_iterator{typedef list_node<T> node;typedef __list_iterator<T, Ref, Ptr> Self;node* _pnode;__list_iterator(node* p):_pnode(p){}Ptr operator->(){return &_pnode->_data;}Ref operator*(){return _pnode->_data;}Self& operator++(){_pnode = _pnode->_next;return *this;}Self operator++(int){Self tmp(*this);_pnode = _pnode->_next;		return tmp;}Self& operator--(){_pnode = _pnode->_prev;return *this;}Self operator--(int){Self tmp(*this);_pnode = _pnode->_prev;return tmp;}bool operator!=(const Self& it) const{return _pnode != it._pnode;}bool operator==(const Self& it) const{return _pnode == it._pnode;}};// 带头双向循环链表的类模板template<class T>class list{typedef list_node<T> node;public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;const_iterator begin() const{return const_iterator(_head->_next);}const_iterator end() const{return const_iterator(_head);}iterator begin(){return iterator(_head->_next);}iterator end(){return iterator(_head);}void empty_initialize(){_head = new node(T());_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_initialize();}template <class InputIterator>  list(InputIterator first, InputIterator last){empty_initialize();while (first != last){push_back(*first);++first;}}void swap(list<T>& lt){std::swap(_head, lt._head);std::swap(_size, lt._size);}// 拷贝构造的现代写法// lt2(lt1)list(const list<T>& lt){empty_initialize();list<T> tmp(lt.begin(), lt.end());swap(tmp);}// 负值重载的现代写法// lt3 = lt1list<T>& operator=(list<T> lt){swap(lt);return *this;}size_t size() const{return _size;}bool empty() const{return _size == 0;}~list(){clear();delete _head;_head = nullptr;}void clear(){iterator it = begin();while (it != end()){it = erase(it);}}void push_back(const T& x){//node* newnode = new node(x);//node* tail = _head->_prev; _head         tail   newnode//tail->_next = newnode;//newnode->_prev = tail;//newnode->_next = _head;//_head->_prev = newnode;insert(end(), x);}void push_front(const T& x){insert(begin(), x);}void pop_front(){erase(begin());}void pop_back(){erase(--end());}iterator insert(iterator pos, const T& x){node* newnode = new node(x);node* cur = pos._pnode;node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}iterator erase(iterator pos){assert(pos != end());node* prev = pos._pnode->_prev;node* next = pos._pnode->_next;prev->_next = next;next->_prev = prev;delete pos._pnode;--_size;return iterator(next);}private:node* _head;size_t _size;};void test_list1(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);// iterator 1、内嵌类型 2、行为像指针一样 list<int>::iterator it = lt.begin();while (it != lt.end()){cout << *it << " ";++it;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;}void test_list2(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_front(5);lt.push_front(6);for (auto e : lt){cout << e << " ";}cout << endl;lt.pop_back();lt.pop_back();lt.pop_front();lt.pop_front();for (auto e : lt){cout << e << " ";}cout << endl;}void test_list3(){list<int> lt;lt.push_back(1);lt.push_back(2);lt.push_back(3);lt.push_back(4);lt.push_front(5);lt.push_front(6);for (auto e : lt){cout << e << " ";}cout << endl;cout << lt.size() << endl;list<int> lt1(lt);for (auto e : lt1){cout << e << " ";}cout << endl;list<int> lt2;lt2.push_back(10);lt2.push_back(20);lt2.push_back(30);lt2.push_back(40);cout << lt2.size() << endl;lt = lt2;for (auto e : lt){cout << e << " ";}cout << endl;}void print_list(const list<int>& lt){list<int>::const_iterator it = lt.begin();while (it != lt.end()){// (*it) += 2; // 不能写cout << *it << " ";++it;}cout << endl;}void test_list4(){list<int> lt1;lt1.push_back(1);lt1.push_back(2);lt1.push_back(3);lt1.push_back(4);list<int>::iterator it = lt1.begin();while (it != lt1.end()){(*it) += 2; // 可以写cout << *it << " ";++it;}cout << endl;print_list(lt1);}struct Pos{int _row;int _col;Pos(int row = 0, int col = 0):_row(row),_col(col){}};void print_list(const list<Pos>& lt){list<Pos>::const_iterator it = lt.begin();while (it != lt.end()){//it->_row++;cout << it->_row << ":" << it->_col << endl;++it;}cout << endl;}void test_list5(){list<Pos> lt;Pos p1(1, 1);lt.push_back(p1);lt.push_back(p1);lt.push_back(p1);lt.push_back(Pos(2,2));lt.push_back(Pos(3,3));// int* p  -> *p// Pos* p  -> p->list<Pos>::iterator it = lt.begin();//list<Pos>::iterator it2 = it;while (it != lt.end()){it->_row++;//cout << (&(*it))->_row << ":" << (*it)._col << endl;cout << it->_row << ":" << it->_col << endl;//cout << it.operator->()->_row << ":" << it->_col << endl;++it;}cout << endl;print_list(lt);}
}

5.vector和list的对比

vector优点:1.下标随机访问2.尾插尾删效率高3.CPU高速缓存命中高缺点:1.前面部分插入删除数据低2.扩容有消耗,还存在一定空间浪费list优点:1.按需申请释放,无需扩容2.任意位置插入删除,时间复杂度为O(1)缺点:1.不支持随机访问2.CPU高速缓存命中低迭代器失效:vector: insert/eraselist: earsestring: insert/erase(和vector类似,但是string一般不关注失效,因为string的insert/erase 重用接口函数都是下标支持的,迭代器支持用得很少)     

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/816687.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

伺服驱动器算法入门的一些建议和书籍推荐

希望此篇文章对想从事伺服驱动器的研发工作的一些刚刚入门的同学一些建议。 针对伺服驱动器的研发工作涉及的知识和需要掌握的技能主要分为两部分&#xff0c;第一是原理部分、第二是工程实践部分。原理部分的学习在此主要推荐大家查看一些入门书籍&#xff0c;本文章中也对书籍…

【opencv】示例-travelsalesman.cpp 使用模拟退火算法求解旅行商问题

// 载入 OpenCV 的核心头文件 #include <opencv2/core.hpp> // 载入 OpenCV 的图像处理头文件 #include <opencv2/imgproc.hpp> // 载入 OpenCV 的高层GUI(图形用户界面)头文件 #include <opencv2/highgui.hpp> // 载入 OpenCV 的机器学习模块头文件 #includ…

Leetcode215_数组中的第K个最大元素

1.leetcode原题链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 2.题目描述 给定整数数组 nums 和整数 k&#xff0c;请返回数组中第 k 个最大的元素。 请注意&#xff0c;你需要找的是数组排序后的第 k 个最大的元素&#xff0c;而不是第 k 个不同的元素。 你必…

多线程(52)Java内存模型(JMM)

Java内存模型&#xff08;JMM&#xff09;是Java虚拟机&#xff08;JVM&#xff09;的一部分&#xff0c;它定义了Java程序中各种变量&#xff08;线程中的本地变量、堆中的对象、类中的静态字段等&#xff09;的访问规则&#xff0c;以及在多线程环境中如何和何时可以看到由其…

陇剑杯 ios 流量分析

陇剑杯 ios 流量分析 ios 一位ios的安全研究员在家中使用手机联网被黑&#xff0c;不仅被窃密还丢失比特币若干&#xff0c;根据流量分析完成ios1-8 ios 1 ios-1&#xff1a;黑客所控制的C&C服务器IP是_____________。 什么是C&C服务器? C&C&#xff08;Com…

Java 大数据开发

Java 作为一种流行的编程语言&#xff0c; 其优秀的跨平台性和可扩展性&#xff0c; 为大数据开发提供了很好的支持。 Java 大数据开发一般涉及到以下几个方面&#xff1a; 1. 数据处理和分析&#xff1a; 这是大数据开发最基础的工作&#xff0c; 通过 Java 编程语言&#xff…

MATLAB GUI图形化界面设计计算器

MATLAB GUI界面设计教程可以帮助用户创建交互式的图形用户界面&#xff0c;以简化与MATLAB程序的交互过程。以下是一个简化的教程&#xff0c;指导你如何进行MATLAB GUI界面设计&#xff1a; 1. 启动GUIDE或App Designer GUIDE&#xff1a;在MATLAB命令窗口中输入guide命令&a…

php在apache运行的几种方式

本文讲运行的三种模式 CGI模式、FastCGI模式、Apache 模块DLL 解释 cgi,fastcgi,php-fmp之间的关系 请看 https://blog.csdn.net/qq_21956483/article/details/80348316 Cgi模式和模块dll加载方式比较&#xff1a; Cgi模式下 apache调用外部执行器php.exe执行php代码&#xff…

Linux kernel 墙上时间

前言 最近在研究 Linux 调度子系统&#xff0c;该子系统由时钟中断推动。每发生一次时钟中断&#xff0c;就会执行一次时钟中断服务程序&#xff0c;在时钟中断服务程序中&#xff0c;最终会调用 tick_periodic() 这个函数。该函数中有 update_wall_time() 这样一个函数&#…

4.2、ipex-llm(原bigdl-llm)进行语音识别

ipex-llm环境配置及模型下载 由于需要处理音频文件&#xff0c;还需要安装用于音频分析的 librosa 软件包。 pip install librosa下载音频文件 !wget -O audio_en.mp3 https://datasets-server.huggingface.co/assets/common_voice/--/en/train/5/audio/audio.mp3 !wget -O a…

44.HarmonyOS鸿蒙系统 App(ArkUI)栅格布局介绍

栅格布局是一种通用的辅助定位工具&#xff0c;对移动设备的界面设计有较好的借鉴作用。主要优势包括&#xff1a; 提供可循的规律&#xff1a;栅格布局可以为布局提供规律性的结构&#xff0c;解决多尺寸多设备的动态布局问题。通过将页面划分为等宽的列数和行数&#xff0c;…

我五年减脂历程中应用的数据指标

对于减脂&#xff0c;理论说的再多无益&#xff0c;关键是要行动起来。只有坚持过&#xff0c;才有资格说&#xff1a;我尽力了。 每天跑步5公里&#xff0c;是改变一个人体态的分水岭。记住是每天&#xff0c;不管春夏秋冬、酷暑寒雪。 我常在想&#xff0c;如何才能变成一个更…

【JavaEE多线程】理解和管理线程生命周期

目录 ThreadThread类的常用构造方法Thread类的常见属性启动一个线程-start()终止一个线程等待一个线程-join()线程的状态 Thread Thread 就是在 Java 中&#xff0c;线程的代言人。系统中的一个线程&#xff0c;就对应到 Java 中的一个 Thread 对象。围绕线程的各种操作&#…

Java 设计模式系列:模板方法模式

简介 模板方法模式是一种行为型设计模式&#xff0c;它定义一个操作中的算法骨架&#xff0c;将一些步骤推迟到子类中。模板方法模式使得子类可以不改变一个算法的结构&#xff0c;即可重定义该算法的某些特定步骤。 在模板方法模式中&#xff0c;抽象类中定义了一系列基本操…

申请OV SSL证书的好处

什么是OV SSL证书&#xff1a; OV SSL证书也叫组织验证型SSL证书&#xff0c;是众多SSL证书当中最受广大用户欢迎的一种类型。因为它不仅需要验证域名的所有权&#xff0c;还需要对企业的相关身份信息进行审核&#xff0c;确保企业是一个真实存在的合法实体。除了这些&#xf…

Rust取代C++? 保守了!关于未来的讨论

当各种平台在大肆讨论rust即将取代C/C的时候&#xff0c;已经有不少人意识到这种讨论是聒噪而无聊的。笔者和老师们通过周末茶会的讨论&#xff0c;认为现今世界常见的大多数编程语言都会在50-80年内被AI取代&#xff0c;同时供人类审计而诞生的“审计语言”会兴起。届时计算机…

Beego 使用教程 1:项目创建

beego 是一个用于Go编程语言的开源、高性能的 web 框架 beego 被用于在Go语言中企业应用程序的快速开发,包括RESTful API、web应用程序和后端服务。它的灵感来源于Tornado, Sinatra 和 Flask beego 官网:http://beego.gocn.vip/ 上面的 beego 官网如果访问不到,看这篇文章…

华为机考入门python3--(15)牛客15-求int型正整数在内存中存储时1的个数

分类&#xff1a;二进制 知识点&#xff1a; int转二进制 binary bin(n)[2:] 题目来自【牛客】 def count_ones_in_binary(n): # 将输入的整数转换为二进制字符串 # bin(n)为0b11011binary bin(n)[2:]# 初始化计数器为0 count 0 # 遍历二进制字符串的每一位 fo…

YOLOv9/YOLOv8算法改进【NO.117】 使用Wasserstein Distance Loss改进小目标的检测效果

前 言 YOLO算法改进系列出到这&#xff0c;很多朋友问改进如何选择是最佳的&#xff0c;下面我就根据个人多年的写作发文章以及指导发文章的经验来看&#xff0c;按照优先顺序进行排序讲解YOLO算法改进方法的顺序选择。具体有需求的同学可以私信我沟通&#xff1a; 首推…

多线程(51)忙等待

忙等待&#xff08;Busy-waiting&#xff09;是一种同步机制&#xff0c;其中一个进程或线程重复检查某个条件是否满足以便继续执行&#xff0c;而不是进入休眠或阻塞状态。这个条件通常与某种资源或锁的可用性有关。忙等待常常与自旋锁相关联&#xff0c;因为自旋锁就是通过忙…