accumlate avec une fonction membre 2

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour j'essai d'utiliser accumulate pour faire un somme en utilisant une fonction membre comme foncteur

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
41
42
43
44
45
46
47
48
49
50
 
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>
class Vehicule
{
public:
	virtual int GetNbRoues() =0;
   template <class T>
	 T addtest(T &a) {return a+=GetNbRoues();};
	};
 
class voiture : public Vehicule
{
public:
 
	virtual int GetNbRoues() {return 4;};
};
 
class moto : public Vehicule
{
public:
	virtual int GetNbRoues() {return 2;};
};
 
 
 
 
template<class T1, class T2>
T1 & addNay2 (T1 &a,T2 &b){return a+=b->GetNbRoues();};
 
 
int main(int argc, char* argv[])
{
	std::vector<Vehicule*> vect;
	vect.push_back( new voiture);
	vect.push_back(new voiture);
	vect.push_back(new moto);
	vect.push_back(new moto);
	vect.push_back(new voiture);
	vect.push_back(new moto);
	vect.push_back(new moto);
	vect.push_back(new voiture);
 
int nb =std::accumulate(vect.begin(),vect.end(),0.f, std::mem_fun(&Vehicule::addtest<int>));
 
 
	return 0;
}

mais accumulate n'envoye pas les paramètres dans le bon sens,
TY =func(Ty,pToto) au lieu de TY =func(pToto,Ty).
existe t'il un fonction qui inverse les parametres?

j'ai essayer de definir un mem_fun avec les parametre inversé

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
template<class _Result,
	class _Ty,
	class _Arg>
	class mem_fun1_tr
		: public std::binary_function<_Arg,_Ty *, _Result>
	{	// functor adapter (*p->*pfunc)(val), non-const *pfunc
public:
	explicit mem_fun1_tr(_Result (_Ty::*_Pm)(_Arg))
		: _Pmemfun(_Pm)
		{	// construct from pointer
		}
 
	_Result operator()(_Arg _Right,_Ty *_Pleft) const
		{	// call function with operand
		return ((_Pleft->*_Pmemfun)(_Right));
		}
 
private:
	_Result (_Ty::*_Pmemfun)(_Arg);	// the member function pointer
	};
 
 
 
template<class _Result,
	class _Ty,
	class _Arg> inline
	mem_fun1_tr<_Result, _Ty, _Arg> mem_funr(_Result (_Ty::*_Pm)(_Arg))
	{	// return a mem_fun1_t functor adapter
	return (mem_fun1_tr<_Result, _Ty, _Arg>(_Pm));
	}

ca marche mais je ne trouve pas ca propre

07/08/2007, 12h59
Mat007

Salut,

Dans boost il y a le très pratique boost.bind qui permet de fabriquer tout un tas de foncteurs très facilement.

En l'occurence ça donnerait :

Code:

int nb = std::accumulate(vect.begin(),vect.end(),0, boost::bind( &Vehicule::addtest<int>, _2, _1 ) );

En fait depuis que je connais boost.bind je n'utilise plus du tout les std::mem_fun et autres.

MAT.
07/08/2007, 14h15
yan

Citation:

Envoyé par Mat007

Salut,

Dans boost il y a le très pratique boost.bind qui permet de fabriquer tout un tas de foncteurs très facilement.

En l'occurence ça donnerait :

Code:

int nb = std::accumulate(vect.begin(),vect.end(),0, boost::bind( &Vehicule::addtest<int>, _2, _1 ) );

En fait depuis que je connais boost.bind je n'utilise plus du tout les std::mem_fun et autres.

MAT.

Malheureusement il faut utiliser boost. C'est pas que je n'aime pas, je connait pas. Au contraire çaà l'air génial.

Il n'y a rien de base dans la STL?
07/08/2007, 14h28
Matthieu Brucher
Plus simple :

Code:

std::accumulate(machin.begin(), machin.end(), vehicule)

