Est-ce que je peux enlever des éléments de std :: list, quand j'y vais?

Le code correct est le suivant:

for (std::list<int>::iterator itr = lst.begin(); itr != lst.end(); /*nothing*/)
{
    if (*itr > 10)
        itr = lst.erase(itr);
    else
        ++itr;
}

Lorsque vous supprimez un élément de la liste, vous pouvez invalider l'itérateur (si elle pointe vers le point d'être supprimé.) Par conséquent, vous devez supprimer à l'aide de erase (qui renvoie valide d'un itérateur pointant vers l'élément suivant).

Bien meilleure idée serait d'utiliser std::remove_if:

bool greater_than_10(int x)
{
    return x > 10;
}

lst.remove_if(greater_than_10);

Si votre compilateur prend en charge les lambdasvous pouvez le mettre encore plus courte:

lst.remove_if([](int x){ return x > 10; });

(Je n'ai pas testé ce code, que mon compilateur n'est pas si nouveau; la fonction lambda est heureusement volé @John Dibling de la réponse.)

---

En fait, l'effacement de la liste invalide uniquement les itérateurs pointant vers l'élément supprimé. Méfiez-vous cependant, que d'autres conteneurs STL n'ont pas cette propriété.

---

Donc, en résumé: d'une manière générale, vous ne devez pas supprimer les éléments de la liste lors de l'itération à travers elle, parce que la suppression peut invalider l'itérateur (et le programme va probablement se bloquer). Si vous êtes cependant tout à fait sûr que les articles que vous supprimez ne sont pas les valeurs référencées par les itérateurs que vous utilisez au moment de la suppression, vous pouvez la supprimer.

Méfiez-vous que pour les autres conteneurs STL (par exemple, les vecteurs) la contrainte est encore plus stricte: la suppression du conteneur invalide pas uniquement des itérateurs pointant vers l'élément supprimé, mais peut-être d'autres itérateurs, trop! Ainsi, la suppression de ce que les récipients lors de l'itération à travers eux, c'est encore plus problématique.

Non, vous ne pouvez pas.

Mais vous pouvez (et devez) utiliser std::remove_if avec un foncteur qui dit "plus de 10", comme ceci:

#include <list>
#include <algorithm>


int main()
{
    std::list<int> lst;
    lst.push_back(1);
    lst.push_back(12);
    lst.push_back(1);
    //....
    lst.erase(std::remove_if(lst.begin(), lst.end(), std::bind2nd(std::greater<int>(), 10)), lst.end());
}

Un autre, plus générique façon de le faire est d'écrire votre propre foncteur. Ici est un foncteur is_a_match qui renvoie true si la valeur en cours de vérification est supérieur à 10. Vous pouvez redéfinir operator() de retour true pour correspondre à ce que cela signifie dans votre cas pour le "match":

#include <list>
#include <algorithm>
#include <functional>

struct is_a_match : public std::unary_function<int, bool>
{
    is_a_match(int val) : val_(val) {};
    bool operator()(int victim) const { return victim > val_; }
private:
    int val_;
};

int main()
{
    std::list<int> lst;
    lst.push_back(1);
    lst.push_back(12);
    lst.push_back(1);
    //....
    lst.erase(std::remove_if(lst.begin(), lst.end(), is_a_match(10) ));
}

Si vous avez l'avantage de C++0x conforme compilateur, vous pouvez également utiliser les lambdas, qui permet de se débarrasser de l'foncteur et à écrire de plus expressive code dans de nombreux cas,

#include <list>
#include <algorithm>

int main()
{
    std::list<int> lst;
    lst.push_back(1);
    lst.push_back(12);
    lst.push_back(1);
    //....
    lst.erase(std::remove_if(lst.begin(), lst.end(), [](int v) {return v > 10;}));
}

Voir http://www.cppreference.com/wiki/iterator/start pour une description des itérateurs.

Un couple de notes:

• Vous devriez être en utilisant la pré-opérateur d'incrémentation (++itr) au lieu de l'après-opérateur d'incrémentation (itr++)
• Invalidation dépend de la précision de la mise en œuvre de l'itérateur, associée à sa collection.