CppCon 2016 学习:STL Algorithms - How to use them； how to write your own
- 算法（Algorithms）：用模板函数写的、通用且有用的功能块，比如排序、查找、转换等。
- 为什么用STL算法（标准模板库算法）：
- 经过充分测试和调试，稳定可靠
- 是编写复杂代码的基本积木
- 使用STL算法写代码更简洁、更易读
- 容易调试和维护
- 方便代码复审和改进
你给的例子是经典的 冒泡排序 实现，然后用 STL 的std::sort替代：
std::vector<int> v{0,1,3,5,7,9,2,4,6,8};
// 手写冒泡排序
bool flag = true;
while(flag) {
flag = false;
for (int j = 0; j < (v.size() -1); j++) {
if (v[j+1] < v[j]) {
std::swap(v[j], v[j+1]);
flag = true;
}
}
}
for (int i : v) std::cout << i << " ";
std::cout << "\n";
// STL排序，简单又高效
std::vector<int> v2{0,1,3,5,7,9,2,4,6,8};
std::sort(v2.begin(), v2.end());
for (int i : v2) std::cout << i << " ";
重点：
- 用STL算法更简洁、高效、易维护。
- STL算法底层实现往往更优化，不用担心细节。
- 代码可读性更强，别人更容易理解。
一些 算法 的示例，类似于 std::min 这样简单的模板函数。下面我给你几个常用算法的简单版本示例，帮助理解它们的工作原理：
1. std::min
template <typename T>
const T& min(const T& a, const T& b) {
return (a < b) ? a : b;
}
- 返回两个值中较小的那个。
2. std::max
template <typename T>
const T& max(const T& a, const T& b) {
return (a > b) ? a : b;
}
- 返回两个值中较大的那个。
3. std::swap
template <typename T>
void swap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
- 交换两个变量的值。
4. std::find
template <typename Iterator, typename T>
Iterator find(Iterator begin, Iterator end, const T& value) {
for (Iterator it = begin; it != end; ++it) {
if (*it == value)
return it;
}
return end;
}
- 在区间
[begin, end)找到第一个等于value的元素，返回它的迭代器；找不到则返回end。
5. std::accumulate
template <typename Iterator, typename T>
T accumulate(Iterator begin, Iterator end, T init) {
for (Iterator it = begin; it != end; ++it) {
init = init + *it;
}
return init;
}
- 将区间内元素依次累加到
init。
总结
- 这些算法都写得很通用，用模板实现。
- 你只要传入数据和区间，就能复用这些算法。
- STL 里的算法都是类似设计，只不过更复杂、功能更多。
给的 std::copy 示例很棒，下面我帮你详细解释一下：
std::copy 简单版实现
template <typename IIter, typename OIter>
OIter copy(IIter first, IIter last, OIter res) {
for (; first != last; ++first, ++res)
*res = *first;
return res;
}
说明：
- 功能：
把[first, last)范围内的元素逐个复制到以res开始的目标位置。 - 参数：
IIter first, last：输入迭代器，指定要复制的范围。OIter res：输出迭代器，指定复制目标起点。
- 返回值：
返回复制结束后目标的迭代器位置（即最后一个写入元素的下一位置）。
用法示例：
std::vector<int> src{1, 2, 3, 4, 5};
std::vector<int> dst(5);
copy(src.begin(), src.end(), dst.begin());
for (int x : dst)
std::cout << x << " "; // 输出: 1 2 3 4 5
作用
std::copy 是最基本、常用的算法之一，广泛用于数组、容器数据搬运。
adjacent_pair 很清晰，就是遍历容器中相邻的元素对，然后对每对元素执行一个函数 f。简单总结一下：
adjacent_pair 函数模板解析
template <typename FwIter, typename Func>
void adjacent_pair(FwIter first, FwIter last, Func f) {
if (first != last) {
FwIter trailer = first; // 指向前一个元素
++first; // 指向后一个元素
for (; first != last; ++first, ++trailer) {
f(*trailer, *first); // 对相邻元素调用函数
}
}
}
说明
- 输入是一个范围
[first, last)和一个函数f。 - 先让
trailer指向第一个元素，first指向第二个元素。 - 循环中，
f被调用，参数是相邻两个元素。 - 这样会调用
f(n-1)次，处理所有相邻的元素对。
用法示例
std::vector<int> v{1, 3, 6, 10};
adjacent_pair(v.begin(), v.end(), [](int a, int b) {
std::cout << "(" << a << ", " << b << ") ";
});
// 输出: (1, 3) (3, 6) (6, 10)
总结
- 这个函数适合处理邻接元素对相关的操作，比如计算差值、比较、合并等。
- 类似
std::for_each，但只针对相邻两元素。
for_all_pairs 函数是用来遍历区间内的所有不重复的元素对，并对每对元素调用函数 f。这是一个经典的双重循环模式。
代码解析
template <typename FwIter, typename Func>
void for_all_pairs(FwIter first, FwIter last, Func f)
{
if (first != last)
{
FwIter trailer = first; // 外层指针
++first; // 内层指针起点，总是在外层之后
for (; first != last; ++first, ++trailer)
for (FwIter it = first; it != last; ++it)
f(*trailer, *it);
}
}
运行机制
trailer指向当前第一个元素（左元素）first指向比trailer位置往后一个的元素（右元素的起点）- 内层循环遍历
first到last，生成所有和trailer配对的元素。 - 这样能保证不重复、不对称（即
(a,b)出现一次，不出现(b,a)）。
举例
std::vector<int> v{1, 2, 3};
for_all_pairs(v.begin(), v.end(), [](int a, int b){
std::cout << "(" << a << ", " << b << ") ";
});
输出：
(1, 2) (1, 3) (2, 3)
作用场景
- 需要比较、处理所有元素对的情况（比如计算距离矩阵、两两比较等）
- 保证不会重复计算同一对元素
这是一个很实用的自定义算法模板，叫 copy_while，它的功能是从输入区间 [first, last) 拷贝元素到输出迭代器 result，直到遇到第一个不满足条件 p 的元素就停止。
代码分析
template<typename InIter, typename OutIter, typename Pred>
std::pair<InIter, OutIter>
copy_while(InIter first, InIter last, OutIter result, Pred p)
{
for (; first != last && p(*first); ++first, ++result)
*result = *first;
return std::make_pair(first, result);
}
first是输入序列的开始迭代器。last是输入序列的结束迭代器。result是输出序列的开始迭代器。p是一个一元谓词函数，判断元素是否满足某条件。
运行逻辑
- 从
first到last，遍历元素。 - 只要
p(*first)为true，就将元素复制到输出result。 - 一旦
p(*first)为false或到达结尾，停止循环。 - 返回当前输入迭代器位置和输出迭代器位置。
返回值
- 返回一个
std::pair：first指向第一个不满足条件的元素（或last，如果全部满足）。result指向输出序列中下一个可写位置。
用法示例
std::vector<int> input{1, 2, 3, 4, 5, 6};
std::vector<int> output;
output.resize(input.size());
auto is_less_than_4 = [](int x) { return x < 4; };
auto result = copy_while(input.begin(), input.end(), output.begin(), is_less_than_4);
// 复制了1, 2, 3到output，result.first指向元素4的位置
总结
copy_while是std::copy_if的一个变种，只复制满足条件的连续前缀。- 可用于需要“复制直到不满足条件”为止的场景。
- 返回剩余未处理区间，方便后续操作。
这是一个通用的 split 函数模板，用来根据分隔符 t 将输入区间 [first, last) 拆分成多个子区间，并对每个子区间调用回调函数 f。
代码分析
template <typename InIter, typename T, typename Func>
void split(InIter first, InIter last, const T &t, Func f)
{
while (true)
{
InIter found = std::find(first, last, t);
f(first, found);
if (found == last)
break;
first = ++found;
}
}
- 参数说明：
first,last：输入区间的迭代器。t：分隔符元素。f：函数对象或lambda，接受两个迭代器参数[begin, end)，表示拆分出的子区间。
运行逻辑
- 在
[first, last)区间内查找第一个等于分隔符t的元素位置found。 - 调用
f(first, found)，把当前子区间[first, found)传给回调函数。 - 如果
found是最后一个元素，结束循环。 - 否则，跳过分隔符，
first = found + 1，继续拆分剩余区间。
举个例子
std::string s = "apple,banana,orange";
auto print_substr = [&](auto begin, auto end) {
std::cout << std::string(begin, end) << "\n";
};
split(s.begin(), s.end(), ',', print_substr);
输出：
apple
banana
orange
总结
- 这个
split函数利用迭代器和回调函数完成分割，灵活且泛用。 - 不限制容器类型，只要支持迭代器和
std::find。 - 对于每个分割出的区间都调用一次
f，方便后续处理。
这段代码定义了一个通用的模板函数 adjacent_pair，用于遍历一个区间内的元素，并对每对相邻元素调用一个给定的函数 f。
代码结构及理解：
template <typename FwIter, typename Func>
void adjacent_pair(FwIter first, FwIter last, Func f)
{
if (first != last) // 如果区间非空
{
FwIter trailer = first; // 指向第一个元素
++first; // first 指向第二个元素
for (; first != last; ++first, ++trailer)
f(*trailer, *first); // 对相邻的两个元素调用函数 f
}
}
参数说明：
FwIter first, last：输入迭代器，表示要遍历的区间[first, last)。Func f：函数对象，接受两个参数，两个相邻元素的引用或值，类型大致是void(const T&, const T&)。
具体做了什么？
- 先判断区间是否为空，如果为空，什么都不做。
trailer指向第一个元素，first指向第二个元素。- 进入循环，直到
first == last：- 调用函数
f(*trailer, *first)，即把当前元素和它后面的相邻元素传给回调函数。 trailer和first同时向后移动一位，保证下一次调用是下一个相邻对。
- 调用函数
举个例子：
假设你有一个整数序列，你想对每对相邻元素求和并打印：
std::vector<int> v = {1, 3, 5, 7};
adjacent_pair(v.begin(), v.end(), [](int a, int b){
std::cout << a << " + " << b << " = " << a + b << std::endl;
});
输出：
1 + 3 = 4
3 + 5 = 8
5 + 7 = 12
总结：
adjacent_pair遍历序列的相邻元素对，依次执行f。- 适合处理需要比较或操作相邻元素的场景，比如相邻差值、相邻元素组合等。
- 对输入迭代器有前向迭代器（Forward Iterator）的要求，因为要做两个指针的迭代。
写的这个版本是 adjacent_pair 函数的改写，用了“值拷贝”的方式保存上一个元素，而不是用迭代器 trailer 指向上一个元素。
template <typename InIter, typename Func>
void adjacent_pair(InIter first, InIter last, Func f)
{
if (first != last)
{
???? trailer = *first; // What type is this?
++first;
for (; first != last; ++first)
{
f(trailer, *first);
trailer = *first;
}
}
}
关键点在于 trailer 的类型是什么？
因为 trailer 是用来保存上一个元素的值，而不是迭代器，所以：
trailer的类型应该和解引用迭代器*first返回的类型一致。- 迭代器解引用类型是
decltype(*first)，但注意它可能是引用类型（如int&），我们需要值类型。 - 用
auto自动推导时，auto trailer = *first;会得到值类型（拷贝），这是最简单的写法。 - 也可以用
typename std::iterator_traits来显式写出类型。::value_type trailer = *first;
所以，完整的写法可以是：
template <typename InIter, typename Func>
void adjacent_pair(InIter first, InIter last, Func f)
{
if (first != last)
{
auto trailer = *first; // 拷贝第一个元素的值
++first;
for (; first != last; ++first)
{
f(trailer, *first);
trailer = *first; // 更新上一个元素值
}
}
}
或者写得更明确点：
template <typename InIter, typename Func>
void adjacent_pair(InIter first, InIter last, Func f)
{
using ValueType = typename std::iterator_traits<InIter>::value_type;
if (first != last)
{
ValueType trailer = *first;
++first;
for (; first != last; ++first)
{
f(trailer, *first);
trailer = *first;
}
}
}
这版 adjacent_pair 和之前版本的区别
- 之前用的是两个迭代器，
f接受的是两个元素的引用或值，调用时写f(*trailer, *first)。 - 这版用值拷贝保存前一个元素，
f直接用trailer和*first，这样避免了维护两个迭代器。 - 适合输入迭代器（Input Iterator），因为只需要单向遍历，且保存一个值拷贝，不需要回溯。
总结：
trailer类型就是迭代器指向元素的“值类型”，用auto即可，或用std::iterator_traits显式指定。
代码说明
template <typename InIter, typename Func>
void adjacent_pair(InIter first, InIter last, Func f)
{
if (first != last)
{
// 使用迭代器的值类型定义trailer，保存前一个元素的拷贝
typename std::iterator_traits<InIter>::value_type trailer = *first;
++first;
for (; first != last; ++first)
{
// 调用用户提供的函数f，传入相邻的两个元素
f(trailer, *first);
// 更新trailer为当前元素，准备下一轮比较
trailer = *first;
}
}
}
作用和流程
adjacent_pair模板函数遍历[first, last)范围内的元素，针对所有相邻元素对调用f。- 使用
trailer保存前一个元素的拷贝，避免使用两个迭代器。 - 首先把
trailer初始化为第一个元素的值，然后从第二个元素开始遍历。 - 对每个元素调用
f(trailer, *first)，即处理相邻的两个元素。 - 更新
trailer为当前元素的值，继续下一轮。
适用场景
- 你可以用这个函数来处理序列中每一对相邻元素，比如比较、合并或计算差异等。
- 由于
trailer是元素的拷贝，适合元素类型可拷贝的序列。 - 适用任何符合输入迭代器规范的容器或范围。
例子
std::vector<int> v = {1, 3, 6, 10};
adjacent_pair(v.begin(), v.end(), [](int a, int b) {
std::cout << a << " -> " << b << "\n";
});
输出：
1 -> 3
3 -> 6
6 -> 10
总结
trailer用来保存上一个元素的“值”。- 用
std::iterator_traits明确写出::value_type trailer类型，便于泛型编程。 - 逻辑简单且有效，避免了维护两个迭代器。
这是一种基于迭代器类别选择不同实现的模板编程技巧，通常称为标签分派（tag dispatching）。我帮你详细拆解：
主要思想
- 不同类型的迭代器支持不同的操作（比如随机访问、双向访问、单向访问等）。
- 我们希望针对不同迭代器类型，写出不同的函数实现，做到高效且类型安全。
- 迭代器类别信息存储在
std::iterator_traits里，比如：::iterator_category std::input_iterator_tagstd::forward_iterator_tagstd::bidirectional_iterator_tagstd::random_access_iterator_tag
- 这些类别之间存在继承关系，如随机访问迭代器继承自双向迭代器，双向迭代器继承自前向迭代器，依此类推。
代码结构解释
// 适用于前向迭代器的实现
template <typename FWIter, typename Func>
void adjacent_pair_impl(FWIter first, FWIter last, Func f, std::forward_iterator_tag);
// 适用于输入迭代器的实现
template <typename InIter, typename Func>
void adjacent_pair_impl(InIter first, InIter last, Func f, std::input_iterator_tag);
// 主函数，调用对应版本
template <typename Iterator, typename Func>
void adjacent_pair(Iterator first, Iterator last, Func f)
{
return adjacent_pair_impl(first, last, f,
typename std::iterator_traits<Iterator>::iterator_category());
}
关键点
- 传入的最后一个参数是迭代器类别类型的临时对象，例如
std::forward_iterator_tag()。 - 编译器根据这个参数的类型自动匹配调用对应的
adjacent_pair_impl重载版本。 - 利用继承关系：如果传入的是
std::random_access_iterator_tag，编译器也可以匹配接受基类std::forward_iterator_tag的函数（除非专门为随机访问迭代器写了更具体版本）。 - 这样实现了根据迭代器类型“自动分派”调用最合适的实现。
举个简单的示例
#include 总结
iterator_category告诉你迭代器类别。- 你写多个重载版本（用不同标签做区分）。
- 主函数通过标签参数调用对应实现（标签分派）。
- 编译器帮你自动根据迭代器类型挑最合适的函数。