先问一个问题:为什么
typedef const __list_iterator<T> const_iterator;是错的?明明加了 const,为什么反而"不能遍历、却能改值"?这篇就把这个反例讲清楚,再补上
operator->、拷贝构造、clear和erase。
开篇
学习方式还是老样子:听课 + 自己敲 + AI 辅助。这篇对应第 18 课(5.29 list 下),代码在 VS 2026(MSVC 14.51)下编译运行。
先给结论:
const 迭代器不是"const 的迭代器对象",而是"指向 const 元素的迭代器"。
一、先看一个反例:给迭代器加 const,为什么本末倒置?
很多人第一反应是:
cpp
typedef const __list_iterator<T> const_iterator;
看起来"加了 const,就只读了",但实际效果正好相反。

const修饰的是迭代器对象本身;- 所以
it++调不了非 const 的operator++,不能遍历; - 但
operator*还是返回T&,你仍然能*it = 10,能改值。
这就是本末倒置:该能遍历的不能遍历,该只读的却能改。
二、正确做法:用 Ref / Ptr 把"是否 const"抽出来

cpp
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef list_node<T> Node;
typedef __list_iterator<T, Ref, Ptr> Self;
Node* _node;
Ref operator*() { return _node->_data; }
Ptr operator->() { return &_node->_data; }
Self& operator++() { _node = _node->_next; return *this; }
// ...
};
然后:
cpp
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
同一个模板,实例化出两个类型:
iterator:Ref = T&,Ptr = T*,可读可写;const_iterator:Ref = const T&,Ptr = const T*,只读。
迭代器对象本身不是 const,所以 ++ 正常;const 加在"指向的内容"上,所以 *it = ... 不行。
三、operator->:it->_row 到底怎么展开?
如果 T 是 Pos:
cpp
struct Pos { int _row; int _col; };
你可以写:
cpp
it->_row
它展开是:
cpp
it.operator->()->_row
operator->() 返回 Ptr(Pos* 或 const Pos*),编译器再对返回的指针做一次内置的 ->。
所以:
it->_row可读性好;(*it)._row也能用;- const 迭代器的
Ptr = const Pos*,所以it->_row = 10不行。
四、const 成员函数:print(const list<T>&) 为什么不能改?
cpp
template<class T>
void print(const list<T>& lt)
{
for (auto it = lt.begin(); it != lt.end(); ++it)
cout << *it << " ";
}
lt 是 const 对象,只能调用:
cpp
const_iterator begin() const;
const_iterator end() const;
返回 const_iterator,operator* 返回 const T&,所以:
cpp
*it += 1; // 编译不过
这里跟"命名空间"没关系,是 const 对象只能选 const 成员函数。
另外,模板里写:
cpp
typename list<T>::const_iterator it = lt.begin();
list<T> 是依赖类型,编译器不知道 const_iterator 是类型还是静态成员,typename 是告诉它"这是类型"。用 auto 就绕开了这个歧义。
五、拷贝构造:每个 list 都要有自己的哨兵头

错误做法是直接拷 _head:
cpp
_head = lt._head; // 浅拷贝
这样两个 list 共享同一批节点,析构时 double delete,程序直接崩。
正确做法:
cpp
list(const list<T>& lt)
{
empty_init(); // 新建自己的哨兵头
for (const auto& e : lt)
push_back(e); // 每个元素深拷贝
}
empty_init() 就是:
cpp
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
赋值用 copy-and-swap:
cpp
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
传值先深拷贝一份,swap 后临时对象析构,释放旧节点。自赋值也安全,不需要再写 if (this != <)。
六、clear 和析构:为什么写 it = erase(it)?

cpp
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it); // erase 返回下一个位置
}
}
不能写:
cpp
erase(it);
++it; // it 已经被 delete,++it 是 UB
erase 删除当前节点,返回下一个节点的迭代器;旧 it 已经失效,必须用返回值更新。
析构函数:
cpp
~list()
{
clear(); // 先删数据节点
delete _head; // 再删哨兵头
_head = nullptr;
}
为什么先 clear 再 delete _head?因为 clear 需要 _head 来定位 end();先把头删了,就不知道遍历到哪儿结束了。
七、insert / erase / push / pop / size
insert 和 erase 的核心就是改前后指针:
cpp
iterator insert(iterator pos, const T& val)
{
Node* cur = pos._node;
Node* newnode = new Node(val);
Node* prev = cur->_prev;
prev->_next = newnode;
newnode->_next = cur;
cur->_prev = newnode;
newnode->_prev = prev;
++_size;
return iterator(newnode);
}
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;
prev->_next = next;
next->_prev = prev;
delete cur;
--_size;
return next; // Node* 隐式转成 iterator
}
几个复用:
cpp
push_back(x) -> insert(end(), x)
push_front(x) -> insert(begin(), x)
pop_back() -> erase(--end())
pop_front() -> erase(begin())
end() 是哨兵头,--end() 就到最后一个节点;list 迭代器是双向的,所以可以 --。
erase 返回 Node*,但函数返回类型是 iterator,能编译是因为迭代器构造函数不是 explicit:
cpp
__list_iterator(Node* node) : _node(node) {}
如果加了 explicit,就要写 return iterator(next);。
size() 直接返回 _size,是 O(1);代价是 insert/erase 必须维护 ++_size / --_size,忘了就会对不上。

八、三句话总结
- const 迭代器是"指向 const 元素",不是"const 的迭代器对象" ;用
Ref/Ptr模板,而不是在迭代器前面加 const。 operator->返回指针 ,it->_row等价于it.operator->()->_row。erase返回下一个位置 ,clear里必须it = erase(it);析构先clear()再delete _head。
我踩过的坑
| 我一开始以为 | 实际 |
|---|---|
| 给迭代器加 const 就只读 | const 的是迭代器对象,反而不能遍历、还能改值 |
it->_row 是 (*it)->_row |
是 it.operator->()->_row |
拷贝构造拷 _head 就行 |
浅拷贝共享节点,析构 double delete |
erase(it); ++it; 可以 |
it 已失效,必须 it = erase(it) |
传值赋值要加 if 判断自赋值 |
传值参数是独立拷贝,自赋值天然安全 |
size() 每次遍历计数 |
用 _size 缓存,insert/erase 维护 |
这篇就到这里。下一篇继续 list 的迭代器分类、算法搭配,或者进入 stack/queue。