list类学习的主要是一个迭代器的封装。
因为list和前面vector,string的物理空间状况不同。
vector和string的物理空间是连续的。迭代器可以直接采用原生指针的解引用,++,- -等
而list的空间分布不是连续的,因此直接++,- -,是访问不到实际的下一个结点,并且节点是一个struct,直接解引用也不是一个value。
因此针对这种情况,我们将迭代器封装成一个类。对类进行运算符重载,仿佛迭代器可以像原生指针一样使用。这就是迭代器的封装性。
迭代器的具体考虑
- 迭代器遍历使用!=end(),既可以满足之前的顺序表,也可以满足现在的链表以及之后的stl
- 对于迭代器采用的拷贝模式,因为想要指向空间即可,采用默认的浅拷贝。同时不析构,因为析构应是归list管的而不是迭代器管的。(不然每次开那么多迭代器数据就没了)
- 同时还要考虑对于const容器对象的迭代器const_iterator,学习通过模板参数来避免写一个仅仅是为了迭代器是否以const形式返回copy了一份几乎完全一致的代码。具体操作就是给迭代器类三个模板参数,根据list的选用迭代器来返回具体的是const reference 还是直接reference或者指针。
namespace YCB {
//结点的定义
template<typename T>
struct _list_node {
T _val;
_list_node* _prev;
_list_node* _next;
_list_node( T val=T() )
:_val(val)
,_prev(nullptr)
,_next(nullptr)
{
}
};
//迭代器(采用默认的浅拷贝)
template<typename T,typename ref,typename ptr>
struct _list_iterator {
typedef _list_node<T> node;
typedef _list_iterator<T,ref,ptr> self;
node* _pnode;//迭代器当前指向的结点
_list_iterator(node* tmp)
:_pnode(tmp)
{ }
bool operator==(const self& iter) {
return _pnode == iter._pnode;
}
bool operator!=(const self& iter) {
return _pnode != iter._pnode;
}
ref operator*() {
return _pnode->_val;
}
ptr operator->() {
return &(_pnode->_val);
}
//iterator++
self operator++(int) {
self tmp = *this;
_pnode = _pnode->_next;
return tmp;
}
//++iterator
self& operator++() {
_pnode = _pnode->_next;
return *this;
}
//iterator--
self operator--(int) {
self tmp = *this;
_pnode = _pnode->_prev;
return tmp;
}
//--iterator
self& operator--() {
_pnode = _pnode->_prev;
return *this;
}
};
template<typename T>
class list {
public:
typedef _list_node<T> node;
typedef _list_iterator<T, T&, T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;
iterator begin() const {
return iterator(_phead->_next);
}
iterator end() const {
return iterator(_phead);
}
const_iterator cbegin() const {
return const_iterator(_phead->_next);
}
const_iterator cend() const {
return const_iterator(_phead);
}
//初始化头结点
list<T>()
{
_phead = new _list_node<T>;
_phead->_next = _phead->_prev = _phead;///头结点指向自身
}
//拷贝构造(深拷贝)
list<T>(const list<T>& ls) {
_phead = new _list_node<T>;
_phead->_next = _phead->_prev = _phead;
for (const auto& e : ls) {///这里是调用了operator=给e
push_back(e);
}
}
//operator=赋值
list<T>& operator=(list<T> ls) {
swap(_phead, ls._phead);
return *this;
}
//插入
void insert(iterator it, T val = T()) {
assert(it._pnode);
iterator left = iterator(it._pnode->_prev);
node* newnode = new _list_node<T>(val);
it._pnode->_prev = newnode;
newnode->_prev = left._pnode;
newnode->_next = it._pnode;
left._pnode->_next = newnode;
}
void erase(iterator pos) {
assert(pos._pnode);
assert(pos._pnode->_prev != pos._pnode);///只有头结点的情况
node* left = pos._pnode->_prev;
node* right = pos._pnode->_next;
left->_next = right;
right->_prev = left;
delete (pos._pnode);///释放空间
}
//尾插
void push_back( T val=T() ) {
insert(end(), val);
}
//尾删
void pop_back() {
erase(--end());
}
//头插
void push_front( T val=T() ) {
insert(begin(), val);
}
//头删;
void pop_front() {
erase(begin());
}
//统计size()--->效率很低,放个变量在private里记录就行。stl后面版本实现了
size_t size() {
size_t sz = 0;
iterator it = begin();
while (it != end()) {
++sz;
++it;
}
return sz;
}
//析构
~list() {
node* cur = _phead->_next;
while (cur != _phead) {
node* tmp = cur->_next;
delete cur;
cur = tmp;
}
delete _phead;
_phead = nullptr;
//测试析构
/*node* tmp = _phead->_next;
while (tmp != _phead) {
cout << tmp->_val << " ";
tmp = tmp->_next;
}cout << endl;*/
}
private:
node* _phead;//头结点
};
};
template<typename T>
void print_container(const list<T>& lt) {
typename list<T>::const_iterator it = lt.cbegin();
while (it != lt.cend()) {
//(*it)++;
cout << *it << " ";
it++;
}cout << endl;
}
void test_list1() {
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
print_container(lt);
lt.push_front(8);
lt.push_front(7);
lt.push_front(6);
lt.push_front(5);
print_container(lt);
}
void test_list2() {
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
list<int>lt2(lt);
print_container(lt2);
lt2.pop_back();
print_container(lt2);
print_container(lt);
lt2.pop_front();
print_container(lt2);
print_container(lt);
cout << lt2.size() << endl;
}
void test_list3() {
class Date {
public:
int _year = 0;
int _month = 0;
int _day = 1;
};
list<Date> lt;
lt.push_back(Date());
lt.push_back(Date());
lt.push_back(Date());
list<Date>::iterator it = lt.begin();
while (it != lt.end()) {
cout << (*it)._year << " " << (*it)._month << " " << (*it)._day << endl;
it++;
}cout << endl;
}