std::remove() works as expected with literal but not with dereferenced iterator

Question

While learning remove-erase idiom, as well as understanding how std::min_element() work How to use std::min_element in C++17?. I thought to try removing minimum element from the following piece of code:

#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9};

    std::vector<int>::iterator result = std::min_element(v.begin(), v.end());
    std::cout << "min element at: " << std::distance(v.begin(), result);
}

There are two minimum elements in v. I tried to remove both of them with added diagnostics

int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9};

    std::vector<int>::iterator result = std::min_element(v.begin(), v.end());

    v.erase(result); // This removes just one minimum. What if need to remove all?

    v.push_back(1); // Okay, let's add the minimum again

    std::vector<int>::iterator another_result = std::min_element(v.begin(), v.end());

    std::cout << "min element: " << *another_result  << std::endl;

    auto iter = std::remove(std::begin(v), std::end(v), *another_result);
    // If I write 1 instead of *another_result, I manage to remove all 1's. No need to use iter-1 in erase idiom then.

    std::cout << "\nWhere is my iterator pointing? It is at: " << std::distance(v.begin(), iter);

    v.erase(iter, std::end(v)); // All the minimum are gone if I use iter-1 instead of iter and use *another_result

    std::for_each(v.begin(), v.end(), [](const int& x){std::cout << x << " ";}); // Why is still "1" there?
}

link

My questions are, as highlighted in the code with the comments,

1. Why I am able to remove all the instances of minimum by providing a literal but not a de-referenced iterator? i.e. Why does the following work?

auto iter = std::remove(std::begin(v), std::end(v), 1);

However,

2. If I choose to stick with a de-reference iterator,

auto iter = std::remove(std::begin(v), std::end(v), *another_result);

Doesn't remove all the instances of minimum while sticking to remove-erase idiom.

Answer 1

It looks like you are comparing with a reference into the vector. The element you passed in then gets moved by remove and when comparing against it a second time the reference observes some other value.

This works just fine:

int by_value = *another_result;
auto iter = std::remove(std::begin(v), std::end(v), by_value);

The third parameter of the std::remove overload you're using takes a const T&, but it's "invalidating" the reference in the process of doing its operation.

If you look at the "possible implementation" on en.cppreference

template< class ForwardIt, class T >
ForwardIt remove(ForwardIt first, ForwardIt last, const T& value)
{
    first = std::find(first, last, value);
    if (first != last)
        for(ForwardIt i = first; ++i != last; )
            if (!(*i == value))
                *first++ = std::move(*i); //here it changes the value that "value" points to
                //if you are using a reference of an element inside the vector
    return first;
}

This problem is also mentioned in the "Notes" section as:

Because std::remove takes value by reference, it can have unexpected behavior if it is a reference to an element of the range [first, last).

Answer 2

If you want to remove all the minimum values in one go, you could do something a little more odd like this:

template<class T>
void remove_min( std::vector<T> &container ) {
    if ( container.empty() ) return;
    T min_val = *std::min_element( container.begin(), container.end() );
    container.erase( std::remove( container.begin(), container.end(), min_val ), container.end() );
}

Note that the min_val is a copy first (see PeterT's answer for explanation). The above can probably be modified to work with other containers.

Keep in mind that std::remove doesn't really remove anything. The return value from the function will point to after where the new last element would be, then call the container's erase method from there to remove all the elements from that point on.