supprimer des éléments avec une valeur spécifique de std::list

J'ai besoin de supprimer des éléments avec une valeur spécifique de std::list. Avec le list<int> j'ai utilisé la méthode remove ().

Maintenant, j'ai list<CMyClass> alors j'ai pensé que je devrais utiliser remove_if() mais c'est prédicat prend un seul paramater - l'élément à tester.

Comment puis-je écrire une fonction foo(const CMyClass &Bad) qui enlève de la liste de tous les éléments égaux à Mauvais?

Grâce

struct CMyClass {
    void *Ptr;
    int Var;
}

bool is_equal(const CMyClass &A, const CMyClass &B)
{
    if (A.Ptr == B.Prt and A.Var == B.Var)
        return true;
    else
        return false;
}

s'il vous plaît ajouter CMyClass exemple de définition et de critères de correspondance.
Je pense que le principal problème est que vous ne pouvez pas soumettre une autre paramètre de données que vous pouvez utiliser pour comparer. Je ne sais pas si les objets de fonction peut vous aider ici (jamais utilisé).

OriginalL'auteur jackhab | 2009-03-24

c++list stl

Votre classe doit implémenter l'opérateur == dans votre ClassName

bool operator == ( const Class& rhs );

et puis vous pouvez utiliser

list.remove( Bad )

S'il est raisonnable de votre classe d'opérateur == ( et pas seulement pour les supprimer ) - de la liste::remove est bonne pour vous la solution. Si l'opérateur == seulement pour la liste::remove qu'il est préférable d'utiliser remove_if.

Dans l'exemple suivant de la liste::remove et de la liste::remove_if est démontrée.

struct Class
{
int a_;
int b_;
Class( int a, int b ):
a_( a ),
b_( b )
{}
bool operator == (const Class &rhs)
{
return (rhs.a_ == a_ && rhs.b_ == b_);
}
void print()
{
std::cout << a_ << " " << b_ << std::endl;
}
};
bool isEqual( Class lhs, Class rhs )
{
return (rhs.a_ == lhs.a_ && rhs.b_ == lhs.b_);
}
struct IsEqual
{
IsEqual( const Class& value ):
value_( value )
{}
bool operator() (const Class &rhs)
{
return (rhs.a_ == value_.a_ && rhs.b_ == value_.b_);
}
Class value_;
};
int main()
{
std::list<Class> l;
l.push_back( Class( 1, 3 ) );
l.push_back( Class( 2, 5 ) );
l.push_back( Class( 3, 5 ) );
l.push_back( Class( 3, 8 ) );
Class bad( 2, 5 );
std::cout << "operator == " << std::endl;
l.remove( bad );
std::for_each( l.begin(), l.end(), std::mem_fun_ref( &Class::print ) );
std::cout << "binary function predicat" << std::endl;
l.push_back( Class( 2, 5 ) );
l.remove_if( std::bind2nd( std::ptr_fun(isEqual), bad ) );
std::for_each( l.begin(), l.end(), std::mem_fun_ref( &Class::print ) );
std::cout << "functor predicat" << std::endl;
l.push_back( Class( 2, 5 ) );
l.remove_if( IsEqual( bad ) );
std::for_each( l.begin(), l.end(), std::mem_fun_ref( &Class::print ) );
return 0;
}

Comment supprimer le savoir pour comparer deux CMyClass objets?
Il utilise l' ==-opérateur (que vous pouvez remplacer dans votre classe)
Voulez-vous une solution sans opérateur ==? Alors s'il vous plaît dites comment voulez-vous comparer des valeurs ou de nous donner le nom d'une fonction qui peut faire cela?
std::list::supprimer le membre de la fonction qui est privilégiée std::remove + std::list::erase.
Merci. J'ai utiliser la liste est si rare que j'oublie toujours de cela.

OriginalL'auteur Mykola Golubyev

Pour supprimer tous les éléments en fonction d'un Prédicat:

struct Pred
{
bool operator()(int i) const
{
return i == 42;
}
};
std::list<int> l = ...;
l.remove_if(Pred());

ou de supprimer tous les éléments avec la valeur 42:

std::list<int> l = ...;
l.remove(42);

ou pour une liste de CMyClass:

struct Pred
{
bool operator()(const CMyClass& item) const
{
return item.GetSomething() == 42 && item.GetSomethingElse() == 314159;
}
};
std::list<CMyClass> l = ...;
l.remove_if(Pred());

OriginalL'auteur dalle

3

Créer une classe qui prend la mauvaise valeur et la stocke dans une variable membre. Puis mettre en œuvre le
```
bool operator()(CMyClass const &currVal) { 
return (currVal is equal to this->bad);
}
```
De passer une instance de cet objet pour remove_if

OriginalL'auteur Mr Fooz
2

Vous pouvez simplement effectuer une itération sur les éléments, de les comparer et de les effacer, si la condition est satisfaite, par exemple:
```
for (std::list<string>::iterator i = mylist.begin(), e = mylist.end(); i != e; )
{
if (*i == "foobar")
i = mylist.erase(i);
else
++i;
}
```
OriginalL'auteur Patrick Glandien

Mettre en œuvre operator==(const CMyClass &).

par exemple:

#include <list>
#include <iostream>
#include <iterator>
using namespace std;
class CMyClass {
public:
CMyClass(const int d) : data(d) {}
bool operator==(const CMyClass &rhs) { return data == rhs.data; }
friend
ostream& operator<<(ostream &ost, const CMyClass &rhs) { return ost << rhs.data; }
private:
int data;
};
int main(int, char **) {
list<CMyClass> li;
CMyClass a(1);
CMyClass b(8);
li.push_back(a);
li.push_back(b);
copy(li.begin(), li.end(), ostream_iterator<CMyClass>(cout,"\n"));
li.remove(a);
copy(li.begin(), li.end(), ostream_iterator<CMyClass>(cout,"\n"));
return 0;
}

Résultat:

1
8
8

OriginalL'auteur Thomas L Holaday

using namespace std;
class Foo
{
public:
Foo(int newVal){value = newVal;}
int value;
};
class checkEqual : public binary_function<Foo, Foo, bool>
{
public:
bool operator()(const Foo &inputOne, const Foo &inputTwo) const
{   return inputOne.value == inputTwo.value;}
//implement your comparison here
};
int main(int count, char** args)
{
list<Foo> myList;
for(int x = 0; x < 10; ++x)
myList.push_back(Foo(x));
Foo bad(5);
myList.remove_if(bind2nd(checkEqual(), bad));    
return 0;
}

Ou si vous voulez surcharge == vous pouvez faire:

class Foo
{
public:
Foo(int newVal){value = newVal;}
int value;
bool operator==(const Foo &other) const
{    return this->value == other.value;}
//your comparison here
};

Et puis:

myList.remove(bad);

OriginalL'auteur drby

-1

Essayez d'utiliser la remove_if méthode

http://www.sgi.com/tech/stl/remove_if.html

Utiliser la remove_if fonction de membre à la place: sgi.com/tech/stl/List.html

OriginalL'auteur JaredPar

Vous devez vous connecter pour publier un commentaire.