目录

前言

list的结构与框架

list迭代器

list的插入和删除

insert

erase

list析构函数和拷贝构造

析构函数

 拷贝构造

赋值重载

 迭代器拷贝构造、析构函数实现问题

 const迭代器

 思考

总结

---

前言

        前边我们了解了list的一些使用及其注意事项，今天我们进一步深入学习一下list容器；本文的主要内容是list底层数据结构剖析以及list的模拟实现与封装；

list的结构与框架

list是一个带头双向循环链表，对list的模拟实现的重难点在于迭代器的实现，以及const迭代器的实现；

list实现整体需要封装三个部分：list_node(节点）、list_iterator(迭代器）、list（链表）

首先我们需要先定义一个节点类：

template<class T>
struct list_node
{T _data;list_node<T>* _next;list_node<T>* _prev;list_node(const T& x = T()):_data(x),_next(nullptr),_prev(nullptr){}
};

         定义时的基本结构和C语言的很像，节点中存储两个指针，一个指向下一个节点，一个指向前一个节点，以及T类型的值（便于存储各种类型的数据）；

         其次就是 list_node 的构造函数，我们在list中new节点时需要调用 list_node 的构造函数（new只要对于内置类型：开空间+调用构造函数）

list的基本结构：

class list
{typedef list_node<T> Node;
public:void empty_init() // 初始化开一个头节点，同时也为了方便拷贝构造与构造函数复用{_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_init();}
private:Node* _head;size_t _size;//记录链表长度
};

 list结构初始化需要开一个头节点，并且指针都指向自己；

接下来我们实现一下push_back(尾插），这样我们就可以先上手测试list基本结构是否完善；

 具体操作如下，可以根据图先动手尝试写一下：

 具体代码如下：

void push_back(const T& x)
{Node* newnode = new Node(x);Node* tail = head->next;// 插入节点tail->next = newnode;newnode->prev = tail;newnode->_next = _head;_head->prev = newnode;_size++;
}

 能够插入数据后，接下来就是遍历list，最基本的也就是迭代器遍历，前边我们使用迭代器的方法：

list<int>::iterator it = lt.begin();
while (it != lt.end())
{cout << *it << ' ';it++;
}

vector是顺序结构，它有天然的迭代器，那list是链表怎么++进行遍历？list的 “ ++ ” 本质其实就是封装+运算符重载，我们需要重载“ ++ ”，每次调用“ ++ ”时迭代器都移动到下一个节点；

         从上述迭代器的使用方法中可以看出，要想实现最基本的遍历迭代器起码要重载三部分：

!=、*（解引用）、++；

list迭代器

         要想实现list的遍历，我们首先需要实现list的迭代器，为什么要实现迭代器？

        list迭代器的实现最能体现的就是封装思想，封装屏蔽底层的差异和实现细节；其目的是为了和其他容器的遍历修改的方式保持一致；

template <class T>
struct __list_iterator
{typedef list_node<T> Node;typedef __list_iterator<T,Ref,Ptr> self;Node* _node;//构造函数__list_iterator(Node* node):_node(node){}
};

 我们使用list的节点指针来初始化构造迭代器对象，以上便是迭代器的基本框架，接下来就是迭代器的基本功能实现；

// 前置
self& operator++()
{_node = _node->_next;return *this;
}self& operator--()
{_node = _node->_prev;return *this;
}//后置
self operator++(int)
{self tmp(*this);_node = _node->_next;return tmp;
}self operator--(int)
{self tmp(*this);_node = _node->_prev;return tmp;
}T& operator*()//解引用返回节点的数据即可
{return _node->_data;
}T* operator->()//通过指针访问成员，常用于自定义类型
{return &_node->_data;
}//迭代器比较，比较的是指针是否相等，如果指针相等，则它们指向同一节点
bool operator!=(const self& s)
{return s._node != _node;
}

这些功能实现以后，我们还不能直接使用迭代器，我们需要把迭代器包装到我们实现的list当中；

在list里边实现begin( )、end( )；

class list
{public:typedef list_node<T> Node;typedef __list_iterator<T> iterator;void empty_init() {_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list(){empty_init();}iterator begin();iterator end();
private:Node* _head;size_t _size;
};

 在实现begin( )、end( )；之前，我们需要明确它们指向的位置是哪里？

iterator begin()
{return _head->_next;//返回时会自动调用iterator构造函数
}iterator end()
{return _head;
}

list的插入和删除

         我们在list的基础上包装了一次iterator，那么接下来我们就在有迭代器的基础上实现insert和erase操作；

insert

根据传进来的迭代器的位置进行插入操作：

 

iterator insert(iterator pos, const T& x)
{Node* newnode = new Node(x);Node* cur = pos._node;Node* prev = cur->_prev;// 插入节点newnode->_next = cur;cur->_prev = newnode;prev->_next = newnode;newnode->_prev = prev;_size++;return iterator(newnode);
}

 小tips：

         双向循环链表在插入链接时很容易出现节点丢失的情况，为了尽可能的避免，这里推荐创建一个变量来记录当前节点的前一个位置；

erase

iterator erase(iterator pos)
{Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;delete cur;prev->_next = next;next->_prev = prev;--_size;return iterator(next);
}

注意：

        erase之后迭代器会失效，因为迭代器指向的节点已经被删除释放，为了避免非法访问，这里我们应该返回下一个节点；insert根据客观性来讲，应该返回新插入节点；

 有了插入和删除，在尾插、尾删、头插、头删的接口中都可以复用插入删除操作：

void push_back(const T& x)
{insert(end(), x);
}void push_front(const T& x)
{insert(begin(), x);
}void pop_back(const T& x)
{erase(--end());
}void pop_front(const T& x)
{erase(begin());
}

list析构函数和拷贝构造

有了迭代器析构函数和拷贝构造就会非常简单，我们可以复用前边实现的功能

析构函数

void clear()
{iterator it = begin();while (it != end()){it = erase(it);//注意删除之后需要更新it（迭代器），erase自动返回下一个节点位置}
}//析构函数
~list()
{clear();delete _head;//注意释放头节点_head = nullptr;
}

 拷贝构造

list(list<T>& lt)
//这里应该是list(const list<T>& lt)，但这样写需要const迭代器，const迭代器下面会进行实现
//所有这里先不用const修饰
{empty_init();for (auto e : lt){push_back(e);}
}

赋值重载

这里说传统写法，在复用前边功能实现也是非常简单

list<int>& operator=(list<int>& lt)
{if (this != &lt){clear();for (auto e : lt){push_back(e);}}return *this;
}

现代写法：

void swap(list<T>& lt)
{std::swap(_head, lt._head);std::swap(_size, lt._size);
}
list<int>& operator=(list<int> lt)
{swap(lt);return *this;
}

 迭代器拷贝构造、析构函数实现问题

普通迭代器基本已经实现完毕，那我们来思考一下，迭代器要不要实现析构函数和拷贝构造？

        切记，迭代器不需要实现析构函数，如果实现析构函数释放空间就会把list节点释放；把节点指针给迭代器只是为了上迭代器能够访问list；

        迭代器的拷贝构造和赋值重载也不需要实现，迭代器存在的目的只是为了模拟指针去访问，如果自己实现进行深拷贝那还怎么访问list节点；

 const迭代器

         在实现之前我们需要先捋清楚const迭代器const修饰的是什么？

        

 const迭代器修饰的是iterator指向的对象，对象不能修改；

在普通迭代器前边加上const修饰（const iterator），它修饰的是iterator迭代器，迭代器要能够修改，因为我们要使用 it++向后遍历，而我们需要的是内容不能被修改；

所以要想实现内容不能修改，我们需要重新实现一个类，不能单纯的使用const修饰普通迭代器；

 我们先使用简单的方法，再封装一个和iterator相似的类，命名为const_iterator；

再封装一个类它的内容和iterator的代码很类似，这样代码复用率很低，这里我们选择使用模板来实现一个类模板，可供普通迭代器和const迭代器使用；

 这里我们可以给iterator多添加两个模板参数：

template <class T, class Ref, class Ptr >
// Ref引用   Ptr指针
struct __list_iterator
{typedef list_node<T> Node;typedef __list_iterator<T,Ref,Ptr> self;Node* _node;
}

 为什么要添加？

在iterator类中支持修改的接口就俩个：

• operator*()
• operator->()

 区别就在于它们的返回值，普通迭代器返回的是T&、T*；

const_iterator返回的是const T&、const T*；

        它们是完全不同的类型，如何做到一个函数可以返回两种类型的参数，唯有模板参数，所以这里我们添加两个参数，一个用来返回指针类型（T* 和 const T*），一个用来返回引用（T& 和  constT&） ；

这样我们只需修改两个接口：

Ref operator*()
{return _node->_data;
}Ptr operator->()
{return &_node->_data;
}

修改之后我们就可以把它包装在自己实现的list中：

class list
{public:typedef list_node<T> Node;typedef __list_iterator<T> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;//...iterator begin();iterator end();const_iterator begin() const;// 内容不需要修改只需对函数进行修饰，修改返回类型//因为返回的list节点指针可以构造iterator，也可以构造const_iteratorconst_iterator end() const;  // 成员函数后加const修饰的是成员函数，// 成员函数不可以修改对象的成员变量
private:Node* _head;size_t _size;
};

 我们写一个函数来测试一下：

void print_list(const list<int>& lt)
{list<int>::const_iterator it = lt.begin();while (it != lt.end()){//*it = 10;cout << *it << " ";++it;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;
}

 list的模拟实现很好是体现了封装思想，也让我们很好的感受到泛型编程的魅力；

 思考

         这个测试接口只可以输出 list<int> 类型；那么问题来了，如何修改让它可以适用于任何类型？又如何让它能够遍历任何容器（vector、list ... 都可以使用）？

如何修改让它可以适用于list的任何类型？其实很简单，添加一个模板参数即可；

template<typename T>
void print_list(const list<T>& lt)
{// 使用class时，list<T>未实例化的类模板，编译器不能识别进行实例化// 前面加一个typename就是告诉编译器，这里是一个类型，等list<T>实例化后// 再去类里面去取并实例化出迭代器对象// 这也就是class和typename的区别typename list<T>::const_iterator it = lt.begin();while (it != lt.end()){//*it = 10;cout << *it << " ";++it;}cout << endl;for (auto e : lt){cout << e << " ";}cout << endl;
}

 如何让它能够遍历任何容器（vector、list ... 都可以使用），这里只需要再抽象一层，T可以是任何数据类型，vecror<string>、list<int>都是数据类型，由于每个容器的迭代器使用方式都基本一致，所以我们可以不指定遍历容器的迭代器，相同的使用方式就可以遍历其他的容器：

template<typename Con>
void print_container(const Con& con)
{typename T::const_iterator it = con.begin();while (it != con.end()){cout << *it << " ";++it;}cout << endl;
}

 完整代码：list模拟实现

内含反向迭代器的实现，目前阶段可以忽视

---

总结

        list模拟实现的目的就是为了更深刻的感受封装，以及泛型编程， list的模拟实现很好是体现了封装思想，也让我们很好的感受到泛型编程的魅力；以上便是本文的全部内容，希望对你有帮助，感谢阅读！