list 使用1.list 的构造2.list iterator的使用3.list capacity:4.list element access:5.list modifiers:list 模拟实现#pragma once #includeassert.h namespace yx { templateclass T struct list_node { list_nodeT* _next; list_nodeT* _prev; T _val; list_node(const T val T()) //T()类似int()表示默认参数 :_next(nullptr) , _prev(nullptr) , _val(val) {} }; templateclass T, class Ref, class Ptr //主要用于实现普通迭代器与常量迭代器 struct __list_iterator { typedef list_nodeT Node; typedef __list_iteratorT, Ref, Ptr self; Node* _node; __list_iterator(Node* node) :_node(node) { } Ref operator*() { return _node-_val; } Ptr operator-() { return _node-_val; } 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; } bool operator(const self it)const { return _node it._node; } bool operator!(const self it)const { return _node ! it._node; } }; templateclass T class list { typedef list_nodeT Node; public: typedef __list_iteratorT, T, T* iterator; typedef __list_iteratorT, const T, const T* const_iterator; iterator begin() { return iterator(_head-_next); } iterator end() { return _head; } const_iterator begin() const { return const_iterator(_head-_next); } const_iterator end() const { return const_iterator(_head); } void empty_init() { _head new Node; _head-_prev _head; _head-_next _head; _size 0; } list() { empty_init(); } list(const listT lt) { empty_init(); for (auto e : lt) { push_back(e); } } void swap(listT lt) { std::swap(_head, lt._head); std::swap(_size, lt._size); } listT operator(listT lt) { swap(lt); return *this; } ~list() { clear(); delete _head; _head nullptr; } void clear() { iterator it begin(); while (it ! end()) { it erase(it); } _size 0; } void push_back(const T x) { insert(end(), x); } void push_front(const T x) { insert(begin(), x); } void pop_back() { erase(--end()); } void pop_front() { erase(begin()); } iterator insert(iterator pos, const T x) { Node* cur pos._node; Node* prev cur-_prev; Node* newnode new Node(x); prev-_next newnode; newnode-_next cur; cur-_prev newnode; newnode-_prev prev; _size; return newnode; } 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; --_size; return next; } size_t size() { return _size; } private: Node* _head; size_t _size; }; }