เพิ่มปัญหาการลบตัววนซ้ำ multi_index แบบย้อนกลับ

ฉันมีรหัส (ตัวย่อ) ต่อไปนี้:

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
namespace bmi = boost::multi_index;

#include <string>
#include <iostream>
#include <cassert>

using Container = boost::multi_index_container<
    std::string,
    bmi::indexed_by< bmi::ordered_non_unique< bmi::identity<std::string> > >
>;

/// Get the base of a non-reverse iterator. It's the iterator itself.
inline
Container::iterator const&
iter_base(Container::iterator const& it)
{
    return it;
}

/** Get a non-reverse iterator that points at the same element as the given reverse_iterator.
 *
 * @param rit reverse_iterator
 * @return a (non-reverse) iterator that points to the same element.
 * @pre @p rit is dereferenceable (not equal to @c rend() of whatever container @p rit came from)
 */
inline
Container::iterator
iter_base(Container::reverse_iterator const& rit)
{
    auto bit = rit.base();
    // if 'rit' is a reverse iterator: &*(rit.base() - 1) == &*rit
    return --bit;
}

template <typename IT>
void evict(Container& c, IT rb, IT fin)
{
    std::vector<std::string> result;
    for (; rb != fin; ) {
        if (rb->size() == 3) {
            auto victim = rb;
            ++rb;
            std::cout << "victim->" << *victim << ", next->" << (rb==fin ? std::string{"THE END"} : *rb) << "\n";
            auto next = c.erase(iter_base(victim));
            std::cout << "size=" << c.size() << "\n";
            for (auto const& s : c) {
                std::cout << "remain: " << s << "\n"; // bar - baz - foo
            }

            rb = IT(next);
            (void)next;
        }
        else {
            result.push_back(*rb);
        }
    }
}

int main(int argc, char**)
{
    bool forward = (argc == 1);

    Container c;
    c.insert("foo"); // will be last
    c.insert("bar");
    c.insert("baz");

    if (forward) {
        auto b = c.lower_bound("baz");

        std::cout << ">> " << *b << "\n"; // prints baz

        auto rb = (b);
        std::cout << "<< " << *rb            << "\n"; // prints baz
        std::cout << "<< " << *iter_base(rb) << "\n"; // prints baz

        evict(c, rb, c.end());
    }
    else {
        auto b = c.upper_bound("baz");

        std::cout << ">> " << *b << "\n"; // prints foo

        auto rb = Container::reverse_iterator(b);
        std::cout << "<< " << *rb            << "\n"; // prints baz
        std::cout << "<< " << *iter_base(rb) << "\n"; // prints baz

        evict(c, rb, c.rend());
    }
}

โค้ดจริงไม่เพียงแต่ลบข้อมูลเท่านั้น แต่ยังเพียงพอที่จะแสดงให้เห็นพฤติกรรมดังกล่าวอีกด้วย

แก้ไขเพื่อแสดงว่าไม่มีการลบเกิดขึ้นในลูป ควรเพิ่มรายการใน result ตามลำดับไปข้างหน้าหรือย้อนกลับ ขึ้นอยู่กับประเภทของตัววนซ้ำที่ใช้

เมื่อทำงานโดยไม่มีข้อโต้แย้ง forward==true และผลลัพธ์เป็นไปตามที่คาดไว้:

>> baz
<< baz
<< baz
victim->baz, next->foo
size=2
remain: bar
remain: foo
victim->foo, next->THE END
size=1
remain: bar

เมื่อรันด้วยอาร์กิวเมนต์ forward==false และผลลัพธ์คือ:

>> foo
<< baz
<< baz
victim->baz, next->bar
size=2
remain: bar
remain: foo
segmentation fault (core dumped)

(ไม่เป็นไปตามที่คาดไว้)

การคอมไพล์ด้วย address sanitizer จะแสดง heap-use-after-free ในบรรทัดที่ 42 (บรรทัด ++rb)

ดูเหมือนว่าการโทร erase(victim) ทำให้ rb ไม่ถูกต้อง แม้ว่าการลบจะไม่ทำให้ตัววนซ้ำอื่น ๆ เป็นโมฆะก็ตาม

มีความคิดอะไรบ้างที่ฉันทำอะไรผิด?