Discussion :

[yan]

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

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[yan]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[Matthieu Brucher]

Plus simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Et tu définis qualque part

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[yan]

Plus simple :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Et tu définis qualque part

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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

avec

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int operator+ (int& valeur, const Vehicule& vec)
{
  return valeur+vec.GetNbRoues();
}

mais j'aurai preferer faire un truc comme

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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

mais la aussi faut faire le foncteur plus

[Matthieu Brucher]

Effectivement, c'est mieux

[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.

[Matthieu Brucher]

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

[yan]

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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;};
}

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[yan]

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

n'existe pas (sous vc2005 en tout cas)

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
		}
	};

[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.

[Matthieu Brucher]

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.

[yan]

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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();

[yan]

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

[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)

[yan]

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.

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

[Matthieu Brucher]

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

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.

[Alp]

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, ...

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.

[yan]

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

[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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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

et

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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