Discussion :

[vandamme]

Hello !

Je ne comprends pas pourquoi dans le code ci-dessous, l'expression lambda n'est evaluee qu'une seule fois :

Code :

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

1
2
3
4
5
6
 
  vector<int*> v(2);
  v[0] = 0;
  v[1] = 0;
 
  for_each(v.begin(), v.end(), _1 = new int);

Si par contre, je travaille avec des int au lieu de int*, l'expression suivante est bien evaluee pour chaque element du vecteur (2 fois ici donc) :

Code :

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

1
2
3
 
  vector<int> v(2);
  for_each(v.begin(), v.end(), _1 = _1+1);

Si qqun avait une explication .....

[Arzar]

C'est possible avec boost.phoenix (une généralisation de boost.lambda)

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
 
#include "boost/spirit/include/phoenix.hpp"
#include <algorithm>
#include <vector>
 
using namespace boost::phoenix;
using namespace boost::phoenix::arg_names;
 
int main()
{
  vector<int*> v(2, NULL); 
  int i = 0; 
 
// c'est bien new_ et pas new
  std::for_each(v.begin(), v.end(), arg1 = new_<int>(ref(i)++));   
 
  printf("%d %d\n", *v[0],*v[1]);
}

Mais à vrai dire, je n'ai pas d'explication, car je ne comprends absolument rien au fonctionnement interne de lambda ou phoenix.

[Alp]

C'est juste qu'en C++, la stratégie d'évaluation des arguments est stricte. Si on veut appliquer une lambda-expr à chaque élément d'un vecteur, il faut que d'une façon ou d'une autre on retarde le new, qui est le seul élément perturbateur ici. C'est pour ça qu'il y a un new_. Car sinon on fait un new int, et on va assigner ce même int* aux deux éléments du vecteur. Tu vois la différence ?

[Arzar]

Aaaah oui, j'ai compris, merci

En fait new_() appelle le constructeur d'une fonction-objet dont l'opérateur() fait un new. C'est cet opérateur() qui sera appelé autant de fois qu'il y a d'élément dans le for_each...

[JolyLoic]

Juste pour rappeler que des vraies expressions lambda commencent à être gérées par les compilateurs courants. Jusqu'ici, je me suis refusé à utiliser boost::lambda qui, bien qu'un merveilleux tour de force technique, restent un peu de l'ordre de la bidouille à mon sens.

[Alp]

En fait new_() appelle le constructeur d'une fonction-objet dont l'opérateur() fait un new. C'est cet opérateur() qui sera appelé autant de fois qu'il y a d'élément dans le for_each...

C'est tout à fait ça !

Juste pour rappeler que des vraies expressions lambda commencent à être gérées par les compilateurs courants. Jusqu'ici, je me suis refusé à utiliser boost::lambda qui, bien qu'un merveilleux tour de force technique, restent un peu de l'ordre de la bidouille à mon sens.

Boost.Phoenix est meilleure ! Et on est en train de la réimplémenter. Mais dommage qu'ils ne fassent pas de lambdas polymorphes pour 0x.