C++ 迭代器五分类与失效场景汇总:一张表避开所有 UB

作者:无名猿日期:2026/10/4

std::sort(lst.begin(), lst.end()) 编译不过,for (int x : v) { if (...) v.erase(...); } 跑起来会崩 —— 这两个问题的根子是同一件事:迭代器不是一种东西,而是分等级的,而且会在容器改动时失效。这篇文章把「迭代器五分类」和「失效规则」两块拼成一张可查的表,以后遇到迭代器相关的报错直接对表。

1. 引子:sort 为什么拒绝 list

给一个 std::list<int> 排序,最直观的写法是照抄 vector 的套路:

1// 反例,不要这么写:list 的迭代器不满足 sort 的要求,编译就过不去
2// std::list<int> lst{3, 1, 2};
3// std::sort(lst.begin(), lst.end());
4

线上编译器 gcc 13 会给出「没有匹配的 sort 重载」加一串模板推导失败的注解,一句话概括是:std::sort 的模板参数被约束成「随机访问迭代器」,而 std::list 的迭代器是「双向迭代器」,差了一级。 list 只能改成:

1// 正确写法:list 自带一个成员函数 sort
2// std::list<int> lst{3, 1, 2};
3// lst.sort();
4

这不是标准库在挑刺,而是算法和容器之间的一份性能契约:std::sort 内部是快速排序/内省排序,它需要「跳到第 n 个元素」「求两个迭代器的距离」「按下标二分」,这些操作只有随机访问迭代器才提供 O(1) 版本。list 的节点散落在堆上,it + n 只能靠一步步走,真放进去会退化成 O(n) 的随机访问,sort 的复杂度保证当场作废 —— 所以标准干脆在类型层面拒绝它,让 list::sort 用更适合链表的自底向上归并排序来做。

官方文档:std::sort(明确写着要求 LegacyRandomAccessIterator)、std::list::sort(成员函数版本,稳定性有保证)

2. 五类迭代器:能力是层层递进的

标准库把迭代器按「能做什么」分成五类(iterator category)。类别之间是包含关系:高类别的迭代器自动满足低类别的一切要求。

1  输入迭代器              前向迭代器          双向迭代器          随机访问迭代器
2  input iterator         forward            bidirectional       random access
3  ──────────────         ────────           ─────────────       ──────────────
4  只能读一次               能多趟遍历           能后退 --            能 +n / -n / it[n]
5  只能 ++                 只能 ++              ++ / --              能比大小 <  <= >  >=
6                                                                    能 O(1) 求距离
7
8  典型来源                典型来源             典型来源             典型来源
9  istream_iterator        forward_list         list / map / set     vector / deque / array
10  (读文件、读 stdin)    unordered_map        (双向链表 / 红黑树) 原生指针 / string
11
12  能力包含关系(箭头向右,能力只增不减):
13
14     输入 ──► 前向 ──► 双向 ──► 随机访问
15     输出 ──► 前向 ──► 双向 ──► 随机访问      ← 输出迭代器单独成一条线
16
17  记住一句话:**算法声明要求哪一类,就等于声明它能用哪些操作。**
18  给 std::sort(要求随机访问)传双向迭代器 = 缺了 +n 和 <,编译期就会被挡住。
19

把「能不能做」列成矩阵看得更清楚:

操作输入输出前向双向随机访问
读取 *it可以(只能读一次)不可以可以可以可以
写入 *it = v不可以可以可以(元素可写时)可以可以
++it 前进可以可以可以可以可以
保存 it 后再走一遍(多趟遍历)不行不行可以可以可以
--it 后退不行不行不行可以可以
it + n / it - n不行不行不行不行可以
it[n] 随机下标不行不行不行不行可以
it1 < it2 比位置前后不行不行不行不行可以
it2 - it1 求距离不行不行不行不行可以(O(1))
代表的操作istream_iteratorback_inserterforward_listlist / mapvector

「输入迭代器只能读一次」这条最反直觉:std::cin 消费的是字符流,读过去的字节回不来,所以保存一个 istream_iterator 然后想再走一遍是不成立的。

