Безопасно ли проходить контейнер во время выполнения std::remove_if?

Я добавил некоторые выводы:

#include <algorithm>
#include <iostream>
#include <vector>
#include <mutex>

int main() {
    std::vector<int> vec = {1, 2, 6, 3, 6, 2, 7, 4, 4, 5, 6};

    auto to_remove = std::remove_if (vec.begin(), vec.end(), [&vec](int n) {

        std::cout << "number " << n << ": ";
        for (auto i : vec) std::cout << i << ' ';
        auto c = std::count(vec.begin(), vec.end(), n);
        std::cout << ", count: " << c << std::endl;
        return c == 1;
    });

    vec.erase(to_remove, vec.end());

    for (int i : vec) std::cout << i << ' ';
}

и получил

number 1: 1 2 6 3 6 2 7 4 4 5 6 , count: 1
number 2: 1 2 6 3 6 2 7 4 4 5 6 , count: 2
number 6: 2 2 6 3 6 2 7 4 4 5 6 , count: 3
number 3: 2 6 6 3 6 2 7 4 4 5 6 , count: 1
number 6: 2 6 6 3 6 2 7 4 4 5 6 , count: 4
number 2: 2 6 6 3 6 2 7 4 4 5 6 , count: 2
number 7: 2 6 6 2 6 2 7 4 4 5 6 , count: 1
number 4: 2 6 6 2 6 2 7 4 4 5 6 , count: 2
number 4: 2 6 6 2 4 2 7 4 4 5 6 , count: 3
number 5: 2 6 6 2 4 4 7 4 4 5 6 , count: 1
number 6: 2 6 6 2 4 4 7 4 4 5 6 , count: 3
2 6 6 2 4 4 6 

Как видите, подсчеты могут быть ошибочными. Я не могу создать пример для вашего особого случая, но, как правило, вам приходится беспокоиться о неправильных результатах.

Сначала число 4 считается дважды, а на следующем шаге число 4 считается трижды. Подсчеты неверны, и на них нельзя полагаться.

После того, как предикат вернет true в первый раз, в диапазоне будет одно неопределенное значение. Это означает, что любые последующие вызовы предиката будут учитывать неопределенное значение. Таким образом, подсчет потенциально неверен, и вы можете либо оставить нетронутыми значения, которые вы собираетесь отбросить, либо отбросить значения, которые должны быть сохранены.

Вы можете изменить предикат, чтобы он подсчитывал, сколько раз он возвращал значение true, и соответствующим образом уменьшать диапазон. Например;

std::size_t count = 0;
auto to_remove = std::remove_if (vec.begin(), vec.end(), [&vec, &count](int n)
{
    bool once = (std::count(vec.begin(), vec.end() - count, n) == 1);
    if (once) ++count;
    return once;
 });

Вычитание целочисленного значения из конечного итератора вектора безопасно, но это не обязательно верно для других контейнеров.

Вы неправильно поняли, как работает std::remove_if. Значения, подлежащие удалению, не обязательно сдвигаются в конец. Видеть:

Removing is done by shifting (by means of move assignment) the elements in the range in such a way that the elements that are not to be removed appear in the beginning of the range. cppreference

Это единственная гарантия состояния полигона. Насколько мне известно, не запрещено сдвигать все значения, и это все равно удовлетворит сложность. Поэтому возможно, что некоторые компиляторы сдвигают нежелательные значения в конец, но это будет просто дополнительная ненужная работа.

Пример возможной реализации удаления нечетных чисел из 1 2 3 4 8 5:

   v               - read position
   1 2 3 4 8 5     - X will denotes shifted from value = unspecified
   ^               - write position
     v          
   1 2 3 4 8 5     1 is odd, ++read
   ^
       v
   2 X 3 4 8 5     2 is even, *write=move(*read), ++both
     ^   
         v
   2 X 3 4 8 5     3 is odd, ++read
     ^
           v
   2 4 3 X 8 5     4 is even, *write=move(*read), ++both
       ^
             v
   2 4 8 X X 5     8 is even, *write=move(*read), ++both
         ^

   2 4 8 X X 5     5 is odd, ++read
         ^         - this points to the new end.

Так что, как правило, вы не можете полагаться на то, что count возвращает какие-либо значимые значения. Так как в случае, когда move==copy (как для ints), результирующий массив равен 2 4 8|4 8 5. Который имеет неправильный счет как для нечетных, так и для четных чисел. В случае std::unique_ptrX==nullptr и, следовательно, подсчет nullptr и удаленных значений может быть неправильным. Остальные оставшиеся значения нельзя оставлять в конце массива, так как не делалось копий.

Обратите внимание, что значения не являются неопределенными, поскольку вы не можете их знать. Это в точности результаты операций перемещения, которые могут оставить значение в неопределенном состоянии. Если бы он указывал состояние перемещенных переменных (как это делаетstd::unique_ptr), то они были бы известны. Например. если move==swap, то будет переставлен только диапазон.