C++中如何从函数返回迭代器？迭代器返回后损坏问题求助

问题场景 #

尝试实现一个过滤迭代器，遍历std::list<const char*>时仅返回首字符符合指定过滤条件的元素，但返回迭代器后出现输出异常，得到无效内存地址feeefeeefeeefeee。

原代码

class filteredIterator {
public:
    const std::list<const char *> *myWords;
    std::list<const char *>::const_iterator myIt;
    char filter;
};

filteredIterator begin(const std::list<const char *> words, char filter) {
    filteredIterator rt;
    rt.myWords = &words;
    for(rt.myIt = words.begin(); rt.myIt != words.end(); ++rt.myIt) {
        const char * word = *rt.myIt;
        if (word[0] == filter)
            break;
    }
    printf("returning: %p: %s\n", *(rt.myIt),*(rt.myIt));
    return rt;
}

void test123() {
    std::list<const char *> words;
    words.push_front("CAT");
    words.push_front("BAT");
    words.push_front("BOB");
    filteredIterator fit;
    fit = begin(words,'B');
    printf("got: %p\n", *(fit.myIt));
}

原输出

returning: 00007ff78fe6012a: BOB
got: feeefeeefeeefeee

问题核心原因 #

begin函数的列表参数是传值传递，会创建原列表的临时副本。函数执行完毕后，这个临时副本会被销毁，而filteredIterator中的myWords指向的是已销毁的临时对象，myIt是该临时列表的迭代器，此时迭代器已失效，访问其内容会触发未定义行为，输出无效地址。

正确实现范式 #

1. 修正参数传递方式

将begin函数的列表参数改为const引用，避免创建临时副本，保证迭代器指向的是原存活的列表：

filteredIterator begin(const std::list<const char*>& words, char filter)

2. 完善过滤迭代器的迭代能力

原代码仅实现了找到第一个符合条件的元素，需要补充++操作来遍历后续符合条件的元素，同时重载迭代器必需的操作符（*、!=、->等），并添加标准迭代器的类型定义，使其符合C++迭代器规范。

完整修复代码

#include <list>
#include <cstdio>
#include <iterator> // 用于迭代器类型定义

class filteredIterator {
public:
    // 标准迭代器必需的类型定义，适配标准算法
    using iterator_category = std::forward_iterator_tag;
    using value_type = const char*;
    using difference_type = std::ptrdiff_t;
    using pointer = const char**;
    using reference = const char*&;

    const std::list<const char*>* myWords;
    std::list<const char*>::const_iterator myIt;
    char filter;

    // 构造函数
    filteredIterator(const std::list<const char*>& words, char f, bool end = false)
        : myWords(&words), filter(f) {
        if (end) {
            myIt = words.end();
        } else {
            myIt = words.begin();
            skip_non_matching();
        }
    }

    // 重载++操作符，找到下一个符合条件的元素
    filteredIterator& operator++() {
        ++myIt;
        skip_non_matching();
        return *this;
    }

    // 重载*操作符，返回当前元素
    const char* operator*() const {
        return *myIt;
    }

    // 重载->操作符
    const char** operator->() const {
        return &*myIt;
    }

    // 重载!=操作符，用于循环终止条件
    bool operator!=(const filteredIterator& other) const {
        return myIt != other.myIt;
    }

private:
    // 跳过不符合过滤条件的元素
    void skip_non_matching() {
        while (myIt != myWords->end() && (*myIt)[0] != filter) {
            ++myIt;
        }
    }
};

// 封装begin函数，返回第一个符合条件的迭代器
filteredIterator begin(const std::list<const char*>& words, char filter) {
    return filteredIterator(words, filter);
}

// 封装end函数，返回列表末尾的迭代器
filteredIterator end(const std::list<const char*>& words, char filter) {
    return filteredIterator(words, filter, true);
}

void test123() {
    std::list<const char*> words;
    words.push_front("CAT");
    words.push_front("BAT");
    words.push_front("BOB");
    words.push_front("DOG");
    words.push_front("BALL");

    // 使用过滤迭代器遍历所有首字符为'B'的元素
    for (auto it = begin(words, 'B'); it != end(words, 'B'); ++it) {
        printf("Found: %s\n", *it);
    }
}

int main() {
    test123();
    return 0;
}

运行结果

Found: BALL
Found: BOB
Found: BAT

关键要点 #

• 永远避免让迭代器指向已销毁的对象，使用引用传递而非值传递来传递容器。
• 自定义迭代器需要遵循C++迭代器规范，添加必要的类型定义和操作符重载，才能像标准迭代器一样使用。
• 过滤逻辑封装在迭代器内部，对外保持迭代器的抽象，用户无需关心过滤细节，只需像使用普通迭代器一样遍历。

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