C++11 introduit les fonctions lambda : qu'est-ce que c'est ? Comment (bien) les utiliser ? Voici le support d'une présentation donnée à l'occasion des rencontres C++ à Montpellier le 21 oct. 2014.
Le polymorphisme est souvent limité au seul contexte des hiérarchies de classes (sous-typage). Mais savez-vous qu'il en existe d'autres formes et que, historiquement, son utilisation en programmation objet est la plus récente de toutes?
Au cours de ce talk, nous tenterons de définir ce qu'est le polymorphisme pour ensuite découvrir combien ce concept est... polymorphe!
Support Dot Net avec C#. Ce cours traite les points suivants :
- Architecture .Net
- Les bases de C#
- Objet et Classe
- Héritage
- Encapsulation
- Polymorphisme
- Les exceptions
- Les entrées sorties
- Les interfaces graphiques
- Le multi Threading
- Programmation réseaux (Sockets et DataGram)
- Accès aux bases de données
cours d'initiation à la programmation modulaire sous Python en utilisant des fonctions et des procédures pour décomposer un problème en sous-problème plus facile à traiter en utilisant des fonctions et des procédures.
Le polymorphisme est souvent limité au seul contexte des hiérarchies de classes (sous-typage). Mais savez-vous qu'il en existe d'autres formes et que, historiquement, son utilisation en programmation objet est la plus récente de toutes?
Au cours de ce talk, nous tenterons de définir ce qu'est le polymorphisme pour ensuite découvrir combien ce concept est... polymorphe!
Support Dot Net avec C#. Ce cours traite les points suivants :
- Architecture .Net
- Les bases de C#
- Objet et Classe
- Héritage
- Encapsulation
- Polymorphisme
- Les exceptions
- Les entrées sorties
- Les interfaces graphiques
- Le multi Threading
- Programmation réseaux (Sockets et DataGram)
- Accès aux bases de données
cours d'initiation à la programmation modulaire sous Python en utilisant des fonctions et des procédures pour décomposer un problème en sous-problème plus facile à traiter en utilisant des fonctions et des procédures.
Développement d'applications mobiles hybrides avec IONIC 2 et Angular 2. Depuis l'installation jusqu'à l'utilisation de plugins natifs tels que stockage de données, géolocalisation, liaison serveur API Rest...
PHP unserialization vulnerabilities: What are we missing?Sam Thomas
Video at: https://www.youtube.com/watch?v=PqsudKzs79c
An introduction to PHP unserialization vulnerabilities, with some practical tips on methodology. Based around three new exploits for old vulnerabilities (CVE-2011-4962, CVE-2013-1453, CVE-2013-4338).
C'est le premier chapitre du cours en C++ de la programmation procédurale à la POO.
Partie 1: La Programmation Procédurale.
Partie 2: La Programmation Orientée Objet.
Partie 3: Les Exceptions, Entrées/Sorties, Structures, Unions, Énumérations…
Partie 4: Les interfaces Graphiques avec Qt.
C'est la version 2019 du chapitre 1 sur C++:
https://fr.slideshare.net/AzizDarouichi/chap1-cours-en-c
Si vous avez des remarques ou des suggestions afin d'améliorer ce support du cours merci de me contacter via pr.azizdarouichi@gmail.com
Bonne lecture
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Cette présentation explique quelques concepts fondamentaux de Hazelcast dans l'écosystème du Big Data, et montre comment :
- Créer un cache mémoire distribué basé sur un cluster Hazelcast
- Faire du traitement distribué avec Hazelcast
- Créer une application de messagerie asynchrone utilisant les Topic d'un cluster Hazelcast
- Autres ...
Bon apprentissage
Voici le chapitre sur les classes et les objets en C++.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Cette diapositive présente l'essentiel de langage C# pour des personnes qui'ont deja des notions en POO, dans cette présentation on traite les bases de C# comme les variables, les boucles, les classes, les exception, et aussi on traite des concepts avancés comme les delegates et les événements.
Introduction à la programmation lock-free en C++11 au moyen des atomics. Présentation données par Cyril Comparon lors des rencontres C++ de Montpellier (novembre 2014).
Les nouveautés de C++11 : Ecrire du C++ ModerneMicrosoft
Le langage C++ a toujours la réputation d’un langage complexe, demandant une rigueur de tous les instants et qui peut en rebuter plus d’un. Mais avec l’arrivée de la nouvelle norme C++11 et de son intégration dans Visual Studio 11 (et intégration partielle dans Visual Studio 2010), elle permet comme le souligne Herb Sutter, d’écrire désormais du code "Clean, Safe and Fast", nous passons à l'ère du C++ moderne.
Développement d'applications mobiles hybrides avec IONIC 2 et Angular 2. Depuis l'installation jusqu'à l'utilisation de plugins natifs tels que stockage de données, géolocalisation, liaison serveur API Rest...
PHP unserialization vulnerabilities: What are we missing?Sam Thomas
Video at: https://www.youtube.com/watch?v=PqsudKzs79c
An introduction to PHP unserialization vulnerabilities, with some practical tips on methodology. Based around three new exploits for old vulnerabilities (CVE-2011-4962, CVE-2013-1453, CVE-2013-4338).
C'est le premier chapitre du cours en C++ de la programmation procédurale à la POO.
Partie 1: La Programmation Procédurale.
Partie 2: La Programmation Orientée Objet.
Partie 3: Les Exceptions, Entrées/Sorties, Structures, Unions, Énumérations…
Partie 4: Les interfaces Graphiques avec Qt.
C'est la version 2019 du chapitre 1 sur C++:
https://fr.slideshare.net/AzizDarouichi/chap1-cours-en-c
Si vous avez des remarques ou des suggestions afin d'améliorer ce support du cours merci de me contacter via pr.azizdarouichi@gmail.com
Bonne lecture
Ce premier cours présente les notions d'objet et de classe, et le lien entre elles. Il présente aussi le premier concept clé de la programmation orientée objet, à savoir l'encapsulation des données. Les exemples sont fournis dans plusieurs langages (Python, C#, Java, C++ et PHP).
Cette présentation explique quelques concepts fondamentaux de Hazelcast dans l'écosystème du Big Data, et montre comment :
- Créer un cache mémoire distribué basé sur un cluster Hazelcast
- Faire du traitement distribué avec Hazelcast
- Créer une application de messagerie asynchrone utilisant les Topic d'un cluster Hazelcast
- Autres ...
Bon apprentissage
Voici le chapitre sur les classes et les objets en C++.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture.
Cette diapositive présente l'essentiel de langage C# pour des personnes qui'ont deja des notions en POO, dans cette présentation on traite les bases de C# comme les variables, les boucles, les classes, les exception, et aussi on traite des concepts avancés comme les delegates et les événements.
Introduction à la programmation lock-free en C++11 au moyen des atomics. Présentation données par Cyril Comparon lors des rencontres C++ de Montpellier (novembre 2014).
Les nouveautés de C++11 : Ecrire du C++ ModerneMicrosoft
Le langage C++ a toujours la réputation d’un langage complexe, demandant une rigueur de tous les instants et qui peut en rebuter plus d’un. Mais avec l’arrivée de la nouvelle norme C++11 et de son intégration dans Visual Studio 11 (et intégration partielle dans Visual Studio 2010), elle permet comme le souligne Herb Sutter, d’écrire désormais du code "Clean, Safe and Fast", nous passons à l'ère du C++ moderne.
Comparatif en C# 5, Java 8 et C++ 11.
Y sont analysés les langages et les différences structurelles.
Ce comparatif est la suite de C#4 vs Java 7 ainsi que de .NET 4 côté serveur vs JEE 6
desde la mas remota antiguedad, el ser humano ha buscado en diferentes tecnicas metodos el conocerse a si mismo, y es asi que ha dedicado tiempo y gran esfuerzo a traves de la impecabilidad para despertar la conciencia y alcanzar la libertad.
Propuesta de una interfaz interoperable para una Red Nacional Distribuida de ...Manuel Mujica
La presente es para invitarlos a las defensa de TGM que se indican a continuación:
1) Propuesta de una interfaz interoperable para una Red Nacional Distribuida de repositorios de objetos de aprendizaje
Por: Ing. Javier Albornoz
Tutor: Prof. Arsenio Pérez
Jurado Principal:
Profa. Keyla Cañizalez
Profa. Euvis Piña
Jurado Suplente:
Prof. Julio Véliz
Prof. Alvaro Muñoz
Profa. Olga Palma
Inteligencia emocional y su relación con la felicidadEuler
Comprender, cómo funciona la inteligencia Emocional es muy importante para contar con las herramientas necesarias que mejoren la calidad y satisfacción personal.
Voici la nouvelle version 2019 du chapitre sur les fonctions en C++:
https://fr.slideshare.net/AzizDarouichi/chap2fonctionscpp
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Voici le chapitre sur la surcharge des opérateurs en C++.
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Bonne lecture
la plupart des programmes informatique sont des programmes complexes. Ils comportent des dizaines de milliers de lignes et les grosses applications en comportent des millions. Si l'on garde tout dans une seule fonction, la fonction main() par exemple, il va être très difficile de s'y retrouver. Il serait certainement plus simple de découper ce programme en fonctions. Chaque fonction est destinée à effectuer une tâche précise et renvoie généralement un résultat. Découper son programme en fonctions permet de s'organiser.
En plus, si vous êtes plusieurs développeurs à travailler sur le même programme, vous pourrez vous partager plus facilement le travail : chacun s'occupe d’une fonction différente.
Et ce n'est pas tout ! Prenons par exemple le calcul de la racine carrée, que nous avons vu précédemment. Si vous créez un programme de maths, il est bien possible que vous ayez besoin, à plusieurs endroits, d'effectuer des calculs de racines. Avoir une fonction sqrt() va nous permettre de faire plusieurs de ces calculs sans avoir à recopier le même code à plusieurs endroits. On peut réutiliser plusieurs fois la même fonction et c'est une des raisons principales d'en écrire.
Voici le chapitre sur les fonctions en C++.
La nouvelle version 2019 est par là:
https://fr.slideshare.net/AzizDarouichi/chapitre2fonctionscppv2019
Si vous avez des remarques ou suggestions afin de le parfaire.
N’hésitez pas à me contacter via mon email:
pr.azizdarouichi@gmail.com.
Ce document vise à présenter la programmation fonctionnelle sous Scala.
Les points abordés sont le paradigme fonctionnel, fonction anonyme, fonction d’ordre supérieur, Clôture, fonction partielle, la récursivité, Curryfication. Chaque notion est accompagnée par des exemples.
A la fin de ce chapitre, vous serez en mesure de :
• Créer un projet java sous Intellij IDEA
• Créer des applications Java en mode console en respectant les bonnes pratiques en programmation
• Déclarer une variable en Java
• Comprendre le mécanisme d’initialisation des variables en Java
• Analyser et exécuter une instruction en Java
• Comprendre le mécanisme d’affectation en Java
• Apprendre l'affichage, la saisie des données et la lecture des différents types
• Utiliser les fonctions prédéfinis de la classe Math
• Distinguer entre l’usage des deux structures : if et switch
• Ecrire des programmes en java avec les structures de contrôle : condition et boucles
• Déclarer des variables de type tableau
Mise en oeuvre des lambdas en Java 8
Attention lire le chapitre sur les interfaces avant d'aborder la lecture de ce chapitre.
Extrait de la formation que j'anime
- Les constructeurs
- La gestion des exceptions
- Les getters et les setters
- Lecture du clavier
- Les references
- Surcharge des méthodes
- Le mot clé this
- la méthode String tostring()
Similaire à Les fonctions lambdas en C++11 et C++14 (20)
3. Lλmbdλ ?
Les lambdas sont des fonctions anonymes...
Wikipedia : « Les fonctions anonymes sont des
fonctions n'ayant pas de nom. »
En gros, c'est une fonction avec :
● un corps
● (éventuellement) des paramètres
● (éventuellement) un type de retour
mais pas de nom !
Mais alors, comment ça s'utilise ?
4. Principe
Alors qu'une fonction nommée peut être référencée avant ou après
sa définition, une expression lambda est référencée à l'endroit de
sa création.
Il n'y a pas donc pas de déclaration de symbole, seulement une
définition de bloc fonction.
● Généralement à usage unique, temporaire.
● Typiquement destinée à être passée en argument à une autre
fonction…
Lambda = callback sous stéroïde ?
5. Syntaxe générale
[] // lambda introducer : capture de variables
() // paramètre[s] de la fonction (facultatif)
{
// corps de la fonction
} (); // appel de la fonction (facultatif)
// Exemple :
auto f = [](int i) { return i + 10; };
f(1);
std::vector<int> v = { 1, 2, 3, 4 };
std::transform(cbegin(v), cend(v), begin(v), f);
std::for_each(cbegin(v), cend(v), [](int n) {
std::cout << n << ' ';
});
// affiche : 11 12 13 14
6. Closure et foncteur
Un objet fonction créé via une lambda est une fermeture lexicale
(closure) : il y a capture de paramètres.
std::vector<int> v = { 0, 5, 10, 15, 20, 25 };
auto it = std::find_if(v.cbegin(), v.cend(),
[](int i) { return i > 0 && i < 10; }
);
Le compilateur génère quelque chose qui ressemble à :
struct Lambda1 {
bool operator()(int i) const { return i > 0 && i < 10; }
};
auto it = std::find_if(v.cbegin(), v.cend(), Lambda1());
Lambda = sucre syntactique de foncteur ?
7. <algorithm>
Les lambdas se combinent parfaitement avec les algorithmes de la
STL :
● all_of
● any_of
● count_if
● equal
● mismatch
● none_of
● copy_if
● generate
● remove_if
● sort
● transform
● ...
● binary_search
● find_if
● find_if_not
● for_each
● includes
● minmax
Il est désormais plus facile d'utiliser ces algorithmes au lieu de les
recoder / dissimuler via une boucle for.
● boucle for = goto moderne ?
8. std::async
Les lambdas sont aussi très pratiques en programmation concurrente /
asynchrone :
#include <future>
// exécution asynchrone d'une tâche
std::future<int> f = std::async([] {
// calcul qui prend du temps…
return result;
});
// faire autre chose...
// résultat de l'opération asynchrone
int r = f.get();
9. Qt 5
Depuis Qt5, elles peuvent être utilisées comme slot :
QTcpSocket * socket = new QTcpSocket;
socket->connectToHost("www.example.com", 80);
QObject::connect(socket, &QTcpSocket::connected, [socket]() {
socket->write(QByteArray("GET index.htmlrn"));
});
QObject::connect(socket, &QTcpSocket::readyRead, [socket]() {
qDebug() << "GOT DATA " << socket->readAll();
});
QObject::connect(socket, &QTcpSocket::disconnected, [socket]() {
qDebug() << "DISCONNECTED";
socket->deleteLater();
});
10. Possibilités
A peu près tout ce qui est autorisé dans une fonction nommée l'est aussi
dans une lambda :
● Expressions complexes
● Multiples return
● Lancer / attrapper des exceptions
● Définir d'autres lambdas
● …
Mais l'idée générale est d'avoir quelque chose de concis, en lien étroit
avec le contexte de son utilisation.
Ce qui n'est pas possible : accéder au pointeur this du foncteur généré
par le compilateur.
● Une lambda ne peut donc pas s'appeler elle-même de façon directe.
11. Type d'une lambda
Une lambda qui ne capture aucune variable peut être convertie en
pointeur de fonction. Exemple :
std::atexit([]{
LOG_INFO("Exiting...");
});
Mais le type de la lambda elle-même est non spécifié. Chaque lambda
introduit en effet un nouveau type qui lui est spécifique :
int main() {
[] {
std::cout << __FUNCTION__ << "n";
}();
}
main::<lambda_a8379e393dcd443e8683ae1a31573b62>::operator ()
12. std::function
On ne peut donc pas spécifier de type « lambda » en paramètre / retour
d'une fonction (puisqu'il n'y a pas de tel type global).
Pour ce faire, on utilisera std::function qui peut encapsuler une
lambda, mais aussi d'autre objets appelables :
● Un foncteur
● Un pointeur de fonction « à la C »
● Un objet fonction créé avec std::bind
#include <functional>
void call(std::function<void(void)> f) {
f();
} call([] { std::exit(1); });
call(std::bind(&std::exit, 1));
13. Durée de vie
Les fermetures lexicales peuvent « survivre » aux fonctions qui les ont
créées :
int a = 1;
std::function<int(int)> returnClosure() {
return [](int x) {
return (x + a);
};
}
int main() {
auto f = returnClosure();
std::cout << f(1); // affiche 2
a += 1;
std::cout << f(1); // affiche 3
}
14. Types de retour des lambdas
Préciser le type de retour est optionnel quand :
● il s'agit de void
● le corps de la fonction lambda consiste en un return expr;
Autrement le type de retour doit être spécifié via la syntaxe « à la traîne »
(trailing return type) :
auto f = [](int i) -> int {
g();
return i + h();
};
C++14 assouplit les règles à ce niveau.
15. Trailing return type notation
Cette syntaxe à la traîne :
● Est la seule façon de préciser le type de retour des lambdas quand
cela est nécessaire
● est permise pour n'importe quelle fonction (précédée de auto), y
compris main()
● se combine souvent avec decltype
void f(int x); // syntaxe traditionnelle
auto f(int x)->void; // déclaration équivalente
class A {
public:
bool f1() const;
auto f2() const -> bool;
};
16. Capture de variables
Pour référencer des variables locales (non statiques), la lambda doit les
capturer (principe de la closure) :
std::vector<int> v = { 5, 10, 20 };
int minVal = 10;
// capture de minVal
auto l = [minVal](int i) {
return i > minVal;
};
// affiche 20
std::cout << *std::find_if(
class Lambda {
public:
Lambda(int m) : minVal(m) {}
bool operator()(int i) const {
return i > minVal;
}
private:
int minVal;
};
v.cbegin(), v.cend(), l);
C++11 : le type capturé doit être copiable (donc pas de unique_ptr)
C++14 introduit la généralisation de capture
17. Capture de variables
La capture peut aussi être effectuée par référence :
auto l = [&minVal](int i) {
return i > minVal;
};
class Lambda {
public:
Lambda(int m) : minVal(m) {}
bool operator()(int i) const {
return i > minVal;
}
private:
int & minVal;
};
18. Généralités
On peut combiner les types de capture :
int minVal = 10;
int maxVal = 20;
auto l = [&minVal, maxVal](int i) {
return i > minVal && i < maxVal;
};
class Lambda {
public:
Lambda(int m1, int m2) : minVal(m1), maxVal(m2) {}
bool operator()(int i) const {
return i > minVal && i < maxVal;
}
private:
int & minVal;
int maxVal;
};
19. Généralités
Le mode de capture par défaut peut aussi être spécifié :
int minVal = 10;
int maxVal = 20;
auto f1 = [=](int i) { // défaut : par valeur
return i > minVal && i < maxVal;
};
auto f2 = [&](int i) { // défaut : par référence
return i > minVal && i < maxVal;
};
Quand un mode de capture par défaut est spécifié, les variables
capturées n'ont plus besoin d'être listées.
20. Généralités
On peut bien sûr ajuster le mode de capture au besoin :
int minVal = 10;
int maxVal = 20;
auto f = [=, &minVal](int i) {
return i > minVal && i < maxVal;
};
minVal est capturé par référence, maxVal par valeur.
21. Capturer des membres de classe
On ne peut pas capturer directement les membres d'une classe :
class A {
public:
void f() {
// erreur: this->minVal ne peut pas être capturé !
auto l = [minVal](int i) {
return i > minVal;
};
}
private:
std::vector<int> data;
int minVal;
};
22. Généralités
Pour accéder aux membres d'une classe, il faut capturer this :
class A {
public:
void f() {
/// OK: "minVal" => "this->minVal"
auto l = [this](int i) {
return i > minVal;
};
}
private:
std::vector<int> data;
int minVal;
};
Tous les membres de la classe (même privés) sont accessibles car le
type de la closure fait partie intégrante de la classe où il a été défini.
23. Capture implicite de this
On peut aussi préciser un mode de capture par défaut afin de capturer
implicitement this :
class A {
void f() {
auto it = std::find_if(data.cbegin(), data.cend(),
// OK: copie this dans la closure
[=](int i) { return i > minVal; }
);
}
int minVal = 0;
std::vector<int> data;
};
24. Capture de this par référence
Version avec capture implicite par référence :
void A::f() {
auto it = std::find_if(data.cbegin(), data.cend(),
// OK: maintient une référence vers this dans la closure
[&](int i) { return i > minVal; }
);
}
A noter que :
● la capture de this par référence est potentiellement plus lente à
cause de la double indirection (reference->this->minVal).
● comme toute référence, l'objet référencé peut ne plus exister…
● de même que la capture de this !
25. Capture de this par référence
Si un objet est capturé par référence, celui-ci peut être modifié :
int n = 10;
auto f = [&n] {
n = 20; // OK
};
struct Lambda1 {
Lambda1(int & N) : n(N) {}
void operator()() const {
n = 20; // OK (bien que fonction const!)
}
int & n;
};
Et oui : c'est l'objet référencé qui est modifié, pas la référence !
26. Capture de this par référence
Par contre, cela ne fonctionne pas avec une capture par copie :
int n = 10;
auto f = [n] {
n = 20; // « impossible de modifier une capture par valeur
dans une expression lambda non mutable »
};
struct Lambda1 {
Lambda1(int N) : n(N) {}
void operator()() const {
n = 20; // Erreur : modification depuis const !
}
int n;
};
Une lambda devrait en effet produire le même résultat si appelée deux
fois de suite avec les mêmes arguments (stateless).
27. Lambda mutable
Pour pouvoir modifier une variable capturée par copie, il faut que la
lambda soit mutable :
int n = 10;
auto f = [n]() mutable {
n = 20; // OK
};
struct Lambda1 {
Lambda1(int N) : n(N) {}
void operator()() {
n = 20;
}
int n;
};
operator() n'est plus const.
28. Lambdas en C++14
C++14 vient compléter C++11 à divers niveaux.
En ce qui concerne les lambdas, la modification majeure est la possibilité
d'utiliser auto comme type des paramètres.
Les lambdas deviennent alors génériques (polymorphiques).
29. Lambda générique
auto add = [](auto a, auto b) { return a + b; }
struct Lambda {
template<typename T1, typename T2>
auto operator()(T1 a, T2 b) const -> decltype(a + b) {
return a + b;
Lambda = foncteur sous stéroïde ?
}
};
30. Risques / abus d'utilisation ?
Prepare for unforeseen
consequences...
31. Lambda vs fonction nommée
auto isValidId = [](QString s) {
return s.size() >= 4 &&
s.size() <= 8) &&
(s.toUpper() == s);
};
for (auto & item : group1){
if (isValidId(item->id))
// ...
}
for (auto & item : group2) {
if (isValidId(item->id))
// ...
}
static bool isValidId(QString s) {
return s.size() >= 4 &&
s.size() <= 8) &&
(s.toUpper() == s);
};
for (auto & item : group1){
if (isValidId(item->id))
// ...
}
for (auto & item : group2) {
if (isValidId(item->id))
// ...
}
Si une lambda doit être utilisée plusieurs fois, faut-il lui préférer une
fonction nommée (locale) ?
33. Attention à la capture par référence
class A {
public:
int compute(); // résultat long à calculer
};
future<int> computeAsync(shared_ptr<A> pA) {
return async([&pA]() {
return pA->compute();
});
}
int main() {
auto f = computeAsync(make_shared<A>());
// ...
cout << f.get();
}
Le pointeur intelligent reçu a
été capturé sous forme de
référence… son compteur
d'utilisation n'est pas
incrémenté !
Ce pointeur intelligent est
un temporaire qui est
détruit une fois la fonction
computeAsync() appelée.
34. Récapitulatif
Les expressions lambda génèrent des fermetures lexicales (closures).
Le contexte d'appel peut être capturé par valeur ou par référence.
Le type de retour - si spécifié - utilise la syntaxe dite « à la traîne ».
Les fermetures peuvent être conservées avec auto ou std::function.
● Attention à la durée de vie des variables capturées !
Les lambdas devraient rester concises et spécifiques à un contexte
particulier (utilisées à un seul endroit).
C++14 ajoute le support de paramètres auto, de la capture généralisée,
ainsi que plus de souplesse au niveau de la déduction du type de retour.
35. Conclusion
Au final, une lambda c'est quoi ?
Du sucre syntactique de foncteur sous stéroïde !