官方文档:迭代器库总览 — cppreference、std::iterator_traits

C++20 把这一整套重写成了概念(concept):std::input_iterator、std::random_access_iterator 等,还新增了一档 std::contiguous_iterator(连续迭代器,表示底层元素内存连续,vector / array / string 属于这一档)。分类思想没变,只是从「tag 继承」变成了「概念约束」,报错信息也因此友好得多。本文按 C++17 的 tag 体系讲,这是当前工作环境的口径。

3. 容器 ↔ 迭代器类别对照

容器 / 来源迭代器类别由此带来的限制
std::vector / std::array / std::string随机访问能用 sort,但插入/扩容极易失效
std::deque随机访问能用 sort,插入时几乎全部迭代器失效
std::list双向不能用 std::sort,要用 list::sort;没有 < 比较
std::forward_list前向只能单向走;删除要拿到「前一个位置」
std::map / std::set / 多重版本双向不能用 std::sort;但本身就按 key 有序
std::unordered_map / std::unordered_set前向反向遍历和 --it 都没有;rehash 后全失效
std::istream_iterator / std::istreambuf_iterator输入单趟,读完就没了
std::ostream_iterator / std::back_insert_iterator输出只能写,不能读也不能比位置
原生指针 T*随机访问(C++20 起为连续迭代器)数组不够长就是越界 UB

这张表有个实用推论:「我想反向遍历」这件事在 unordered_* 上做不到。因为它是前向迭代器,没有 rbegin() / rend()。要反序输出只能先收集到 vector 再 std::reverse。

4. 算法的最低迭代器要求速查

标准库算法在文档里都会标注所需的迭代器类别,这张表决定了「这个算法能不能用在这个容器上」:

算法最低要求因此不能用在这些容器上
std::find / std::count / std::for_each输入都能用
std::copy / std::transform输入 → 输出都能用
std::remove_if / std::unique前向都能用
std::rotate / std::inplace_merge前向 / 双向forward_list 之外基本都能用
std::reverse / std::next_permutation双向不能用 forward_list 和 unordered_*
std::lower_bound / std::equal_range前向(C++11 起放宽)都能用,但无序容器上语义无意义
std::sort / std::stable_sort随机访问不能用 list / map / set / unordered_*
std::partial_sort / std::nth_element随机访问同上
std::make_heap / std::push_heap随机访问同上
list::sort / forward_list::sort容器内建只在这两个容器上可用

官方文档:算法库总览 — cppreference(每个算法页面都标了 LegacyIterator 要求)

5. advance / next / distance 与 const_iterator

std::advance / std::next / std::prev / std::distance 是四个「按迭代器类别自动选实现」的工具,也是观察类别的窗口。

1// iterator_utils.cpp — 编译: g++ -std=c++17 -Wall -O2 iterator_utils.cpp -o demo
2#include <cstddef>
3#include <cstdio>
4#include <iterator>
5#include <list>
6#include <vector>
7
8int main() {
9    const std::vector<int> v{10, 20, 30, 40, 50};
10    const std::list<int> l{10, 20, 30, 40, 50};
11
12    // distance:随机访问迭代器走「直接相减」O(1),其余类别只能一步步 ++ 到 O(n)
13    std::printf("vector 距离 = %td(O(1):直接相减)\n", std::distance(v.begin(), v.end()));
14    std::printf("list   距离 = %td(O(n):逐个 ++)\n", std::distance(l.begin(), l.end()));
15
16    // next / prev:返回一个新迭代器,不修改入参
17    const auto vit = std::next(v.begin(), 2);
18    const auto lit = std::next(l.begin(), 2);
19    std::printf("next(vector::begin, 2) = %d\n", *vit);
20    std::printf("next(list::begin,   2) = %d\n", *lit);
21    std::printf("prev(next(v.begin, 2)) = %d\n", *std::prev(vit));
22
23    // advance:就地移动,没有返回值
24    auto ait = l.begin();
25    std::advance(ait, 3);
26    std::printf("advance(list::begin, 3) = %d\n", *ait);
27
28    // cbegin / cend:强制得到 const_iterator,从类型上禁止误改元素
29    const auto cit = v.cbegin();
30    std::printf("cbegin = %d\n", *cit);
31}
32
1vector 距离 = 5(O(1):直接相减)
2list   距离 = 5(O(n):逐个 ++)
3next(vector::begin, 2) = 30
4next(list::begin,   2) = 30
5prev(next(v.begin, 2)) = 20
6advance(list::begin, 3) = 40
7cbegin = 10
8

