C++ 中 std::search 查找子序列首次出现：别被“子串”思维带偏了

刚写完一段字符串处理代码，朋友发来消息：“search 怎么总找不到我的子序列？我明明写了 vector<int>{1,3,5}，源里也有这三个数啊。”
——这太常见了。很多人一看到 std::search，下意识就当成“C++ 版 strstr”，默认它要找连续、紧挨着的元素。但其实，search 的核心语义是‘查找完全匹配的连续子序列’，不是‘跳着找元素’，也不是‘判断是否为子集’。它找的是内存中真实相邻的一段，和你手写 for 循环逐个比对的行为逻辑一致，只是封装得更稳。

先划重点：std::search 从不跳过中间元素，也不做任何排序或重排；它只忠实地检查一段连续内存里，是否原样出现了你要找的那一小段。比如在 {2,1,3,5,7,9} 中查 {1,3,5}，它会成功；但查 {1,5,3} 或 {1,7,5} 就失败——哪怕数字都存在，顺序或间隔不对，就不算。

那怎么用？标准写法长这样：

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> haystack = {4, 2, 1, 3, 5, 8, 1, 3, 5, 6};
    std::vector<int> needle   = {1, 3, 5};

    auto it = std::search(haystack.begin(), haystack.end(),
                          needle.begin(), needle.end());

    if (it != haystack.end()) {
        std::cout << "找到啦，起始位置索引：" << (it - haystack.begin()) << "\n";
        // 输出：找到啦，起始位置索引：2
    } else {
        std::cout << "没找到\n";
    }
}

这里的关键不是语法，而是理解迭代器返回值的含义：it 指向的是匹配成功的第一个元素（即 1），不是整个子序列的“包装体”。你可以直接用 it + needle.size() 安全访问末尾，也能拿它做后续操作——比如删掉第一次出现的 {1,3,5}，只需 haystack.erase(it, it + needle.size());。

有人试过用 search 查 vector 里的结构体，结果编译报错。原因很实在：默认比较用 operator==，而你的类如果没定义它，或者定义得不满足严格相等（比如只比了部分成员），就会静默失败或行为异常。解决办法简单粗暴：显式传入自定义谓词。

比如你有个 Person 类，只想按 id 匹配：

struct Person { int id; std::string name; };
std::vector<Person> people = {{101,"Alice"},{205,"Bob"},{101,"Charlie"}};
std::vector<Person> target = {{101,"?"}}; // 注意：这里 name 不重要，我们只看 id

auto it = std::search(people.begin(), people.end(),
                      target.begin(), target.end(),
                      [](const Person& a, const Person& b) {
                          return a.id == b.id; // 只比 id
                      });

这个 lambda 是真正的“开关”——它把模糊的“相等”变成了明确的业务规则。没有它，search 根本不知道两个 Person 算不算一样。

还有一种典型踩坑：用 search 查 std::string 时混用窄字符和宽字符。比如 std::wstring 里调 search，却传入 std::string 字面量 "abc"，编译器不会自动转，直接罢工。类型必须严格一致：wstring::begin() 配 wstring::end()，string_view 配 string_view，连 const char* 都得小心隐式转换陷阱。

顺带提一句，search 的时间复杂度是 O(n×m)，在海量数据里反复调用可能变慢。如果需要高频查找且模式固定，不如提前建好 KMP 失败函数，或者改用 std::boyer_moore_searcher（C++17 起）——它底层优化了跳过逻辑，实测在长文本中快 3–5 倍。不过，日常开发里，除非 profiler 明确指出 search 是瓶颈，否则别过早替换；原生 search 足够清晰、足够可靠，也足够快。

最后说个容易被忽略的细节：空序列。当 needle 为空（比如 vector<int>{}），std::search 永远返回 haystack.begin()——这是标准规定的，不是 bug。如果你的业务逻辑里“空”有特殊含义（比如代表通配），就得在调用前加一层判断，而不是依赖 search 给你“合理”的结果。

回到开头那个朋友的问题。他后来发现，自己想查的根本不是子序列，而是“数组 A 中是否存在 B 的所有元素（不要求连续）”。那是 std::includes 的活儿，或者手写 std::unordered_set 判包含。工具不是万能钥匙，关键是先问清楚：你真正想找的，到底是什么样的“出现”？

search 不负责猜测意图，它只执行指令。写对了，它安静又精准；写错了，它也一声不吭——就像一个只认图纸不问用途的老师傅。用好它的前提，从来不是背熟参数列表，而是把问题本身想透。