Demande d'explication de code std::find_if

Bonjour a tous,

Je cherchais comment utiliser la fonction std::find_if en comparant le membre d'un objet avec une valeur précise.

je suis tomber sur ce code en anglais :

Citation:

---

That's not how predicates work. You have to supply either a free function bool Comparator(const MyClass & m) { ... }, or build a function object, a class that overloads operator():

Code:

---

1 2 3 4 5 6 7 8 9

struct MyClassComp { explicit MyClassComp(int i) n(i) { } inline bool operator()(const MyClass & m) const { return m.myInt == n; } private: int n; };   std::find_if(v.begin(), v.end(), MyClassComp(5));

---

In C++0x:

Code:

---

1 2	std::find_if(v.begin(), v.end(), [](const MyClass & m) -> bool { return m.myInt == 5; });

---

This captureless lambda is in fact equivalent to a free function. Here is a capturing version that mimics the predicate object:

Code:

---

1 2 3

const int n = find_me(); std::find_if(v.begin(), v.end(), [n](const MyClass & m) -> bool { return m.myInt == n; });

---

---

J'ai compris le première exemple de code c'est ce que j'ai choisie d'utiliser. Mais le second extrait la j'arrive plus à lire le code. Quelqu'un pourrais m'indiquer quel élément du C++11 est utilisé ici ?

Cordialement.

Citation:

---

Envoyé par Kalite

J'ai compris le première exemple de code c'est ce que j'ai choisie d'utiliser. Mais le second extrait la j'arrive plus à lire le code. Quelqu'un pourrais m'indiquer quel élément du C++11 est utilisé ici ?

---

Hello,

les 3 exemples font la même chôse, les 2 et 3eme exemple utilisent des lambdas (= fonction anonyme en gros).

La syntaxe :
une liste de capture [],
puis comme une fonction classique : paramètres, type de retour et corps

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

int a; float b;   auto l1 = [](int i) -> int { return i; } // prend un int en parametre, retourne un int, ne capture rien donc ni a ni b ne sont visible dans le corp de la lambda. auto l2 = [a](int i) -> int { return i * a; } // on capture a par copie, a est donc visible dans la lambda. auto l3 = [a, &b](int i) -> int { b = 0.0f; return i * a; } // capture a par copie, b par référence   class Foo { void f() { } void bar { auto l = [this]() { f(); }; // this est toujours capturé par référence, ne prend pas de paramètre et retourne void } };   auto l4 = [=]() { }; // capture tout par copie, a, b, l1, l2 et l3 ici auto l5 = [&]() { }; // capture tout par référence auto l6 = [a, &]() { }; // capture a par copie, tout le reste par référence auto l7 = [&a, =]() { }; // capture a par référence, tout le reste par copie

---

edit : Il faut juste faire attention à la durée de vie des objets en cas de capture par ref :

Code:

---

1 2 3 4 5 6 7

std::function<void()> foo() { int a = 5; return std::function<void()>([&a]() { std::cout << a++; }); }   auto f = foo(); f(); // appel de lambda (via une std::function), mais a n’existe plus.

---

Merci pour l'explication.