Discussion :

[Kalite]

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 :

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 C++ :

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

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 C++ :

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

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 C++ :

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

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.

[Iradrille]

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 :

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
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 :

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

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.

[Kalite]

Merci pour l'explication.