STL et prédicat

Version imprimable

15/03/2010, 07h51
moidibe

STL et prédicat
Bonjour,
j'utilise le containeur list de la STL contenant plusieurs éléments de la classe suivante :
Code:

1 2 3 4 5 6 7 8 class position { public: int l, m , n; double x; double y; double z; }
Je souhaite supprimer certains éléments de la liste que j'ai créé suivant un critère par exemple n = variable . J'essaie d'utiliser l'algorithme remove_if mais il demande un predicate. Pouvez vous m'aider à comprendre comment marche les prédicats ?
je regardais sur beaucoup de site et je n'arrive toujours pas a supprimer un élément.
Je vous remercie d'avance pour votre aide.
15/03/2010, 16h42
moidibe

Certains parlent d'utiliser bind2nd() ou bind1st(). Quel est la différence ? Comment les utilise-t-on ?
Si quelqu'un avez plus de renseignement ca serait sympa.
15/03/2010, 17h00
Invité(e)
Bonjour,

On peut voir un prédicat une fonction booléenne qui prend le type stocké dans la liste comme paramètre.

Il faut donc que tu donnes à remove_if une fonction comme :
Code:

1 2 3 4 bool mon_predicat(const position & pos) { /* on supprime si n est égal à zero. */ return (pos.n == 0); }
http://www.cplusplus.com/reference/stl/list/remove_if/

Pour les bind, voir ce tuto http://r0d.developpez.com/articles/algos-stl/#LI-D
16/03/2010, 01h51
moidibe
En fait, je cherche plutôt une fonction comme ca :
Code:

1 2 3 4 bool mon_predicat(const position & pos, int ma_variable) { /* on supprime si n est égal à zero. */ return (pos.n == ma_variable); }
J'ai cru comprendre qu'un prédicat est une fonction unaire:
predicate
Unary predicate that, taking a value of the same type as those contained in the list object, returns true for those values to be removed from the container, and false for those remaining.

Code:

endp = remove_if(list1.begin(), list1.end(),bind2nd(greater<int>(), variable));

En fait, l'utilisation bind2nd ou bind1st permet d'ajouter un paramètre supplémentaire ce qui serait assez pratique.

Citation:
En fait, je cherche plutôt une fonction comme ca :
Code:

1 2 3 4 bool mon_predicat(const position & pos, int ma_variable) { /* on supprime si n est égal à zero. */ return (pos.n == ma_variable); }
Alors, dans ce cas, il ne faut pas passer par un prédicat fonction, mais par une classe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 struct predicat{ predicat(int var) { ma_variable = var; } int ma_variable; bool operator () (const position & pos) { return (pos.n == ma_variable); } }; int main() { predicat mon_predicat(5); list<position> ma_liste; ma_liste.remove_if(mon_predicat); return 0; }
Si on tiens absolument à utiliser bind1st ou bind2nd, il faut implémenter une binary_function, mais je pense que le comportement final est à peut près équivalent.

Salut,
std::ptr_fun permet de créer un foncteur avec une fonction libre.
std::bind2nd permet de lier le second paramètre du foncteur.
Ce qui donnerait :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <list>
#include <algorithm>
#include <functional>
 
class position
{
public:
	int l, m , n;
	double x;
	double y;
	double z;
};
 
bool mon_predicat(position  pos, int ma_variable) {
    /* on supprime si n est égal à zero. */
    return (pos.n == ma_variable);
}
 
int main()
{
   std::list<position> lst_pos;
   std::remove_if(
      lst_pos.begin(),
      lst_pos.end(),
      std::bind2nd(std::ptr_fun(&mon_predicat),42)
   );
   return 0;
}

Malheureusement, ça capture mal la référence constante du premier paramètre, donc un passage par valeur est nécessaire.
Sinon, avec boost, ça se passe mieux :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <list>
#include <algorithm>
#include "boost\bind.hpp"
 
class position
{
public:
	int l, m , n;
	double x;
	double y;
	double z;
};
 
bool mon_predicat(position const& pos, int ma_variable) {
    /* on supprime si n est égal à zero. */
    return (pos.n == ma_variable);
}
 
int main()
{
   std::list<position> lst_pos;
   std::remove_if(
      lst_pos.begin(),
      lst_pos.end(),
      boost::bind(mon_predicat,_1,42)
   );
   return 0;
}

Sinon, il reste effectivement la possibilité proposée par Mabu de passer par une structure dédiée :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <list>
#include <algorithm>
 
class position
{
public:
	int l, m , n;
	double x;
	double y;
	double z;
};
struct mon_predicat
{
   int ma_variable;
   mon_predicat(int var_):ma_variable(var_){}
   bool operator()(position const& pos) {
       /* on supprime si n est égal à zero. */
       return (pos.n == ma_variable);
   }
};
 
int main()
{
   std::list<position> lst_pos;
   std::remove_if(
      lst_pos.begin(),
      lst_pos.end(),
      mon_predicat(42)
   );
   return 0;
}