两个实用结论:

  • 别在循环里对非随机访问容器调 std::distance。 每次调用是 O(n),套在循环里就变成 O(n²)。对 list 求长度用 l.size()(C++11 起是 O(1))。
  • cbegin() / cend() 是「只读」的编译期保证,begin() 在 const 对象上才返回 const_iterator。函数参数故意写成 const auto& 或者显式用 cbegin(),能让「本意只读」这件事被编译器守住。

官方文档:std::distance、std::advance、std::next

6. 迭代器失效大表(全篇最该收藏的一节)

「迭代器失效(iterator invalidation)」指的是:容器做了某个操作后,之前拿到的迭代器不能再用了,继续解引用或自增就是未定义行为(undefined behavior,UB)。标准对每个容器的每种操作都有明确规定,汇总如下。

容器insert / emplaceerase(it)push_back / pop_back重分配 / rehashclear()
vector未超 capacity → 插入点之后的失效;超了 → 全部失效被删元素及其之后的全部失效push_back 同上(可能扩容);pop_back 只让被删元素失效reserve / 扩容 → 全部失效全部失效
deque全部迭代器失效(但指向元素的引用/指针仍有效)全部失效(元素本身还在的仍可引用)push_front / push_back → 全部失效;pop_* 只让被删元素失效不适用全部失效
list只有 end() 失效只有被删元素失效只有 end() 失效不适用全部失效
forward_list只有 end() / before_begin() 失效只有被删元素失效push_front 不影响其他迭代器不适用全部失效
map / set / 多重版本全部保持有效只有被删元素失效不适用不适用全部失效
unordered_map / unordered_set未 rehash → 保持有效;rehash → 全部失效只有被删元素失效不适用rehash → 迭代器全失效,但指向元素的指针/引用仍有效全部失效
string同 vector;SSO 短字符串时引用也可能失效同 vector同 vector同 vector全部失效
array不适用(定长)不适用不适用不适用不适用

三个最容易记混的点,拎出来单独说:

  1. vector 的「部分失效」有条件。只有 capacity 够、不发生重新分配时,才是「插入点之后的失效」;一旦扩容,整块缓冲区搬家,所有迭代器、指针、引用全废。第 7 节会把这个搬家过程画出来。
  2. deque 是「迭代器比引用脆」的典型。push_front / push_back 会让所有迭代器失效,但已经存在的元素不会搬家,所以指向元素的引用和指针仍然有效。这个区别在有外部缓存引用时很关键。
  3. list / map / set 是「节点式容器」,失效面最小。插入不搬任何已有节点,所以除 end() 外全部迭代器保持有效;删除也只影响被删的那个。想让「指向元素的指针/引用长期稳定」,就得选节点式容器。

另外,C++11 起 insert 和 erase 都有返回值,这一点是修正失效问题的基础:

  • erase(it) 返回被删元素之后的下一个有效迭代器。
  • insert(...) 返回指向新插入元素的迭代器。

官方文档:容器库 —— 迭代器失效规则汇总、std::vector 的失效说明、std::unordered_map 的失效说明

7. vector 扩容:迭代器失效的物理原因

前面反复提到「扩容导致全部失效」,跑一遍把这个过程看看清楚:

