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