Блог

У меня есть следующий (упрощенный) код:

 #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 constamp;
iter_base(Container::iterator constamp; 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 constamp; rit)
{
    auto bit = rit.base();
    // if 'rit' is a reverse iterator: amp;*(rit.base() - 1) == amp;*rit
    return --bit;
}

template <typename IT>
void evict(Containeramp; c, IT rb, IT fin)
{
    std::vector<std::string> resu<
    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 constamp; 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 в строке 42 (строка rb) отображается значение heap-use-after-free.

Кажется, что вызов erase(victim) rb каким-то образом стал недействительным, хотя стирание не должно приводить к аннулированию любого другого итератора.

Есть идеи, что я делаю не так?

Второй ответ, с дополнительным запросом от OP, чтобы обход выполнялся в прямом или обратном порядке в зависимости от характера итератора. С небольшой осторожностью это можно сделать следующим образом:

 template <typename IT>
void evict(Containeramp; c, IT rb, IT fin)
{
    std::vector<std::string> resu<
    if(rb != fin) for(;;) {
        IT next = rb;
          next;
        bool finished  = (next == fin);
        if (rb->size() == 3) {
            c.erase(iter_base(rb));
            std::cout << "size=" << c.size() << "n";
            for (auto constamp; s : c) {
                std::cout << "remain: " << s << "n"; // bar - baz - foo
            }
        }
        else {
            result.push_back(*rb);
        }
        if(finished) break;
        rb = next;
    }
}
 

 template <typename IT>
void evict(Containeramp; c, IT rb, IT fin)
{
    std::vector<std::string> resu<
    if(rb != fin) for(;;) {
        bool finished  = (std::next(rb) == fin);
        if (rb->size() == 3) {
            rb = IT{c.erase(iter_base(rb))};
            std::cout << "size=" << c.size() << "n";
            for (auto constamp; s : c) {
                std::cout << "remain: " << s << "n"; // bar - baz - foo
            }

        }
        else {
            result.push_back(*rb);
        }
        if(finished) break;
    }
}