1  ① v.reserve(2) 后 push_back 两个元素,capacity 用满
2
3       v 的控制块 {begin, end, cap_end}
4          │
5          ▼
6        ┌─────┬─────┐
7        │  1  │  2  │       堆上的缓冲区(capacity = 2)
8        └─────┴─────┘
9          ▲
10          │  某个迭代器 it 也指向这里
11
12  ② v.push_back(3) —— capacity 不够,必须「另开一块更大的 + 把元素搬过去 + 释放旧的」
13
14        新缓冲区(capacity = 4)
15        ┌─────┬─────┬─────┬─────┐
16        │  1  │  2  │  3  │  —  │
17        └─────┴─────┴─────┴─────┘
18          ▲
19          │  v.begin() 现在指这里
20
21        ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
22        │  1  │  2  │  (旧缓冲区已释放)
23        └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
24          ▲
25          │  it 还指向这块已经失效的内存 → 悬垂迭代器(dangling iterator)
26             再用它解引用或 ++,就是 UB
27
1// vector_realloc.cpp — 编译: g++ -std=c++17 -Wall -O2 vector_realloc.cpp -o demo
2#include <cstdio>
3#include <vector>
4
5int main() {
6    std::vector<int> v;
7    v.reserve(2);                       // 预分配 2 个位置
8    v.push_back(1);
9    v.push_back(2);
10
11    const int* buffer_before = v.data();    // 记录缓冲区首地址,只用来比较「有没有搬家」
12    std::printf("填满 capacity 后: size=%zu capacity=%zu\n", v.size(), v.capacity());
13
14    v.push_back(3);                     // 超出 capacity → 重新分配 + 搬迁
15    std::printf("再插一个之后    : size=%zu capacity=%zu\n", v.size(), v.capacity());
16    std::printf("缓冲区搬家了吗: %s\n",
17                v.data() == buffer_before ? "没有(迭代器仍有效)" : "搬了(旧迭代器全部失效)");
18}
19
1填满 capacity 后: size=2 capacity=2
2再插一个之后    : size=3 capacity=4
3缓冲区搬家了吗: 搬了(旧迭代器全部失效)
4

所以「提前 reserve(n)」不只是性能优化(少几次分配和拷贝),它还是避免迭代器失效的手段 —— 容量一次给够,后面就不会因为扩容而整块搬家。这也是为什么《vector 扩容策略与迭代器失效全解》里反复强调「知道元素数量就 reserve」。

官方文档:std::vector::reserve、C++ Core Guidelines — SL.con.2 默认选 vector

8. 遍历中删除元素:两种必崩的写法

这是迭代器失效在真实代码里最高频的翻车现场。

1// 反例 1,不要这么写:erase 后 it 已经失效,下一轮 ++it 是 UB
2// for (auto it = v.begin(); it != v.end(); ++it) {
3//     if (*it % 2 == 0) {
4//         v.erase(it);      // it 失效;紧接着 for 的自增 ++it 踩在失效迭代器上
5//     }
6// }
7
8// 反例 2,不要这么写:范围 for 的隐藏迭代器改不了,删元素必然踩空
9// for (int x : v) {
10//     if (x % 2 == 0) {
11//         v.erase(v.begin());   // 隐藏迭代器不知道这回事,下一次自增就是 UB
12//     }
13// }
14

范围 for 会被展开成 auto&& __range = v; auto __it = begin(__range); ... ++__it,其中 __it 是编译器的隐藏变量,你拿不到也改不了。既然没法把它更新成 erase 的返回值,范围 for 里就不能删元素 —— 这是硬结论,不是风格问题。

正确写法只有一个模式:手动写循环、把 erase 的返回值接回来。

