stl algorithmes

Le
gpg
Bonsoir
j'ai un vecteur de pointeurs d'objets :
vector <object*> list_vector;


class object
{
public:
object();
~object();
Fonction_qui_retourne_data_type();


private:
type_data data_type;
}

j'aimerai supprimer du vecteur list_vector tout les objects dont
data_type = type donné en argument, j'au du mal a comprendre la fonction
binder2nd, ou plutot comment ecrir le Predicate

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
binder2nd(remove_element,data_type)),
list_vector.end()));

remove_element(object* object,type_data p_data ); /* Fonction predicat
de l'object contenant list_vector*/


ce code ne compilera pas, quelqu'un peut m'aider svp ? (je n'ai pas un
exemple complet, j'espere que mon idée est coherente).
merci.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
gpg
Le #306536
Bonsoir
j'ai un vecteur de pointeurs d'objets :
vector <object*> list_vector;


class object
{
public:
object();
~object();
Fonction_qui_retourne_data_type();


private:
type_data data_type;
}

j'aimerai supprimer du vecteur list_vector tout les objects dont
data_type = type donné en argument, j'au du mal a comprendre la fonction
binder2nd, ou plutot comment ecrir le Predicate

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
binder2nd(remove_element,data_type)),
list_vector.end()));

remove_element(object* object,type_data p_data ); /* Fonction predicat
de l'object contenant list_vector*/


ce code ne compilera pas, quelqu'un peut m'aider svp ? (je n'ai pas un
exemple complet, j'espere que mon idée est coherente).
merci.


Je ne sais pas si j'etais coherent ou non, je voulais juste savoir
comment supprimer un element d'un conteneur avec une condition :
"di begin a end supprimer les elements dont la condition X est verifiee".
Quelqu'un aurait une idee ?
merci d'avance.


--
gpg

Etienne Rousee
Le #307297
"gpg"
Bonsoir
j'ai un vecteur de pointeurs d'objets :
vector <object*> list_vector;


class object
{
public:
object();
~object();
Fonction_qui_retourne_data_type();


private:
type_data data_type;
}

j'aimerai supprimer du vecteur list_vector tout les objects dont
data_type = type donné en argument, j'au du mal a comprendre la fonction
binder2nd, ou plutot comment ecrir le Predicate

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
binder2nd(remove_element,data_type)),
list_vector.end()));

remove_element(object* object,type_data p_data ); /* Fonction predicat
de l'object contenant list_vector*/


Ceci devrait fonctionner, mais suppose p_data global,
pas gênant si c'est une constante:

type_data p_data;

// initialisation de p_data

bool Elimine(Object &o) // suppose surcharge de == pour Object
{
return o.Fonction_qui_retourne_data_type() == p_data;
}

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
Elimine),
list_vector.end());

--

Etienne

Mathias Gaunard
Le #307296

j'aimerai supprimer du vecteur list_vector tout les objects dont
data_type = type donné en argument, j'au du mal a comprendre la fonction
binder2nd, ou plutot comment ecrir le Predicate


binder2nd etc. c'est juste fait pour t'aider à générer des foncteurs
facilement. Mais tu peux très bien les écrire toi-même si tu as du mal à
utiliser ces fonctions.
D'ailleurs, elles sont pas terribles. bind de TR1 est bien mieux.

James Kanze
Le #307295
On May 10, 11:17 pm, gpg
j'ai un vecteur de pointeurs d'objets :
vector <object*> list_vector;

class object
{
public:
object();
~object();
Fonction_qui_retourne_data_type();

private:
type_data data_type;
}

j'aimerai supprimer du vecteur list_vector tout les objects dont
data_type = type donné en argument, j'au du mal a comprendre la fonct ion
binder2nd, ou plutot comment ecrir le Predicate

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
binder2nd(remove_element,data_type)),
list_vector.end()));

remove_element(object* object,type_data p_data ); /* Fonction predicat
de l'object contenant list_vector*/


Deux points importants :

-- std::binder2nd est un template de classe. C-à'd qu'il faut
bien préciser les types d'instantation lorsqu'on s'en sert.
La plupart du temps, on se sert plutôt de la fonction
std::bind2nd, qui renvoie une instance de la classe ; lors
de l'appel de la fonction, il y a déduction automatique des
types, ce qui évite qu'on ait à les spécifier explicitement.

-- std::binder2nd a besoin de savoir les types concernés. Pour
ceci, il s'attend à ce qu'ils soient définis comme membre.
Du coup, pas question de lui passer un pointeur à une
fonction (qui n'a pas de membre). Ou bien, tu convertis la
fonction en objet fonctionnel (qui héritera de
std::binary_function, pour en avoir les typedef), ou bien,
tu utilise std::ptr_fun.

Ce qui donnerait quelque chose du genre :

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),

bind2nd(ptr_fun(remove_element),data_type)),
list_vector.end()));

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

James Kanze
Le #307294
On May 14, 12:16 am, "Etienne Rousee"
"gpg"
j'ai un vecteur de pointeurs d'objets :
vector <object*> list_vector;

class object
{
public:
object();
~object();
Fonction_qui_retourne_data_type();
private:
type_data data_type;
}

j'aimerai supprimer du vecteur list_vector tout les objects dont
data_type = type donné en argument, j'au du mal a comprendre la fon ction
binder2nd, ou plutot comment ecrir le Predicate

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
binder2nd(remove_element,data_type)),
list_vector.end()));

remove_element(object* object,type_data p_data ); /* Fonction predicat
de l'object contenant list_vector*/


Ceci devrait fonctionner, mais suppose p_data global,
pas gênant si c'est une constante:

type_data p_data;

// initialisation de p_data

bool Elimine(Object &o) // suppose surcharge de == pour Object
{
return o.Fonction_qui_retourne_data_type() == p_data;
}

list_vector.erase(remove_if(list_vector.begin(),
list_vector.end(),
Elimine),
list_vector.end());


L'utilisation du global, c'est extrèmement laide, et ne manquera
pas de poser de problèmes par la suite. En revanche, si la
valeur en question est effectivement une constante à chaque
appel, rien n'empêche l'utilisation d'un template de fonction :

template< type_data type >
bool
elimine( Object* pObj )
{
return pObj->getType() == type ;
}

list_vector.erase( remove_if( list_vector.begin(),
list_vector.end(),
elimine< data_type > ),
list_vector.end() ) ;

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


Publicité
Poster une réponse
Anonyme