C++中处理std::vector相邻元素的惯用方法是什么？

我经常需要执行依赖于std::vector中两个相邻元素比较的操作，简化示例如下：

void foo()
{
    std::vector<int> v;
    for (size_t i = 0; i < v.size(); ++i)
    {
        if (i + 1 < v.size())
        {
            if (v[i + 1] > v[i])    // some condition
            {
                // compound statement X
            }
            else
            {
                // compound statement Y
            }
        }
        else
        {
            // compound statement Y
        }
    }
}

当两个复合语句内容较多时，该结构难以维护，重复的边界检查和索引操作也显得繁琐。请问在C++中是否有更惯用或更简洁的方法来遍历并处理vector的相邻元素？

惯用的简化方案 #

1. 拆分遍历逻辑，分离相邻对与末尾元素处理 #

把相邻元素对的遍历和最后一个元素的处理拆成独立逻辑，消除嵌套判断，让代码结构更扁平：

void foo()
{
    std::vector<int> v;
    // 遍历所有相邻元素对
    for (auto it = v.begin(); it != prev(v.end()); ++it) {
        auto next_it = next(it);
        if (*next_it > *it) {
            // compound statement X
        } else {
            // compound statement Y
        }
    }
    // 单独处理最后一个元素（容器非空时）
    if (!v.empty()) {
        // compound statement Y
    }
}

如果compound statement Y代码量较大，建议将其提取为独立函数，彻底消除代码重复。

2. 封装业务逻辑，解耦遍历与处理 #

将X、Y对应的业务逻辑封装成独立函数，让遍历代码只负责流程控制，可读性和维护性大幅提升：

void handle_case_X(const int& curr, const int& next) {
    // compound statement X
}

void handle_case_Y(const int& elem) {
    // compound statement Y
}

void foo()
{
    std::vector<int> v;
    for (auto it = v.begin(); it != v.end(); ++it) {
        if (next(it) != v.end()) {
            *next(it) > *it ? handle_case_X(*it, *next(it)) : handle_case_Y(*it);
        } else {
            handle_case_Y(*it);
        }
    }
}

3. C++20+：用范围库简化相邻元素遍历 #

利用C++20引入的<ranges>库，通过views::pairwise直接生成相邻元素对，省去手动管理迭代器的麻烦：

#include <ranges>

void foo()
{
    std::vector<int> v;
    // 遍历所有相邻元素对
    for (auto [curr, next] : v | std::views::pairwise) {
        if (next > curr) {
            // compound statement X
        } else {
            // compound statement Y
        }
    }
    // 处理最后一个元素
    if (!v.empty()) {
        handle_case_Y(v.back());
    }
}

4. 合并条件判断，减少分支嵌套 #

观察原逻辑可知：仅当存在下一个元素且满足条件时执行X，其余所有情况都执行Y。可以将嵌套条件合并为单个布尔判断，简化代码：

void foo()
{
    std::vector<int> v;
    for (size_t i = 0; i < v.size(); ++i) {
        const bool should_execute_X = (i + 1 < v.size()) && (v[i+1] > v[i]);
        if (should_execute_X) {
            // compound statement X
        } else {
            // compound statement Y
        }
    }
}

内容的提问来源于stack exchange，提问作者a_floating_point