1// erase_pattern.cpp — 编译: g++ -std=c++17 -Wall -O2 erase_pattern.cpp -o demo
2#include <cstdio>
3#include <iterator>
4#include <list>
5#include <map>
6#include <vector>
7
8int main() {
9    // ① vector:erase 返回下一个有效迭代器,必须用它续上
10    std::vector<int> v{1, 2, 3, 4, 5, 6};
11    for (auto it = v.begin(); it != v.end();) {
12        if (*it % 2 == 0) {
13            it = v.erase(it);       // 关键:用返回值续上,不要 ++it
14        } else {
15            ++it;                   // 不删才前进
16        }
17    }
18    std::printf("vector 删偶数后: ");
19    for (int x : v) {
20        std::printf("%d ", x);
21    }
22    std::printf("\n");
23
24    // ② map:同一个模式,而且 erase 只让被删元素失效,其他迭代器不受影响
25    std::map<int, int> m{{1, 10}, {2, 20}, {3, 30}, {4, 40}};
26    for (auto it = m.begin(); it != m.end();) {
27        if (it->first % 2 == 0) {
28            it = m.erase(it);
29        } else {
30            ++it;
31        }
32    }
33    std::printf("map 删偶数 key 后大小 = %zu\n", m.size());
34
35    // ③ list:还是同一个模式(list 是双向迭代器,没有 +n,用 std::next 前进)
36    std::list<int> lst{1, 2, 3, 4, 5, 6};
37    for (auto it = lst.begin(); it != lst.end();) {
38        if (*it % 2 == 0) {
39            it = lst.erase(it);
40        } else {
41            it = std::next(it);
42        }
43    }
44    std::printf("list 删偶数后大小 = %zu\n", lst.size());
45}
46
1vector 删偶数后: 1 3 5 
2map 删偶数 key 后大小 = 2
3list 删偶数后大小 = 3
4

模式只有三行,记住它的形状就行:

1   for (auto it = c.begin(); it != c.end(); )   ← 注意 for 的第三格是空的
2   {
3       if (要删的条件)  it = c.erase(it);         ← 接住返回值,迭代器自己前进
4       else             ++it;                    ← 不删才手动前进
5   }
6
7   口诀:**删了就接返回值,没删就手动 ++;绝不同时做两件事。**
8

C++20 还给了更省事的写法:std::erase_if(container, pred),一行搞定,内部就是上面这个循环。

1// verify: std=c++20
2// 需要 C++20:std::erase_if 统一了「按条件删除」的写法
3// std::erase_if(v, [](int x) { return x % 2 == 0; });
4// std::erase_if(m, [](const auto& kv) { return kv.first % 2 == 0; });
5

9. 完整示例:靠迭代器类别做编译期分派

最后把「类别」这件事用起来。标准库自己就是这么干的(std::distance 内部按类别分派),我们也能用 std::iterator_traits + if constexpr 写一个「随机访问就 O(1) 求长度,否则老老实实数」的版本:

1// category_dispatch.cpp — 编译: g++ -std=c++17 -Wall -O2 category_dispatch.cpp -o demo
2#include <cstddef>
3#include <cstdio>
4#include <forward_list>
5#include <iterator>
6#include <list>
7#include <map>
8#include <type_traits>
9#include <vector>
10
11namespace {
12
13// 按迭代器类别在编译期选实现:随机访问直接相减,其余类别逐个 ++
14template <typename It>
15std::size_t countElems(It first, It last) {
16    using Category = typename std::iterator_traits<It>::iterator_category;
17    if constexpr (std::is_base_of_v<std::random_access_iterator_tag, Category>) {
18        return static_cast<std::size_t>(last - first);   // O(1)
19    } else {
20        std::size_t n = 0;
21        for (; first != last; ++first) {                 // O(n)
22            ++n;
23        }
24        return n;
25    }
26}
27
28}  // namespace
29
30int main() {
31    const std::vector<int> v{1, 2, 3, 4, 5};
32    const std::list<int> l{1, 2, 3};
33    const std::forward_list<int> f{1, 2, 3, 4};
34    const std::map<int, int> m{{1, 10}, {2, 20}};
35
36    std::printf("vector       个数 = %zu(随机访问,O(1) 相减)\n", countElems(v.begin(), v.end()));
37    std::printf("list         个数 = %zu(双向,O(n) 逐走)\n", countElems(l.begin(), l.end()));
38    std::printf("forward_list 个数 = %zu(前向,O(n) 逐走)\n", countElems(f.begin(), f.end()));
39    std::printf("map          个数 = %zu(双向,O(n) 逐走)\n", countElems(m.begin(), m.end()));
40}
41
1vector       个数 = 5(随机访问,O(1) 相减)
2list         个数 = 3(双向,O(n) 逐走)
3forward_list 个数 = 4(前向,O(n) 逐走)
4map          个数 = 2(双向,O(n) 逐走)
5

