第一步：看源代码
类的框架：
成员函数：
基本可以确定list是一个带头双向循环链表，end()的迭代器指向头节点，begin()的迭代器指向头结点的下一个节
list的迭代器：（稍显复杂）
库中的迭代器成员函数只有一个链表节点指针。对链表节点指针直接解引用只能拿到节点空间，没办法拿到节点中存储的date，但是可以通过自定义类型封装间接实现拿到date。节点的指针++，也不会到达下一个地址。自定义类型的运算符重载可以控制行为。
下面是具体的实现：
list.h中
#pragma once
#include<iostream>
#include<algorithm>
#include<assert.h>
using namespace std;
namespace bit
{
template<class T>
struct _list_node
{
_list_node(const T& x = T())
//这里的缺省不能直接给0，因为T的类型可能为string，vector
{
_date = x;
_next = nullptr;
_prev = nullptr;
}
_list_node<T>* _next;
_list_node<T>* _prev;
T _date;
};
//list的迭代器是一个难点
//template<class T>最开始的框架
//typedef _list_iterator<T, T&, T*> iterator;
//typedef _list_iterator<T, const T&, const T*> const_iterator;
//当调用begin()的类型不同时匹配的begin()函数不同，决定了是返回const_iterator类型还是iterator类型，
//由此决定ref具体是什么类型，ptr具体是什么类型。
template<class T, class ref, class ptr>
//源代码中模板参数有三个template<class T, class Ref, class Ptr>这个和const迭代器有关。
struct _list_iterator
{
typedef _list_node<T> Node;
typedef _list_iterator<T,ref,ptr> Self;
Node* _node;
//迭代器器的本质是一个节点指针，和_head一样。
_list_iterator(Node* it)
//如果不想被隐式类型转换可以这样声明：explicit _list_iterator(Node* it)
:_node(it)
{}
//需要写析构函数吗？
//不需要，_node指向的是节点空间，不能说使用一次迭代器就释放节点空间，所以使用默认生成的析构函数就可以
//默认生成的析构函数不会对指针类型进行处理
//需要写拷贝构造和赋值重载吗？
//不需要，指针为内置类型，默认生成的浅拷贝就可以。
ref operator*()
//开始的框架：T& operator*()
{
return _node->_date;
//_date是节点中的数据，节点是new出来的，出作用域不会消失，可以引用返回。
}
//开始的框架：T* operator->()
ptr operator->()
//
ptr
operator->
()是干什么的？
//当T的实参为类时会用到。在下面test.cpp中test2有示范
{
return &(_node->_date);
}
bool operator==(const Self& pos)
{
return _node == pos._node;
}
bool operator!=(const Self& pos)
//pos是_list_iterator<T>类型
{
return _node != pos._node;
//这里必须用_node进行比较，如果用迭代器比较，会再进行!=重载，形成死循环。
//this是指向迭代器的指针，是_list_iterator<T>*类型
}
Self& operator++()
{
_node = _node->_next;
return *this;
//_node是_list_node<T>*类型，不能转换为_list_iterator<T>&类型
//如果没有&，就可以，因为支持单参数隐式类型转换。
}
Self operator++(int)
{
Self tmp = _node;
_node = _node->_next;
return tmp;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
Self operator--(int)
{
Self tmp = _node;
_node = _node->_prev;
return tmp;
}
};
template<class T>
class list
{
typedef _list_node<T> Node;
//重复typedef是因为上一个typedef只有在所在的{}内才有效
public:
//开始的框架：typedef _list_iterator<T> iterator;
typedef _list_iterator<T,T&,T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;
//类模板给不同的参数，会变成不同的类型
//关于为什么const迭代器中T的前面不用加const：加上const，迭代器中的T就表示const T,_list_node<T>就表示
//_list_node<const T>list存储的数据变成不可修改的了，而Node中的内容是可以修改的。类型不匹配，
//在类模板中不同类型之间是不能赋值的（有const和没有const是不同类型），会报错。
//迭代器封装以后，在使用时(不同容器的迭代器)看起来是一样的。如果没有被public修饰，就无法在list外使用。
//T是存储的数据类型，T&/const T&是返回存储的数据，加引用是为了减少拷贝，
//有无const取决于可不可以通过迭代器修改数据。
//关于迭代器使用的图示：
list()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
//传统写法：
//list(const list<T>& it)//it2(it1)
//{
// _head = new Node;
// _head->_next = _head;
// _head->_prev = _head;
// for (auto e : it)
// {
// push_back(e);
// }
//}
//现代写法：
void empty_init()
//库中也提供了这个函数
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
template <class InputIterator>
list(InputIterator first, InputIterator last)
{
empty_init();
while (first != last)
{
push_back(*first);
first++;
}
}
void swap(list<T>& it)
//it的内容要修改，不能加const
{
std::swap(_head, it._head);
//依据实现size()的方式，可能还有交换size,这里没有实现size()，所以没交换。
}
list(const list<T>& it)
{
empty_init();
//不能用未初始化的list和tmp交换。
list<T> tmp(it.begin(), it.end());
swap(tmp);
}
list<T>& operator=(list<T> it)
//it2 = it1
{
swap(it);
//传值拷贝，it中已经有需要的数据了
return *this;
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
}
}
void push_back(const T& x)
{
///*Node* tmp = new Node(x);
//_head->_prev->_next = tmp;
//tmp->_prev = _head->_prev;
//tmp->_next = _head;
//_head->_prev = tmp;*/
//Node* tmp = new Node(x);
//Node* tail = _head->_prev;//保存尾节点的地址，就可以不用按顺序完成链表的连接了
//tail->_next = tmp;
//tmp->_prev = tail;
//tmp->_next = _head;
//_head->_prev = tmp;
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());
//这里可以用--end(),原因不明
}
void pop_front()
{
erase(begin());
}
iterator begin()
//引用返回的话可能会修改首节点地址的数据
{
return iterator(_head->_next);
//这样写可以进行一次优化，减少拷贝次数。
//传值返回，单参数，支持隐式类型转换。
}
iterator end()
{
return iterator(_head);
}
const_iterator begin() const
{
return const_iterator(_head->_next);
}
const_iterator end() const
{
return const_iterator(_head);
}
iterator insert(iterator pos, const T& val)
//在pos位置之前插入数据
{
Node* newnode = new Node(val);
Node* cur = pos._node;
cur->_prev->_next = newnode;
newnode->_prev = cur->_prev;
newnode->_next = cur;
cur->_prev = newnode;
return iterator(newnode);
//insert的返回值很少用，和库里尽量保持一致还是加上了。
}
iterator erase(iterator pos)
{
assert(pos != end());
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
return iterator(next);
//返回值解决迭代器失效的问题
}
private:
Node* _head;
};
}
test.cpp中
#define _CRT_SECURE_NO_WARNINGS 1
#include"list.h"
#include<list>
void test_list1()
{
bit::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(3);
l.push_back(4);
l.push_back(5);
bit::list<int>::iterator it = l.begin();
while (it != l.end())
{
cout << *it << " ";
++it;
}
}
struct AA
{
AA(int a = 0, int b = 0)
{
a1 = a;
a2 = b;
}
int a1;
int a2;
};
cout没有AA的重载的解决方案一:加上重载
//ostream& operator<<(ostream& out, AA& aa)//函数中不能定义函数
//{
// cout << aa.a1 << " " << aa.a2 << " ";
// return out;
//}
void test_list2()
{
bit::list<AA> l;
l.push_back(AA(1, 1));
l.push_back(AA(2, 2));
l.push_back(AA(3, 3));
l.push_back(AA(4, 4));
l.push_back(AA(5, 5));
bit::list<AA>::iterator it = l.begin();
/*while (it != l.end())
{
cout << *it << " ";//这里的it是迭代器，解引用后拿到的是_date，_date的类型是T，即AA。cout没有AA的重载
++it;
}*/
while (it != l.end())
{
cout没有AA的重载的解决方案二:
//cout << (*it).a1 << " " << (*it).a2 << " ";
//it是迭代器，迭代器模仿的是指针，指针有通过->直接访问数据的功能，而it是一个类
//cout << it->a1 << " " << it->a2 << " ";//原本应该这样使用的：it._node->_date.a1
//库中支持迭代器直接访问数据，库中函数：T* operator->() const { return &(operator*()); }
//it调用operator*()，*it会拿到其中的数据，即拿到_next->date，为operator*()的返回值；
//it调用operator->()返回&(_node->date)，即AA*，it->a1即AA* a1，实际上编译器为了可读性对这里进行简化。
//it->a1实际上应该是it->->a1。it->即：it.operator->()返回AA*，AA*->a1，读取到数据
cout << it->a1 << " " << it->a2 << " ";
++it;
}
}
void print_list(const bit::list<int> tmp)
{
bit::list<int>::const_iterator it = tmp.begin();
//如果只是在begin()后加上const的修饰，只能编译通过，不能保证数据不可修改
//要能做到不可修改，需要给 * 和 -> 的重载返回值加上const，但是加上const同时也意味着非const修饰的迭代器不可修改
// 一般情况下，会选择再写一个_list_const_iterator类型的类，但是和_list_iterator类的逻辑高度重合，维护起来不方便
// 下面跳转到list类部分，见证大佬为何是大佬。(每个注释有开始的框架的上下行都是大佬智慧的结晶)
// 还不理解的翻到末尾，有图解说明
//标准库中begin()可以自动识别迭代器类型，但是不能将const修饰的迭代器赋值给非const修饰的迭代器。
//自定义类型被const修饰和不被const修饰是两个无关类型，
//不能将被const修饰的类型赋值给不被const修饰的类型，标准库中也一样
//比如说自定义类型的迭代器，不能说用const修饰了，就能支持const类型运算，还要有const类型对应运算的重载，
//就算不被const修饰类型已经有对应的运算重载也不行。
while (it != tmp.end())
{
cout << *it << " ";
++it;
}
}
void test_list3()
{
bit::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(3);
l.push_back(4);
l.push_back(5);
print_list(l);
}
void test_list4()
{
bit::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(3);
l.push_back(4);
l.push_back(5);
l.insert(l.begin(), 10);
l.push_front(20);
l.push_front(30);
l.push_front(40);
l.erase(l.begin());
l.pop_back();
l.pop_front();
bit::list<int>::iterator it = l.begin();
while (it != l.end())
{
cout << *it << " ";
++it;
}
}
void test_list5()
//关于list的insert的迭代器失效问题
{
bit::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(2);
l.push_back(3);
l.push_back(4);
l.push_back(5);
l.push_back(6);
bit::list<int>::iterator it = l.begin();
while (it != l.end())
{
if (*it % 2 == 0)
{
l.insert(it, *it * 10);
}
it++;
}
for (auto it : l)
{
cout << it << " ";
}
cout << endl;
//运行发现没什么问题
//原因在于：list空间不连续，insert插入数据不需要挪动数据，所以不存在野指针问题，
//insert插入数据，插入在指向的节点之前，意义也没有发生变化。
}
void test_list6()
//关于list的erase的迭代器失效问题
{
bit::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(2);
l.push_back(3);
l.push_back(4);
l.push_back(5);
l.push_back(6);
bit::list<int>::iterator it = l.begin();
/*while (it != l.end())
{
if (*it % 2 == 0)
{
l.erase(it);//这样写是必然崩溃的，it都被释放了，it迭代器自然失效
}
it++;
}*/
while (it != l.end())
{
if (*it % 2 == 0)
{
it = l.erase(it);
}
else
{
it++;
}
}
for (auto it : l)
{
cout << it << " ";
}
cout << endl;
l.clear();
l.push_back(1);
l.push_back(2);
l.push_back(3);
for (auto it : l)
{
cout << it << " ";
}
cout << endl;
}
void test_list7()
{
bit::list<int> l;
l.push_back(1);
l.push_back(2);
l.push_back(3);
l.push_back(4);
l.push_back(5);
l.push_back(6);
bit::list<int> l2(l);
for (auto it : l)
{
cout << it << " ";
}
cout << endl;
l.pop_back();
l2 = l;
for (auto it : l2)
{
cout << it << " ";
}
}
int main()
{
test_list7();
return 0;
}
