处理向量时如何为find和find_if使用正确的指针

Question

I have a structure like this:

struct client
{
    string name;
    double money;
};

I also have 2 predicates:

bool less_10(const client& a)
{
    return a.money < 10;
}

bool not_a(const client& a)
{
    return a.name.at(0) != 'A';
}

In my main function I use this to filter out the result stored in vector client_list (everyone with money < 10 (choice 1) or everyone with name not start with A (else))

if (choice_filter == 1)
    {
        vector<client>::iterator it3;
        it3 = find_if(client_list.begin(), client_list.end(), less_10);
        while (it3 != client_list.end())
        {
            **client_list.erase(it3); 
            it3 = find_if(it3 + 1, client_list.end(), less_10);
        }
        client_list.erase(it3);**
    }

    else
    {
        vector<client>::iterator it4;
        it4 = find_if(client_list.begin(), client_list.end(), not_a);

        while (it4 != client_list.end())
        {
            **client_list.erase(it4);
            it4 = find_if(it4 + 1, client_list.end(), not_a);
        }
        client_list.erase(it4);**
}

I notice that if I erase first, then find_if, i'll lost the last client. So i added 1 more line to erase, but the program crashes as iterator is now at the end, cant erase.

Is there any way to get around this? I want to keep using find_if with predicates as well as while loop like above as they are required.

Answer 1

As others have said, std::remove_if is the best solution. If you're doing this for pedagogical reasons (which I suspect is the case, given these particular predicates): you're on the right track. The only issue is that client_list.erase invalidates the iterator. But since it returns an iterator to the element immediately after the element it erased, you can use something like:

std::vector<Client>::iterator it 
    = std::find_if( client_list.begin(), client_list.end(), predicate );
while ( it != client_list.end() ) {
    it = client_list.erase( it );
    it = std::find_if( it, client_list.end(), predicate );
}

And you don't want to call erase after the loop. The iterator designates the end, where there is no element to be erased.

Answer 2

I also agree with chris, to using std::remove_if:

{
    remove_if(client_list.begin(), client_list.end(), less_10);
}

But if you want to reinvent the wheel:

{
    vector<client>::iterator it3 = client_list.begin();
    while (true)
    {
        it3 = find_if(it3, client_list.end(), less_10);
        if (it3 == client_list.end()) {
            break;
        }
        it3 = client_list.erase(it3); 
    }
}

Answer 3

The typical way to go is to use a temporary vector:

vector<client> tmp;
for (...)
{
    if(predicate(it))
        tmp.push_back(*it);
}
client_list.swap(tmp);

This is similar to what Chris suggested in a comment, although that solution would first move elements to the end of the vector and then truncate them from there. I'm not sure if that doesn't change the order on the way, just check the documentation. Depending on what you want, either could do the work though.

---

If you used a different container like list<> that did not invalidate all iterators in erase(), you could do this:

it = c.begin();
end = c.end();
while(it != end)
{
    if(predicate(*it))
    {
        c.erase(it++);
    }
    else
    {
        ++it;
    }
}

Note that if you call erase(), you invalidate that iterator still, hence the iterator is first incremented and erase() is called with the former value using the postfix increment.