C++传递迭代器作为函数参数时程序挂起，求问题排查

我在完成C++教材习题时，尝试用双迭代器相向遍历的方法统计列表元素出现次数：两个迭代器逐步移动，遇到目标值就增加计数器，直到二者相遇。目前仅能统计列表首个值，但拓展到其他值时，传递迭代器作为函数参数会导致程序挂起；如果在findNumberOccurences函数内部初始化start迭代器为input.begin()则正常。程序无异常抛出，但陷入假死状态，终端光标持续闪烁。

原代码：

#include <functional>
#include <iostream>
#include <iterator>
#include <list>
  
int findNumberOccurences(std::list<int> input, std::list<int>::iterator& start) {
    std::cout << *start << '\n';
    std::list<int>::iterator end = input.end();
    int count = 1;
   
    while (std::distance(input.begin(), start) != std::distance(input.begin(), end)) {
        while (*end != *start) {
            --end;
        }
 
        ++count;
        ++start;

        if (std::distance(input.begin(), start) == std::distance(input.begin(), end)) {
            break;
        }
 
        while (*start != *end) {
            std::cout << *start << '\n';
            ++start;
        }
 
        ++count;
        --end; 
    } 

    return count;
} 

int main() {
    std::list<int> input = {3, 4, 4, 2, 3, 3, 4, 3, 2};
    std::list<int>::iterator start = input.begin();
    int count = findNumberOccurences(input, start);
    std::cout << count << '\n';
    return 0;
}  

1. 核心问题：迭代器与容器不匹配 #

函数里的input是值传递，会生成原列表的副本。但你传递的start迭代器是绑定到main里的原列表的，不是副本的迭代器。用这个迭代器访问副本的元素属于未定义行为，这是程序假死的直接原因。

2. 其他逻辑漏洞 #

• 直接解引用尾后迭代器end()：end()不指向任何有效元素，*end会触发未定义行为。
• std::distance对std::list是O(n)操作，频繁调用会拖慢程序，且用它判断迭代器位置的逻辑容易出错。
• 双迭代器相向遍历的逻辑仅适用于有序列表，无序列表中目标元素分散，会导致无限循环。

修复后的代码 #

方案一：可靠的单遍历实现（推荐） #

#include <iostream>
#include <list>

// 容器用引用传递，避免副本，迭代器传值即可
int findNumberOccurences(std::list<int>& input, std::list<int>::iterator start) {
    if (start == input.end()) return 0;
    int target = *start;
    int count = 0;
    // 单遍历统计所有目标元素
    for (auto it = input.begin(); it != input.end(); ++it) {
        if (*it == target) {
            ++count;
        }
    }
    return count;
}

int main() {
    std::list<int> input = {3, 4, 4, 2, 3, 3, 4, 3, 2};
    auto start = input.begin();
    int count = findNumberOccurences(input, start);
    std::cout << "元素 " << *start << " 的出现次数：" << count << '\n';

    // 测试其他元素
    auto anotherStart = std::next(input.begin(), 1); // 指向4
    int anotherCount = findNumberOccurences(input, anotherStart);
    std::cout << "元素 " << *anotherStart << " 的出现次数：" << anotherCount << '\n';
    return 0;
}

方案二：适配有序列表的双迭代器实现 #

如果你的列表是有序的，可以用双迭代器优化：

#include <iostream>
#include <list>

int findNumberOccurencesSorted(std::list<int>& input, std::list<int>::iterator start) {
    if (start == input.end()) return 0;
    int target = *start;
    int count = 0;
    auto left = start;
    auto right = input.end();
    --right; // 移动到最后一个有效元素

    while (left != right && std::next(left) != right) {
        if (*left == target) ++count;
        if (*right == target) ++count;
        ++left;
        --right;
    }
    // 处理剩余的1-2个元素
    if (left == right) {
        if (*left == target) ++count;
    } else {
        if (*left == target) ++count;
        if (*right == target) ++count;
    }
    return count;
}

int main() {
    std::list<int> sortedInput = {2,2,3,3,3,3,4,4,4};
    auto start = sortedInput.begin();
    int count = findNumberOccurencesSorted(sortedInput, start);
    std::cout << "有序列表中元素 " << *start << " 的出现次数：" << count << '\n';
    return 0;
}

关键修复说明 #

• 容器改成引用传递（std::list<int>& input），确保迭代器和容器匹配，避免未定义行为。
• 尾后迭代器必须先移动到有效元素位置才能解引用。
• 无序列表优先用单遍历实现，双迭代器仅适合有序场景，否则逻辑会出错。

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