Question

I have std::list eg. with ints: 9 10 8 25 70 75 30 14 80

I want to move all elements less than 10 after the some_position_number element eg. = 5. The initial order of moved objects is important and must be the same as initial after moving.

In other words at the end need to receive some_position_number elements that false and after them true

Like it must be for 1st example: 10 25 70 75 30 9 *8* 14 80

Second initial: 9 3 8 25 70 75 30 14 80
Second result: 10 25 70 75 30 9 *3* 8 14 80

Third initial: 25 70 75 30 14 9 3 8 80
Third result: 25 70 75 30 14 9 3 8 80 (the same already 5 at the beginning)

4 initial: 3 4 1 2 3 9 3 8 80
4 result: 9 3 8 80 3 4 1 2 3 (something like this) seems here some_position_number must be used as threshold or 80 3 4 1 2 3 9 3 8 also accepted, but seems need to check for end() and for infinity loop?

How to do this most effective way, maybe without additional list to avoid unnecessary objects creation and erasing? because at the real app there is no ints at the std::list, but objects. Maybe std::splice? Somehow select objects that need to move, than find new position and std::splice every element to it.

Answer 1

It’s ugly, but it works and I believe it properly handles all iterator invalidation situation correctly:

#include <iostream>
#include <list>

using namespace std;

list<int> l;

// prototypes for various helpers of no consequence to the question
void  init();
bool my_pred( list<int>::value_type val);
void dump_list( list<int> const& l);


typedef list<int>::iterator iter_t;

int main() 
{
    init();
    dump_list(l);

    // we want to remove elements that meet the predicate until
    // there are `some_position_number` elements that didn't meet 
    // the predicate

    int some_position_number = 5;
    list<int> tmp_list;

    iter_t i = l.begin();
    for (int count = 0; count < some_position_number && i != l.end(); ) {
        iter_t tmp(i);
        ++i;
        if (my_pred(*tmp)) {
            tmp_list.splice( tmp_list.end(), l, tmp); // remove an element
        }
        else {
            ++count;
        }
    }

    // now i points at the position we want to insert the elements we removed:

    l.splice( i, tmp_list);

    dump_list(l);
}




bool my_pred( list<int>::value_type val)
{
    return val < 10;
}

void  init()
{
    l.push_back(9);
    l.push_back(10);
    l.push_back(8);
    l.push_back(25);
    l.push_back(70);
    l.push_back(75);
    l.push_back(30);
    l.push_back(14);
    l.push_back(80);
}

void dump_list( list<int> const& l)
{
    for (list<int>::const_iterator i = l.begin(); i != l.end(); ++i) {
        cout << *i << " ";
    }

    cout << endl;
}

The keys are:

• the iterator i that’s used to walk the range of elements that might be moved has to be copied then incremented before calling splice(). When splice() is called, the original i (now tmp) is invalidated.
• we splice the elements that we want to move on to a temporary list. While this requires a second list, it still doesn’t involve a copy of the elements – we’re just moving them somewhere else to keep bookkeeping easy.
• keep a count of the elements that didn’t meet the predicate – this lets use figure out the insertion point as we move along checking for elements to move.