Повысить multi_index обратный итератор стереть проблему

Question

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

#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)

(не так, как ожидалось)

Компиляция с адресом sanitizer показывает строку "куча использования после освобождения" в строке 42 (строка ++rb).

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

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

Answer 1

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

template <typename IT>
void evict(Container& c, IT rb, IT fin)
{
    std::vector<std::string> result;
    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 const& s : c) {
                std::cout << "remain: " << s << "\n"; // bar - baz - foo
            }
        }
        else {
            result.push_back(*rb);
        }
        if(finished) break;
        rb = next;
    }
}

Мой плохой, пронизанный код все еще работал в UB. Пожалуйста, попробуйте это:

template <typename IT>
void evict(Container& c, IT rb, IT fin)
{
    std::vector<std::string> result;
    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 const& s : c) {
                std::cout << "remain: " << s << "\n"; // bar - baz - foo
            }

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

Answer 2

Хорошо, работа с обратными итераторами - это боль в шее. Давайте проанализируем указатель бизнес во время выполнения этой части кода evict:

auto victim = rb;
++rb;
auto next = c.erase(iter_base(victim));

когда внутри звонка evict(c, Container::reverse_iterator(c.upper_bound("baz")), c.rend()), Под "указывает на" я подразумеваю "внутренний итератор указывает на". Шаг за шагом мы имеем:

1. Перед вводом кода: rb указывает на "foo", victim еще не существует

   auto victim = rb;

2. rb указывает на "foo", victim указывает на "foo",

   ++rb;

3. rb указывает на "baz", victim указывает на "foo",

   auto next = c.erase(iter_base(victim));

4. "baz" стирается, rb указывает на удаленное "baz", victim указывает на "foo", Любая дальнейшая операция разыменования, сравнения или (де / в) обработки с rb является неопределенным поведением.

Я понимаю, что вы пытаетесь написать evict функция, которая работает как с итераторами, так и с обратными итераторами. Один из возможных способов сделать это заключается в следующем:

template<typename Container>
std::pair<typename Container::iterator,typename Container::iterator>
direct_range(
  typename Container::iterator first,
  typename Container::iterator last)
{
  return {first,last};
}

template<typename Container>
std::pair<typename Container::iterator,typename Container::iterator>
direct_range(
  typename Container::reverse_iterator first,
  typename Container::reverse_iterator last)
{
  return {last.base(),first.base()};
}

template <typename IT>
void evict(Container& c, IT rb, IT fin)
{
  auto p=direct_range<Container>(rb,fin);
  c.erase(p.first,p.second);

  for(auto const& s:c){
    std::cout<<"remain: "<<s<<"\n"; // bar - baz - foo
  }
}