Et tu définis qualque part
Code:

1 2 3 4 5 Vehicule operator+ (Vehicule&, const JeNeSaisQuoi& valeur) { //Faire une addition return newVehicule; }
Attention, il faut normalement retourner un nouveau véhicule à chaque fois...
Mais si tu additionnes des nombres de roues, tu t'y prends sans doute mal au niveau conceptuel, tu devrais simplement additionner des entiers représentant le nombre de roues et non pas des véhicules avec des nombres de roues.
07/08/2007, 14h41
yan
Citation:
Envoyé par Miles

Plus simple :

Code:

std::accumulate(machin.begin(), machin.end(), vehicule)

Et tu définis qualque part

Code:

1 2 3 4 5 Vehicule operator+ (Vehicule&, const JeNeSaisQuoi& valeur) { //Faire une addition return newVehicule; }

Attention, il faut normalement retourner un nouveau véhicule à chaque fois...
Mais si tu additionnes des nombres de roues, tu t'y prends sans doute mal au niveau conceptuel, tu devrais simplement additionner des entiers représentant le nombre de roues et non pas des véhicules avec des nombres de roues.
je ferai plustot le contraire

Code:

std::accumulate(machin.begin(), machin.end(), 0);

avec
Code:

1 2 3 4 int operator+ (int& valeur, const Vehicule& vec) { return valeur+vec.GetNbRoues(); }
mais j'aurai preferer faire un truc comme

Code:

std::accumulate(machin.begin(), machin.end(), 0,std::bind1st(std::plus,std::mem_fun(&Vehicule::GetNbRoues));

mais la aussi faut faire le foncteur plus
07/08/2007, 15h01
Matthieu Brucher

Effectivement, c'est mieux :)
07/08/2007, 15h25
Alp

Le foncteur plus existe déjà dans la stl, il me semble.

Il demande au type qu'on lui passe de définir un opérateur +, simplement.
07/08/2007, 15h46
Matthieu Brucher

Exact, il faut faire std::plus<T1, t2>()

Citation:

Envoyé par Alp

Le foncteur plus existe déjà dans la stl, il me semble.

int plus(int,int) ne peut recevoir int plus (int , std::men_fun(...)).
Il faut donc ré-écrire plus par un foncteur
Code:

1 2 3 4 5 template <class T1,class T2,class Tresult> class plus : public std::binary_function<T1, T2, Tresult> { Tresult operator() (T1 & a, T2 & b) {return a+b;}; }
Citation:

Envoyé par Alp

Il demande au type qu'on lui passe de définir un opérateur +, simplement.
C'est pour cela que cela ne marche pas dans mon cas

On ne peut pas définir plusieurs sorte d'opérateur +.
Par exemple si je rajouter une fonction qui me donne le nombre de litre d'essence du véhicule.

Je pourrai faire un operateur + qui m'ajoute les nombre de roue mais je pourrai pas en même temps définir un operateur + qui me conterai le somme total d'essence.
Alors que ne pas ecrire de foncteur et faire directement un truc comme
Code:

1 2 std::accumulate(machin.begin(), machin.end(), 0,std::bind1st(std::plus,std::mem_fun(&Vehicule::GetNbRoues)); std::accumulate(machin.begin(), machin.end(), 0,std::bind1st(std::plus,std::mem_fun(&Vehicule::GetNbLitreEssence));
se serait surpuissant. Mais, comme je ne trouve pô, ben soit il manque des choses, soit j'ai pas tout compris, soit je n'utilise pas les bonne fonction :lol:

Citation:

Envoyé par Miles

Exact, il faut faire std::plus<T1, t2>()

n'existe pas (sous vc2005 en tout cas)

Code:

1
2
3
4
5
6
7
8
9
template<class _Ty>
	struct plus
		: public binary_function<_Ty, _Ty, _Ty>
	{	// functor for operator+
	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
		{	// apply operator+ to operands
		return (_Left + _Right);
		}
	};

07/08/2007, 16h16
Alp

Dans ton cas il y a alors un défaut de "conception" qui ressort.
Tu peux grâce à un foncteur faire un foreach par exemple qui accumule d'une part la capacité totale des réservoirs des véhicules, d'autre part le nombre de roue total des véhicules.

accumulate, c'est pour accumuler des nombres ou des objets définissant un opérateur+ additionnant deux objets du type en question. Pas additionner les attributs de ce véhicule.

Ou alors le truc un peu louche, tu accumule tout dans un seul véhicule, qui aura comme capacité la capacité totale et comme nombre de roues le nombre total de roues.
07/08/2007, 16h37
Matthieu Brucher

Citation:

Envoyé par Mongaulois

Je pourrai faire un operateur + qui m'ajoute les nombre de roue mais je pourrai pas en même temps définir un operateur + qui me conterai le somme total d'essence.

Si tu veux faire ça, tu as clairement un problème de conception.

Citation:

Envoyé par Alp

Dans ton cas il y a alors un défaut de "conception" qui ressort.
Tu peux grâce à un foncteur faire un foreach par exemple qui accumule d'une part la capacité totale des réservoirs des véhicules, d'autre part le nombre de roue total des véhicules.

accumulate, c'est pour accumuler des nombres ou des objets définissant un opérateur+ additionnant deux objets du type en question. Pas additionner les attributs de ce véhicule.

Ou alors le truc un peu louche, tu accumule tout dans un seul véhicule, qui aura comme capacité la capacité totale et comme nombre de roues le nombre total de roues.

ok, c'est plustot utiliser le mauvais algo alle problèmeors. Pourtant il avait l'air de bien correspondre a ce que je voulais faire. Par contre je ne sais pas si c'est une bonne chose de faire un foncteur (ou fonctionnoide je sais pas le terme exacte) avec un for_each. Pour avoir ton résultat, tu te retrouve a instancier ton fonction hors du for_each pour avoir accés à ton résultat
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 template<class T> class accumulerRoue { public: explicit accumulerRoue():somme(0){}; void operator() ( T &vec){somme+=vec->GetNbRoues();}; int GetSomme(){return somme;} private : int somme; }; . . . accumulerRoue<Vehicule*> foncteur; foncteur = std::for_each(vect.begin(),vect.end(), accumulerRoue<Vehicule*>()); int nb =foncteur.GetSomme();

07/08/2007, 16h48
yan

Citation:

Envoyé par Miles

Si tu veux faire ça, tu as clairement un problème de conception.

Je veut utiliser un algorithm pour faire une somme de quelque chose qui appartient a un objet contenu dans un contenaire. Pour moi accumulat correspond a ce que je veut faire (du moins de ce que j'ai compris sur la définition de cette algo). Mais ça me gêne de devoir faire un foncteur particulier. ALors je cherche la méthode la plus propre pour m'en passer.

Je début, donc je veut bien croire que j'ai tort, mais je vois pas pourquoi :aie:
07/08/2007, 16h49
Alp

Oui et alors ?
Sa portée sera agrandie, mais je doute que ça _diminue_ les performances, et tu as alors seulement à accéder à deux attributs de ta classe.

De toute manière, accumulate est fait pour additionner des objets, comme je t'ai dit (y compris les types fondamentaux additionnables), ce qui n'est à l'évidence pas ce que tu veux faire. Tu veux en même temps additionner séparément deux attributs de ton type Vehicule.
Autre solution : deux accumulate avec deux foncteurs, un par attribut.

(ps : généralement, pour les foncteurs, on utilise des structures, pour avoir tout public par défaut --- ce qui est généralement le plus pratique pour les opérations que l'on veut effectuer dessus)
07/08/2007, 17h05
yan

Citation:

Envoyé par Alp

Oui et alors ?
Sa portée sera agrandie, mais je doute que ça _diminue_ les performances, et tu as alors seulement à accéder à deux attributs de ta classe.

De toute manière, accumulate est fait pour additionner des objets, comme je t'ai dit (y compris les types fondamentaux additionnables), ce qui n'est à l'évidence pas ce que tu veux faire. Tu veux en même temps additionner séparément deux attributs de ton type Vehicule.
Autre solution : deux accumulate avec deux foncteurs, un par attribut.

(ps : généralement, pour les foncteurs, on utilise des structures, pour avoir tout public par défaut --- ce qui est généralement le plus pratique pour les opérations que l'on veut effectuer dessus)

je suis d'accord. Je cherche à utiliser au maximum les parties déja existante de la STL, pour jouer avec les algo.

Citation:

Envoyé par Alp

accumulate est fait pour additionner des objets

je ne vois pas pourquoi ces objets ne pourrai faire partie d'un autre objet. Enfin, je vais y refléchire. Les subtilité de la philosophie de la STL ne sont toujours évidentes :cry:
07/08/2007, 17h08
Matthieu Brucher

Citation:

Envoyé par Mongaulois

je ne vois pas pourquoi ces objets ne pourrai faire partie d'un autre objet. Enfin, je vais y refléchire. Les subtilité de la philosophie de la STL ne sont toujours évidentes :cry:

Ce ne sont pas des subtilités de la philosophie STL, mais peut-être plus de l'architecture logicielle de ùanière générale.
07/08/2007, 17h10
Alp

Citation:

je suis d'accord. Je cherche à utiliser au maximum les parties déja existante de la STL, pour jouer avec les algo.

C'est très bien, car ça va t'aider à comprendre quand les utiliser, ...

Citation:

je ne vois pas pourquoi ces objets ne pourrai faire partie d'un autre objet. Enfin, je vais y refléchire. Les subtilité de la philosophie de la STL ne sont toujours évidentes

Ils peuvent, mais ce qui est illogique, c'est que tu veux parallèlement additionner deux objets(des int, ici).

Ils n'ont rien à voir, pourquoi vouloir les accumuler en même temps.

C'est comme si tu utilisais std::map<int, T> au lieu de std::vector<T>, plus ou moins.
07/08/2007, 17h21
yan

Citation:

Envoyé par Alp

Ils peuvent, mais ce qui est illogique, c'est que tu veux parallèlement additionner deux objets(des int, ici).

Ils n'ont rien à voir, pourquoi vouloir les accumuler en même temps.

Le but est de voir se que l'on peut faire avec les fonctionnals, pour voir jusqu'ou je peut allez sans faire de foncteur. La deusième addition sert juste a argumenté ma question. Biensur que c'est bête de faire c'est addition dans deux algo different; Mais ce n'etait pas la question
08/08/2007, 09h50
yan
J'ai reflechis, et je ne voit pas en quoi ma conception est mauvaise.
un for_each, sert à appliquer un traitement sur des données.
accumulate a faire une accumulation de quelque chose (ce que je fait j'accumule l'information nbroue)
Par exemple.
imaginon une class volume3d contenant une class boudingBox . La class bouding box a un operateur + qui donne une bouding box qui englobe les deux.

Maintenant j'ai une liste de volume (cube,sphère,cone...)
j'aimerai avoir la boudingbox d'une partie. Je pense que accumulate correspond a ce problème et j'ecrirai :
Code:

1 2 3 4 5 6 7 struct accumulerBoudingBox { boudingbox operator () (boudingbox & bcurrent,volume *vol) { return bcurrent + vol->GetBoudingBox(); } }
et
Code:

1 2 boudingbox bbenglobe; bbenglobe = accumulate(l.begin()+3, l.begin()+20,boudingbox(),ptr_fun( &accumulerBoudingBox));

Voir 40 message(s) de cette discussion en une page