Discussion :

[Kaluza]

Bonjour.

Je suis en train de découvrir les fonctions/expressions lambda de C++ 2011 et j'ai un peu du mal à comprendre comment cela fonctionne.

J'aimerai savoir si les fonctions lambda sont adaptées à ce genre d'utilisation :

Soit V1 et V2 deux std::vector
Je voudrais écrire une fonction qui prend en paramètre deux vecteurs + une fonction lambda et qui retourne un vecteur dont le résultat correspond à la fonction lambda qui a été passée en paramètre.

Exemple : si ma fonction lambda est un truc du style z = x * y, j'aimerai que
le vecteur V3 retourné soit égal à :
V3[0] = V1[0]*V2[0]
V3[1] = V1[1]*V2[1]
V3[2] = V1[2]*V2[2]
etc...

Si quelqu'un pouvait me donner la syntaxe d'une fonction faisant cela, ça m'aiderait énormément (ça me servirait de base pour bidouiller après)

Merci beaucoup

[cob59]

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
//std
#include <vector>
#include <iostream>
#include <iterator>
 
using namespace std;
 
template <class VectorType, typename Function>
VectorType eval(const VectorType& v1, const VectorType& v2, Function func)
{
	VectorType v;
	auto it1 = v1.begin(), it2 = v2.begin();
	auto end1 = v1.end(), end2 = v2.end();
	for (;it1!=end1 && it2!=end2; ++it1, ++it2)
	{
		v.push_back(func(*it1,*it2));
	}
	return v;
}
 
template <typename Iterable>
void display(const Iterable& v)
{
	ostream_iterator<typename Iterable::value_type> out_it (cout," ");
	copy( v.begin(), v.end(), out_it );
	cout << endl;
}
 
int main(int argc, char* argv[])
{
	vector<int> a = { 1, 2, 3, 4, 5, 6 };
	vector<int> b = { 1, 0, 1, 0, 1, 0 };
	vector<int> c;
 
	c = eval( a, b, [] (int a, int b) { return a+b; } );
	display(c);
	c = eval( a, b, [] (int a, int b) { return a*b; } );
	display(c);
 
	return 0;
}

Cet exemple-là compile/tourne sous MinGW (avec l'option -std=c++0x bien sûr).

[Kaluza]

Génial, merci beaucoup, je vais tester ça !

[Flob90]

Bonjour,

En réalité on n'écrit pas spécifiquement une fonction prenant en paramètre une lambda, mais une fonction prenant en paramètre n'importe quoi qui soit compatible avec l'utilisation que tu en fais après. Ainsi ca permet à la fonction de marcher aussi bien avec une lambda-function, un std::function (avec les bon arguments templates) ou un foncteur personnel ofrrant une bonne interface.

C'est ce que fait cob59 dans son code avec son paramètre template Function, et c'est aussi ce qui est fait dans la bibliothèque standard pour tout les algorithmes nécessitant un foncteur.

[3DArchi]

Salut,
Les lambdas s'utilisent comme tu utiliserais tout autre objet 'callable' : fonction libre, foncteur, pointeur de fonction...

Soit tu as une approche générique comme les algorithmes de la STL, soit tu utilises un std::function:

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
#include <vector>
#include <algorithm>
#include <iterator>
#include <functional>
 
template<class F>
void fonction_1(F f)
{
   std::vector<int> v1;
   std::vector<int> v2;
   std::vector<int> v3;
 
   std::transform(v1.begin(),v1.end(),v2.begin(),std::back_inserter(v3),f);
}
 
void fonction_2(std::function<int (int,int)> f)
{
   std::vector<int> v1;
   std::vector<int> v2;
   std::vector<int> v3;
 
   std::transform(v1.begin(),v1.end(),v2.begin(),std::back_inserter(v3),f);
}
 
int main()
{
   auto lambda =
      [](int i1, int i2)
   {
      return i1+i2;
   }
   ;
 
   fonction_1(lambda);
   fonction_2(lambda);
 
   return 0;
}

De plus le type d'une lambda est un détail d'implémentation du compilateur. Impossible d'écrire quelque chose comme ça void fonction_3(???a_lambda_type??? f).

[gbdivers]

Juste une petite remarque. Sauf erreur de ma part, il est conseillé maintenant d'utiliser les fonctions libres begin() et end() au lieu des fonctions membres (permet la spécialisation pour des conteneur/iterateurs personnalisés)

Code :

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

std::transform(begin(v1), end(v1), begin(v1), std::back_inserter(v3), f);

Code :

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

1
2
auto it1 = begin(v1), it2 = begin(v2);
auto end1 = end(v1), end2 = end(v2);

Ce fonctions appellent de toute façon les fonctions membres si elles existent (sans surcoût à l’exécution) ou les fonctions spécialisées si nécessaire.
cf la FAQ C++11 de Stroustrup

[Kaluza]

Bonjour et merci pour ces exemples.
Maintenant, pour être sûr de bien comprendre, comment faire si à la place de std::vector, j'utilise par exemple des int *v = new int[10] et pas d'iterateur.

Comment faire une fonction qui itère une fonction passée en paramètre si :
1) La fonction passée en paramètre est une fonction lambda
2) La fonction passée en paramètre peut être n'importe quoi (lambda, foncteur, std::function etc...)

Merci les gens

[Flob90]

Bonjour,

En réalité on n'écrit pas spécifiquement une fonction prenant en paramètre une lambda, mais une fonction prenant en paramètre n'importe quoi qui soit compatible avec l'utilisation que tu en fais après. Ainsi ca permet à la fonction de marcher aussi bien avec une lambda-function, un std::function (avec les bon arguments templates) ou un foncteur personnel ofrrant une bonne interface.

C'est ce que fait cob59 dans son code avec son paramètre template Function, et c'est aussi ce qui est fait dans la bibliothèque standard pour tout les algorithmes nécessitant un foncteur.

Donc comme tu l'as déjà fait .

Pour une fonction que accepterait juste une lambda-function je doute que ce soit possible, et je ne vois pas l'interet .

Pour ta premier question l'avantage de la bibliothèque standard c'est qu'elle introduit le concept d'itérateur, si tu utilises std::vector, tu utilises begin()/end(), si tu utilises int*, tu utilises p/p+size, un pointeur est un itérateur .