P.S. C++0x devrais même te faciliter la vie avec les lambdas (non testé mais ça devrait y ressembler peu ou prou) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <list>
#include <algorithm>
 
class position
{
public:
	int l, m , n;
	double x;
	double y;
	double z;
};
 
int main()
{
   std::list<position> lst_pos;
   std::remove_if(
      lst_pos.begin(),
      lst_pos.end(),
      [](position const& pos){return (pos.n == 42);}
   );
 
   return 0;
}

Citation:

Envoyé par 3DArchi

Malheureusement, ça capture mal la référence constante du premier paramètre, donc un passage par valeur est nécessaire.

Je me permet un petit HS :oops:
J'ai un peu "complété" la STL pour contourner ce problème endémique (pour les méthodes de classe)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
		// TEMPLATE CLASS binder2nd
template<class _Bfn>
class binder2nd_mod: public std::unary_function<typename _Bfn::first_argument_type, typename _Bfn::result_type>
{
protected:
	_Bfn op;
	typename _Bfn::second_argument_type value;
public:
	binder2nd_mod(_Bfn _X, typename _Bfn::second_argument_type _Y)
		: op(_X), value(_Y) {}
	result_type operator()(const argument_type & _X) const
		{ return (op(_X, value)); }
};
		// TEMPLATE FUNCTION bind2nd
template<class _Bfn, class _Ty>
inline binder2nd_mod<_Bfn> bind2nd_mod(_Bfn _X, const _Ty & _Y)
	{ return (binder2nd_mod<_Bfn>(_X,_Y)); }
 
 
template<class _Result, class _Ty, class _Arg>
class const_mem_fun1_ref_mod_t: public std::binary_function<_Ty, _Arg, _Result>
{	// functor adapter (*left.*pfunc)(val), const *pfunc
private:
	_Result (_Ty::*_Pmemfun)(_Arg) const;	// the member function pointer
public:
	explicit const_mem_fun1_ref_mod_t(_Result (_Ty::*_Pm)(_Arg) const)
		: _Pmemfun(_Pm) // construct from pointer
		{}
 
	_Result operator()(const _Ty & _Left, _Arg _Right) const
		{	// call function with operand
		return ((_Left.*_Pmemfun)(_Right));
		}
};
 
template<class _Result, class _Ty, class _Arg>
inline const_mem_fun1_ref_mod_t<_Result, _Ty, _Arg> mem_fun_ref_mod(_Result (_Ty::*_Pm)(_Arg) const)
	{	// return a const_mem_fun1_ref_t functor adapter
	return (const_mem_fun1_ref_mod_t<_Result, _Ty, _Arg>(_Pm));
	}

Il ne faut ans doute pas grand chose de plus pour utilisation avec les fonctions libres.

16/03/2010, 15h48
moidibe

Je vous remercie vraiment pour votre aide. Vos solutions me semblent toutes très intéressante.
Je vais finir par éplucher ca demain matin (il se fait un peu tard ici).

Merci mille fois !
16/03/2010, 17h48
Joel F

@Archi3D, pour rester avec Boost, une boost::lambda est tout aussi simple (voir un coup de Phoenix)
16/03/2010, 19h56
koala01
Salut,

Allez, pour rajouter une dernière possibilité...

Si la valeur avec laquelle tu veux effectuer la comparaison est une valeur numérique entière(ou considérable comme telle), tu peux également envisager la création d'une fonction template:
template <int i>
Code:

1 2 3 4 bool predicat(position const & p) { return p.n==i; }
qui s'utiliserait sous la forme de
Code:

1 2 3 4 5 6 7 int main() { std::list<position> l_pos; /* ...*/ std::remove_if(l_pos.begin(), l_pos.end(),predicat<5>); return 0; }
16/03/2010, 20h04
Goten

Citation:

Envoyé par Joel F

@Archi3D, pour rester avec Boost, une boost::lambda est tout aussi simple (voir un coup de Phoenix)

Y'a-t-il encore une raison d'utiliser lambda? Je vois plus ça comme quelque chose de deprecated au profit de phoenix. (et il me semble que je suis pas le seul!)
16/03/2010, 20h06
Joel F

Phoenix est parfois lourd en temps de compilation, mais oui on pousse avec Harmut et l'aute Joel pr passer Phoenix en first class citizen.
16/03/2010, 20h07
Goten

Ah oui, lourd, c'est pas faux. (chose qui devrait être améliorer avec le passage à proto non?)
16/03/2010, 20h10
Joel F

Oui. Dans un des prototypes qu'on teste, j'en ai un qui remplacent les actor (objet) par des fonctions qui appellent make_expr. J'avais posté ici:

http://lists.boost.org/boost-users/2009/02/45591.php

une analyse des temps de compils respectifs d'objet vs fonctions.
Restera les 2.2s de preprocessing de proto:aie:
18/03/2010, 03h39
moidibe

Je vous remercie pour votre aide. Ca a parfaitement résolu mon probleme mais maintenant je dois m'attaquer aux différents bugs qu'il y a dans mon programme...
Encore une fois merci à vous.