C++ 入门笔记(十八):list 进阶 —— const 迭代器、operator-> 与 clear 的坑

先问一个问题:为什么 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 != &lt)。

六、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,忘了就会对不上。

八、三句话总结

  1. const 迭代器是"指向 const 元素",不是"const 的迭代器对象" ;用 Ref/Ptr 模板,而不是在迭代器前面加 const。
  2. operator-> 返回指针 ,it->_row 等价于 it.operator->()->_row。
  3. 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。

相关推荐
一起学安全技术14 分钟前
拆大模型 11|大模型面试拷问:12 问逐层拆
人工智能·ai·语言模型·面试·职场和发展·求职招聘
nice_lcj52043 分钟前
【从零理解计算机网络 · 04】TCP 三次握手:为什么恰好是三次
java·后端·tcp/ip·计算机网络·面试·tcp·三次握手
ShineWinsu1 小时前
对于Qt:QVBoxLayout常见属性以及方法的解析
开发语言·数据库·c++·qt·gui·客户端·布局管理器
思想觉悟1 小时前
Android启动流程之点rc文件
android·linux·面试
ShineWinsu12 小时前
对于Qt:QFormLayout常见属性以及方法的解析
开发语言·c++·qt·面试·客户端·表单·qformlayout
kyle~13 小时前
嵌入式 SoC 系统
linux·c++·嵌入式·计算系统
nice_lcj52013 小时前
MySQL 主从复制与读写分离:从库怎么跟着主库走
数据库·mysql·面试·binlog·读写分离·主从复制
ashiho14 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
CoderYanger15 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第二弹)
java·数据库·面试·职场和发展·java-ee·tomcat·mybatis