Discussion :

[Biozic]

Bonjour,

Je me suis décidé à tester Boost.Lambda dans une partie de mon ancien code, pour remplacer des boucles for par des std::for_each. Bien que je ne sois pas totalement convaincu de l'utilité de tout ça (du moins en C++), j'ai voulu essayer.

Je n'arrive pas à faire exécuter une méthode d'un objet local en passant comme argument différentes valeurs issues d'un vecteur. Je suis pas sûr de me faire comprendre, donc je mets mon code d'essai (qui ne fait pas grand chose d'utile pour l'instant... )

Generator.h

Code :

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
51
52
53
54
55
56
57
58
59
#ifndef GENERATOR_H_
#define GENERATOR_H_
 
#include <functional>
#include <vector>
#include <algorithm>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
 
template <typename Type>
class Functor
	: public std::unary_function<Type, Type>
{
public:
	Functor(const Type& value) : m_value(value) {}
	Type operator()(const Type& arg) const { return arg * m_value; } // pour l'exemple
 
private:
	Type m_value;
};
 
template <typename Type>
inline
Functor<Type> CreateFunctor(const Type& arg)
{
	return Functor<Type>(arg);
}
 
//------------------------------------------------------------------------------
 
template <typename Type>
class Generator
	: public std::unary_function<Type, Type>
{
public:
	typedef std::vector<Functor<Type> > FunctorList;
 
	void addFunctor(const Functor<Type>& functor)
	{
		m_functors.push_back(functor);
	}
 
	Type operator()(const Type& arg) const
	{
		using namespace boost::lambda;
 
		Type result = Type();
		std::for_each(m_functors.begin(),
		              m_functors.end(),
		              result += bind(_1, arg)
		              );
		return result;
	}
 
private:
	FunctorList m_functors;
};
 
#endif /*GENERATOR_H_*/

main.cpp

Code :

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
#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/assign.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
 
#include "Generator.h"
 
using namespace std;
using namespace boost::assign;
using namespace boost::lambda;
 
typedef std::vector<double> ValueList;
 
int main()
{
	ValueList list;
	list += 2.0, 3.14, 10;
 
	Generator<double> gen;
	std::for_each(list.begin(),
	              list.end(),
	              // comment faire: "gen.addFunctor(CreateFunctor(_1))" ?
	              );
 
	cout << gen(10.0) << endl;
 
	return 0;
}

Je n'arrive pas à trouver le code pour la ligne commentée dans main()...

Merci d'avance
Nicolas

[Mat007]

Salut,

Sans essayer de compiler je dirais quelque chose comme :

Code :

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

std::for_each(list.begin(), list.end(), bind( &Generator<double>::addFunctor, boost::ref(gen), bind( &CreateFunctor<double>, _1)));

MAT.

[Biozic]

OK, je vois l'idée des bind imbriqués. Je vais essayer ça.
Merci beaucoup
Nicolas

[Biozic]

Ça marche nickel! Merci.

[corrector]

Sans essayer de compiler je dirais quelque chose comme :

Code :

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

std::for_each(list.begin(), list.end(), bind( &Generator<double>::addFunctor, boost::ref(gen), bind( &CreateFunctor<double>, _1)));

Muf. Est-ce que vous trouvez ça élégant? Avez-vous envie d'écrire des choses comme ça?

(Je pose vraiment la question, sans condamner un style particulier.)

[Mat007]

Muf. Est-ce que vous trouvez ça élégant? Avez-vous envie d'écrire des choses comme ça?

Le double bind imbriqué c'est un peu too much, mais personnellement je ne fais plus que des boucles for pour les std::map, pour tout le reste je fais des :

Code :

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

std::for_each( container, boost::bind( &Element::DoIt, _1, param ) );

(en utilisant donc une version personnalisée de for_each)
Plutôt que par exemple des :

Code :

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

1
2
for( CIT_Container it = container.begin(); it != container.end(); ++it )
  (*it)->DoIt( param );

Mais bon j'ai fait des boucles manuelles pendant très longtemps en prétextant que les for_each étaient illisibles, donc je comprends tout à fait...

Cela dit par ailleurs boost::bind a de multiples autres utilités en dehors des boucles, notamment pour tout ce qui est enregistrement de fonctions réflexes.

MAT.

[corrector]

fonctions réflexes.

Muf?

[Mat007]

Callbacks.

MAT.

[JolyLoic]

Muf. Est-ce que vous trouvez ça élégant? Avez-vous envie d'écrire des choses comme ça?

Même si j'ai lu les avantages d'une telle écriture, je trouve que la perte de lisibilité est bien trop importante pour que je l'utilise.

Je pense que je ne laisserai tomber ma bonne vieille boucle for que quand untruc comme http://www.open-std.org/jtc1/sc22/wg...007/n2394.html sera implémenté dans mon compilateur.

[HanLee]

Pareil, boost.lambda pour des types primitifs c'est bien, sinon c'est inutilisable (en partie parce que l'opérateur . n'est pas surchargeable), car trop illisible.

Sauf que moi j'attends pas les range based for-loop, ça m'énerve trop de déclarer explicitement le type des itérateurs, j'utilise les foreach fournis par boost et Qt.

Sinon, les foncteurs anonymes ce sera pas mal. Après, je sais pas si ce sera assez concis pour utiliser accumulate (~fold_left).