Nrthugu

I'm trying to delete every second element from std::list but I'm getting segment error (core dump) when I run erase().

#include <bits/stdc++.h>



using namespace std;



int main()

{

    list <int> num_list;

    list <int> :: iterator it;

    num_list.push_back(1);

    num_list.push_back(2);

    num_list.push_back(3);

    num_list.push_back(4);

    num_list.push_back(5);

    cout << num_list.size() << endl;

    it = num_list.begin();

    advance(it, 1);

    for(it; it != num_list.end(); advance(it, 2)) {

        num_list.erase(it);

    }

    for(it = num_list.begin(); it != num_list.end(); ++it) {

        cout << *it << " ";

    } 

    cout << endl;

    return 0;

}

Start from the second item: next(num_list.begin(), 1). The erase method returns an iterator to the next item of the removed item. So you can use just ++ operator to step 2.

int main()

{

    list<int> num_list;

    num_list.push_back(1);

    num_list.push_back(2);

    num_list.push_back(3);

    num_list.push_back(4);

    num_list.push_back(5);

    cout << num_list.size() << endl;



    for (auto it = next(num_list.begin(), 1); it != num_list.end();) {

        it = num_list.erase(it);

        if (it != num_list.end())

            ++it;

    }

    for (auto it = num_list.begin(); it != num_list.end(); ++it) {

        cout << *it << " ";

    }

    cout << endl;

    return 0;

}

For a good explanation on why your approach does not work, see Stepan Lechner's answer.

A completely different approach using std::remove_if and lambda expressions:

int main() {

    std::list<int> ints{1, 2, 3, 4, 5};



    auto position = std::remove_if(ints.begin(), ints.end(),

            [counter = 0](const auto x) mutable {

        return ++counter % 2 == 0;

    });



    ints.erase(position, ints.end());



    for(const auto x : ints) {

        std::cout << x << ' ';

    }

}

std::remove_if, paired with erase methods calls, is the algorithm for removing particular elements from a range. Here, it gets a little tricky - we want to remove every second element, so we need a predicate, which will return true only for the even positions in the list. We achieve it using a member counter initialized with lambda init capture.

EDIT: As correctly stated by MSalters in the comments, using std::list::remove_if is a superior solution to erase-remove idiom from <algorithm>. It takes advantage of internal std::list implementation, plus it's simply less awkward to type:

// *ints* being the list itself

ints.remove_if([counter = 0](const auto x) mutable {

    return ++counter % 2 == 0;

});

as opposed to the original:

auto position = std::remove_if(ints.begin(), ints.end(),

        [counter = 0](const auto x) mutable {

    return ++counter % 2 == 0;

});



ints.erase(position, ints.end());

Erasing an element of a list invalidates the respective iterator, such that it must not be used for dereferencing or advancing any more. Iterators pointing to other elements than the erased one, however, are not affected.

So you just need to remember an iterator position to be deleted and advance the original iterator before erasing the "toDelete"-position:

int main()

{

    list <int> num_list;

    num_list.push_back(1);

    num_list.push_back(2);

    num_list.push_back(3);

    num_list.push_back(4);

    num_list.push_back(5);



    size_t size = num_list.size();

    cout << size << endl;



    list <int> :: iterator it = num_list.begin();

    while(size--) {

        auto toDelete = it;

        it++;



        if (size%2==1)

            num_list.erase(toDelete);

    }



    for(it = num_list.begin(); it != num_list.end(); ++it) {

        cout << *it << " ";

    }

    cout << endl;

    return 0;

}