这段代码正好收束了全篇的主线:

  • std::iterator_traits<It>::iterator_category 是「问编译器这个迭代器属于哪一类」的标准入口。
  • if constexpr(C++17)让分支在编译期就被丢弃 —— last - first 这段代码对 list 根本不会被实例化,所以即使双向迭代器没有 operator-,编译也不会报错。这是泛型代码里处理「能力差异」的标准手法。
  • std::is_base_of_v 之所以能用来判断类别,正因为五类迭代器的 tag 之间是继承关系(random_access_iterator_tag 继承自 bidirectional_iterator_tag,一路到 input_iterator_tag),这也是第 2 节那张包含关系图的类型层面体现。

官方文档:std::iterator_traits、std::random_access_iterator_tag、if constexpr(C++17)

10. 延伸阅读

11. 一句话总结

迭代器的类别决定了「能对容器做什么」,容器的失效规则决定了「拿到手的迭代器还能活多久」——算法挑类别(sort 要随机访问,list 不满足)、代码避失效(vector 扩容全废、节点容器最稳)、遍历中删除一律走「it = c.erase(it) 或 ++it,二选一」这一个模式。三件事记牢,迭代器相关的 UB 基本就绝迹了。


参考文档


《C++ 迭代器五分类与失效场景汇总:一张表避开所有 UB》 是转载文章,点击查看原文。


相关推荐


第 28 章 案例四 多智能体协作系统
前端阿凡2026/9/27

第 28 章 案例四:多智能体协作系统 本章要解决的问题 行业分析报告需要研究员、数据员、写手协作完成——多智能体系统的拓扑、通信、可观测性实战。 章节大纲 28.1 多 Agent 拓扑设计(主从 + 流水线) 28.2 通信协议与任务编排 28.3 可观测性与调试 28.4 上线与迭代 🛠 解决方案:多智能体上下文隔离方案 + 协作效率度量 28.1 场景与拓扑设计 28.1.1 场景:行业分析报告生成 业务:投研团队要生成行业分析报告,人工流程: 研究员查资料 → 数据分析师算指


第28课-AJAX与前端框架
qq_269506752026/9/20

第 28 课:AJAX 与前端框架 本课目标:掌握 AJAX 异步请求、Fetch API、async/await 语法,了解 Vue.js 基础用法和 SPA 单页应用概念,能够实现前后端数据交互。 一、概念讲解 1.1 什么是 AJAX AJAX(Asynchronous JavaScript And XML)异步 JavaScript 和 XML,是一种在无需重新加载整个页面的情况下,与服务器交换数据并更新部分网页内容的技术。 1.2 AJAX 工作流程 ┌───


【AI大模型接入SDK】ChatGPT API
艾莉丝努力练剑2026/9/12

🎬 个人主页:艾莉丝努力练剑 ❄专栏传送门:《C语言》《数据结构与算法》《C/C++干货分享&学习过程记录》 《Linux操作系统编程详解》《笔试/面试常见算法:从基础到进阶》《Python干货分享》 ⭐️为天地立心,为生民立命,为往圣继绝学,为万世开太平 🎬 艾莉丝的简介: 文章目录 1 ~> OpenAI API 体系与版本演进1.1 两套核心 API 定位1.2 核心能力对比1.3 官方选型建议 2 ~> Chat Completion


最新大数据毕业设计选题推荐-基于大数据的电商与本地服务消费评论数据可视化分析-大数据-Spark-Hadoop-Bigdata
IT研究室2026/9/4

✨作者主页:IT研究室✨ 个人简介:曾从事计算机专业培训教学,擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python项目 安卓项目 微信小程序项目 文章目录 一、前言二、开发环境三、系统界面展示四、代码参考五、系统视频结语 一、前言 系统介绍 本系统《基于大数据的电商与本地服务消费评论数据可视化分析》以Hadoop分布式文件系


MySQL DQL全面解析:从入门到精通
渣渣盟2026/8/27

