Проблема
C ++ включає такі корисні загальні функції, як std::for_eachі std::transform, що може бути дуже зручно. На жаль, вони також можуть бути досить громіздкими у використанні, особливо якщо функтор, який ви хочете застосувати, унікальний для певної функції.
#include <algorithm>
#include <vector>
namespace {
struct f {
void operator()(int) {
// do something
}
};
}
void func(std::vector<int>& v) {
f f;
std::for_each(v.begin(), v.end(), f);
}
Якщо ви використовуєте лише fодин раз і в цьому конкретному місці, здається, зайвим є написання цілого класу, щоб зробити щось тривіальне і одне.
У C ++ 03 ви можете спокуситись написати щось на зразок наступного, щоб зберегти функціонера локальним:
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
однак це не дозволено, fне може бути передано функції шаблону в C ++ 03.
Нове рішення
C ++ 11 представляє лямбдаси, які дозволяють написати вбудований, анонімний функтор для заміни struct f. Для невеликих простих прикладів це може бути більш чистим для читання (він зберігає все на одному місці) і потенційно простішим у підтримці, наприклад, у найпростішому вигляді:
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Функції лямбда - це лише синтаксичний цукор для анонімних функціонерів.
Типи повернення
У простих випадках для вас виводиться тип повернення лямбда, наприклад:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
однак, коли ви почнете писати складніші лямбда, ви швидко зустрінете випадки, коли компілятор не може визначити тип повернення, наприклад:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
Щоб вирішити це рішення, ви можете чітко вказати тип повернення для функції лямбда, використовуючи -> T:
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) -> double {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
"Захоплення" змінних
Поки ми не використовували нічого, крім того, що було передано лямбда всередині нього, але ми також можемо використовувати й інші змінні в межах лямбда. Якщо ви хочете отримати доступ до інших змінних, ви можете використовувати пункт захоплення ( []вираз), який до цих пір не використовувався в цих прикладах, наприклад:
void func5(std::vector<double>& v, const double& epsilon) {
std::transform(v.begin(), v.end(), v.begin(),
[epsilon](double d) -> double {
if (d < epsilon) {
return 0;
} else {
return d;
}
});
}
Ви можете захопити з допомогою як посилання і значення, яке можна задати з допомогою &і =відповідно:
[&epsilon] захоплення посиланням[&] фіксує всі змінні, використовувані в лямбда за посиланням[=] фіксує всі значення, використовувані в лямбда за значенням[&, epsilon] фіксує змінні типу [&], але epsilon за значенням[=, &epsilon] фіксує змінні типу [=], але epsilon за посиланням
Сформований operator()це constза замовчуванням, з підтекстом , що захоплює буде constпри зверненні до них за замовчуванням. Це призводить до того, що кожен виклик з одним і тим же входом дасть однаковий результат, однак ви можете відзначити лямбда якmutable просити, щоб те, operator()що виробляється, не було const.
