Objectifs des fonctions lambda

• Les fonctions lambda en C++ sont utilisées pour définir :

• des fonctions anonymes (c'est-à-dire sans nom) à l'intérieur du code, souvent
dans le contexte de fonctions d'ordre supérieur, comme les algorithmes de la
bibliothèque standard du C++.
• L'objectif principal des fonctions lambda est de permettre la création
de petites fonctions ad hoc pour une utilisation locale, sans avoir
besoin de définir formellement une fonction séparée.
Objectifs des fonctions lambda
• Concision : Les fonctions lambda permettent de définir de petites fonctions en quelques lignes de code,
directement à l'endroit où elles sont utilisées. Cela permet d'améliorer la lisibilité du code en évitant la
nécessité de déclarer et de définir une fonction séparée.

• Expressivité : Les fonctions lambda permettent de définir la logique d'une fonction directement dans le
contexte où elle est utilisée, ce qui peut rendre le code plus expressif et faciliter la compréhension du
comportement attendu.

• Flexibilité : Les fonctions lambda sont flexibles et peuvent être utilisées comme des arguments de fonction,
des variables locales ou des membres de classe, ce qui permet de les utiliser dans une grande variété de
situations et de scénarios.

• Captures de variables : Les fonctions lambda peuvent capturer des variables du contexte où elles sont définies,
ce qui leur permet d'accéder à ces variables même lorsque la portée dans laquelle elles ont été définies a expiré.
Cela permet de créer des fonctions avec des comportements dépendant de l'état du contexte.
#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;
int main() {

auto f =[](int i){

return i+10;
};
vector<int> v={1,2,3,4};
transform(cbegin(v),cend(v),begin(v),f);
for_each(cbegin(v),cend(v),[](int n){
cout<<n<<" "<<endl;
});

return 0;
}
Exemples de capture

• Exercice 1: Écrire une fonction lambda qui prend deux entiers en

entrée et retourne leur somme.
• Exercice 2: Écrire une fonction lambda qui prend un tableau d'entiers
et son nombre d'éléments en entrée, et qui retourne le plus grand
nombre dans le tableau.
• Exercice 3: Écrire une fonction lambda qui prend un entier en entrée et
retourne true si l'entier est pair, et false sinon
Exercice1: #include <iostream>
using namespace std;
int main() {
int x,y;
cout<<"saisir x et y"<<endl;
cin>>x>>y;
// Déclaration de la fonction lambda
//méthode1
auto addition = [x,y]() {
return x + y;
};
//méthode2
auto addition = [=]() { //[=] = capture toutes les variables
return x + y;
};

// Utilisation de la fonction lambda

int sum = addition();

std::cout << "La somme de " << x << " et " << y << " est : " <<
sum << std::endl;

return 0;
}
Exercice 2:
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
// Déclaration de la fonction lambda
max_element de la bibliothèque algorithm
auto maxElement = [](int arr[], int size) {
permet de chercher la valeur maxi d’un tableau
return *max_element(arr, arr + size);
};

// Utilisation de la fonction lambda

int arr[] = {10, 5, 25, 15, 10};
int size = sizeof(arr) / sizeof(arr[0]);
int max = maxElement(arr, size);
std::cout << "Le plus grand element du tableau est : " << max << std::endl;
return 0;
}
Exercice 3:

#include <iostream>

int main() {
// Déclaration de la fonction lambda
auto isEven = [](int num) { //[] capture toutes les variables
return num % 2 == 0;
};

// Utilisation de la fonction lambda

int x = 8;
bool result = isEven(x);

std::cout << "Le nombre " << x << " est-il pair ? " << (result ? "Oui" : "Non") << std::endl;

return 0;
}
#include <iostream>
#include <vector> Recherche de la valeur minimal des éléments d’un vecteur
#include <algorithm>
using namespace std;

int main() {
vector<int> v = {5, 8, 2, 3, 3, 4, 12};
int minval = 5;

auto x = find_if(v.begin(), v.end(), [minval](int a) {

return a < minval;
});

if (x != v.end()) {
std::cout << "La valeur minimale de la liste est : " << *x << std::endl;
} else {
std::cout << "Aucune valeur minimale trouvée dans la liste." << std::endl;
}

return 0;
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Lambda {
public:
bool operator()(int i1, int i2) const {
return i1 < i2;
}
};
int main() {
vector<int> v = {5, 8, 2, 3, 3, 4, 12}; // Modification des valeurs du vecteur v
Lambda lambda; // Création d'une instance de la classe Lambda

// Utilisation de la fonction min_element avec la classe Lambda pour rechercher le

minimum
auto min_num = min_element(v.begin(), v.end(), lambda);

// Vérification si la recherche a réussi

if (min_num != v.end()) {
cout << "Le minimum est : " << *min_num << endl;
} else {
cout << "Le vecteur est vide." << endl;
}

return 0;
}
Exemple #include <iostream>
int main() {
int x = 10;
int y = 20;

// Utilisation d'une capture par référence dans une fonction lambda

auto sum = [&x, &y]() {
return x + y;
};
// Modification des valeurs de x et y
x = 30;
y = 40;

// Appel de la fonction lambda pour obtenir la somme

int result = sum();
std::cout << "Résultat : " << result << std::endl; // Affiche "Résultat : 70"

return 0;
}
On peut combiner un passage par valeur et un autre par référence

#include <iostream>
int main() {
int x = 10;
int y = 20;

// Utilisation d'une capture par référence dans une fonction lambda

auto sum = [&x, y]() {

return x + y;
};
// Modification des valeurs de x et y
x = 30;
y = 40;

// Appel de la fonction lambda pour obtenir la somme

int result = sum();
std::cout << "Résultat : " << result << std::endl; // Affiche "Résultat : 70"
return 0;
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class lambda {
private:
int minval;
int maxval;
public:
lambda(int m1, int m2) : minval(m1), maxval(m2) {} // Correction : m -> m2
bool operator()(int i) const {
return i > minval && i < maxval;
}
};
int main() {
vector<int> nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int min_val = 3;
int max_val = 8;

// Utilisation de la classe lambda pour filtrer les nombres entre min_val et max_val
vector<int> filtered_nums;
auto lambda_filter = lambda(min_val, max_val);
for (int num : nums) {
if (lambda_filter(num)) {
filtered_nums.push_back(num);
}
}

// Affichage des nombres filtrés

cout << "Nombres filtrés entre " << min_val << " et " << max_val << ": ";
for (int num : filtered_nums) {
cout << num << " ";
}
cout << endl;

return 0;
}
#include <iostream>
#include <vector>
class A {
public:
void f() {
auto l = [this](int i) {
return i > minval;
};
// Exemple d'affichage de valeurs
minval = 5;
std::cout << "minval : " << minval << std::endl;
std::cout << "Résultat de la lambda pour i=10 : " << l(10) << std::endl;
}

private:
std::vector<int> data;
int minval;
};

int main() {
A obj; // Création d'un objet de la classe A

obj.f(); // Appel de la fonction f() de l'objet

return 0;
}