​ 在数据库的广阔天地中,MySQL 凭借其开源、高效、易用等特性,成为了众多开发者的首选。而在 MySQL 的众多功能中,数据查询语言(Data Query Language,简称 DQL)无疑是最为常用且强大的部分之一。通过 DQL,我们可以从数据库中检索出所需的数据,进行各种复杂的数据分析和处理。本文将深入探讨 MySQL DQL 的各个方面,帮助你全面掌握这一重要技能。 一、DQL 基础:SELECT 语句入门 DQL 的核心是 SELECT 语句,它的基本语法如下: SELECT co


我做了一个软著 Skill,可以一键生成申请材料
IvanCodes2026/8/19

Hello,大家好,我是Ivan。 大家做完一个项目以后,可能会遇到一个问题,需要申请软著。这时候,申请表、操作手册和代码材料就都需要重新整理一遍,很麻烦,浪费时间。 所以,我把这部分做成了一个软著 Skill,名字叫 software-certificate-skill。把项目交给它以后,它会读取项目里的代码、页面和接口,然后生成申请表信息、操作手册和代码材料。 skill已经开源了,github链接是 https://github.com/IvanCodesDev/software-c


鸿蒙应用开发:V1与V2版本数据持久化实战教程
程序员黑豆2026/8/6

这是一个使用鸿蒙技术开发的本地原生记账应用,非常适合大家用来练手。相关源码已上传至 Github,点击此处查看项目。欢迎大家交流、指正,也欢迎提交 PR。 一、引言 在鸿蒙应用开发中,数据持久化是构建完整应用体验的关键一环。无论是保存用户的登录状态、个人偏好,还是缓存应用的核心数据,都需要一套可靠且高效的持久化方案。随着HarmonyOS版本的演进,数据持久化能力也从V1版本进化到了V2版本,带来了更强大的功能和更灵活的使用方式。 本文将深入对比V1(PersistentStorage + A


上线一个人静态网站需要多少钱,难不难?
五阳2026/7/28

不难,有合法身份证就能办,只需要花费 10 元,就能发布一个网站。 但是有门槛,先说门槛,如果你的网站需要中国大陆访问,那么必须要域名备案,不同省份等待时间不同。不过最多两周,最少 1 周也能审核完成。 有人问域名不备案就访问不通吗?不是的,我在阿里云申请的域名还没来得及备案,据我观察,大约有 2-3 周时间内,是允许中国大陆用户访问的,但是三周以后如果你还没有备案,那么就会被封掉,但是海外用户还能访问。 这是上线一个网站最困难和煎熬的环节了。 注意:国内个人用户备案域名,只能备案个人博客用途,


Agentic RAG 入门:从固定检索到自主决策
copyer_xyf2026/7/20

普通 RAG 的思路很直接:用户提出问题,系统从知识库检索相关片段,再让大模型根据这些片段生成回答。 这条链路解决了一个重要问题:模型不必只依赖训练时记住的知识,而是可以在回答前读取企业文档、产品手册、业务数据等外部资料,再根据资料组织答案。 但传统 RAG 的执行流程通常是固定的。这里的“固定”,不是说每次召回的文档都相同,而是说无论用户问什么、检索结果质量如何,程序都会按照上图展示的同一条路径执行。它不会在运行过程中重新判断,也不会主动改变检索策略。 但是,这种固定流程会遇到几个实际问题:


AEO 答案引擎优化:从“被搜索”到“被引用”的 AI 营销下一站
A亨日记2026/7/11

一、AI 正在改写“搜索”的默认行为 过去二十年,用户打开百度、Google 的第一件事是输入关键词,然后在十条蓝色链接里选择。但今天,越来越多的人直接向 DeepSeek、豆包、Kimi、ChatGPT 提问,并期待得到一个“直接可用”的答案。 这意味着企业的营销目标正在发生根本转移: SEO 时代:争取搜索结果页的前十排名;GEO 时代:争取被生成式引擎在回答中主动引用;AIO 时代:用结构化数据与反馈闭环持续优化 AI 对企业的“认知”;AEO 时代:直接为答案引擎生产“可被引用的高置信度

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2026 聚合阅读