1ListNode
template<class T>
struct ListNode
{
public:
ListNode(const T& x = T())
:_next(nullptr)
, _prev(nullptr)
, _data(x)
{}
//private:
//共有可访问
ListNode<T>* _next;
ListNode<T>* _prev;
T _data;
};实现iterator对Node*的封装 实现运算符重载
void const_print(const MyList::list<int>& lt)//这里的const本意是lt的node中的data不可改，却使lt不可改
//const迭代器是指， it已经封装过，把it当作指向node中的data的指针 it内的_node 的
{
MyList::list<int>::const_iterator it = lt.begin();//所以应该是 通过函数重载，返回一个迭代器，不能支持对（*it）的改动
while (it != lt.end())
{
//报错，必须是可修改的左值 *it += 19;
//*it += 19;
cout << (*it) << ' ';
it++;
}
cout << endl;
}2ListIterator
template<class T, class Ref, class Ptr>
class ListIterator
{
public:
typedef ListNode<T> Node;
typedef ListIterator<T, Ref, Ptr> Self;//变化
ListIterator(Node* node)
:_node(node)
{}
Ref operator*()//变化
{
return _node->_data;
}
Ptr operator->()//变化
{
return &(_node->_data);
}
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!=(Self it)
{
return _node != it._node;
}
//private: 共有
Node* _node;
};3list
template<class T>
class list
{
public:
typedef ListNode<T> Node;
//typedef ListIterator<T> iterator;
//typedef ListConstIterator<T> const_iterator;//但这样要实现两个类 可以合并
typedef ListIterator<T, T&, T*> iterator;
typedef ListIterator<T, const T&, const T*> const_iterator;
iterator begin()//头是head下一个节点
{
return _head->_next;//单参数的自定义类型支持隐式类型转化 c++11对于多参数的也可以{xx,xx,xx}
}
iterator end()//尾是head
{
return _head;
}
const_iterator begin()const//直接加const 对于const对象能调用，然后刚好构成函数重载，
{
return _head->_next;//返回值也不能是 const itertor 这指的是it不能改，应该封装成（*it）不可改
}
const_iterator end()const
{
return _head;
}
void empty_init()
{
//先new一个节点
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
list(initializer_list<T>il)
{
empty_init();
for (auto& e : il)
push_back(e);
}
list()
{
empty_init();
}
list(const list<T>& lt)
{
empty_init();
for (auto& i : lt)//要引用 有可能是自定义类型
{
push_back(i);
}
}
/*void push_back(const T& x)
{
Node* newnode = new Node(x);
Node* tail = _head->_prev;
tail->_next = newnode;
newnode->_prev = tail;
newnode->_next = _head;
_head->_prev = newnode;
}*/
void push_back(const T& x)
{
insert(end(), x);
}
void push_front(const T& x)
{
insert(begin(), x);
}
void pop_back()
{
erase(--end());//不能是-1，没有重载
}
void pop_front()
{
erase(begin());
}
void insert(iterator pos, T val)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* newnode = new Node(val);
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;
}
iterator erase(iterator pos)//迭代器失效 返回next
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;//
return iterator(next);
}
size_t size()
{
size_t sz = 0;
for (auto i : (*this))
sz++;
return sz;
}
bool empty()
{
return size() == 0;
}
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
}
}
~list()
{
clear();
delete _head;
}
private:
Node* _head;
};4对于const迭代器的解释和->操作符重载
struct A
{
int _a1;
int _a2;
A(int a1 = 0, int a2 = 0)
:_a1(a1)
, _a2(a2)
{}
};
void const_print(const MyList::list<int>& lt)//这里的const本意是lt的node中的data不可改，却使lt不可改（
//const迭代器是指， it已经封装过，把it当作指向node中的data的指针
{
MyList::list<int>::const_iterator it = lt.begin();//所以应该是 通过函数重载，返回一个迭代器，不能支持对（*it）的改动
while (it != lt.end())
{
//报错，必须是可修改的左值 *it += 19;
//*it += 19;
cout << (*it) << ' ';
it++;
}
cout << endl;
}
void print(MyList::list<int>& lt)
{
MyList::list<int>::iterator it = lt.begin();
while (it != lt.end())
{
*it += 19;
cout << (*it) << ' ';
it++;
}
cout << endl;
}
void test2()
{
MyList::list<A>lt;
lt.push_back({ 1,2 });//隐式类型转换，c++11
lt.push_back({ 1,2 });
lt.push_back({ 1,2 });
MyList::list<A>::iterator it = lt.begin();
while (it != lt.end())
{
//报错cout << (*it) << " ";//(*it)访问的是 节点的数据 对于int 数据就是int 支持流输出 ，这里是A对象
//其实就是把it当作 指向A的指针，但本质不是 （*it)就是A
//就是（*it）经过封装，（*it)就是A ，，但it->没封装
//cout << (*it)._a1 << "." << (*it)._a2<<endl;//但本应该it->data 要支持->重载 返回值是_data *
cout << it->_a1 << "." << it->_a2 << endl;
it++;
}
cout << endl;
} 
