X Tutup
The Wayback Machine - https://web.archive.org/web/20220114221114/https://ru.cppreference.com/w/cpp/language/lambda
Пространства имён
Варианты
Действия

Лямбда-выражения (начиная с C++11)

Материал из cppreference.com
< cpp‎ | language
 
 
Язык С++
Общие темы
Управление потоком
Операторы условного выполнения
if
Операторы итераций (циклы)
Операторы переходов
Функции
Объявление функции
Выражение лямбда-функции
Спецификатор inline
Спецификации динамических исключений (до C++20)
Спецификатор noexcept (C++11)
Исключения
Пространства имён
Типы
Спецификаторы
decltype (C++11)
auto (C++11)
alignas (C++11)
Спецификаторы длительности хранения
Инициализация
Выражения
Альтернативные представления
Литералы
Логические - Целочисленные - С плавающей запятой
Символьные - Строковые - nullptr (C++11)
Определённые пользователем (C++11)
Утилиты
Атрибуты (C++11)
Типы
Объявление typedef
Объявление псевдонима типа (C++11)
Приведения
Неявные преобразования - Явные преобразования
static_cast - dynamic_cast
const_cast - reinterpret_cast
Выделение памяти
Классы
Свойства функции, зависящие от класса
explicit (C++11)
static
Специальные функции-элементы
Шаблоны
Разное
 

Создает замыкание — безымянный объект-функцию, способный захватывать переменные в контекст.

Содержание

[править] Синтаксис

[ capture ] ( params ) mutable exception attribute -> ret { body } (1)
[ capture ] ( params ) -> ret { body } (2)
[ capture ] ( params ) { body } (3)
[ capture ] { body } (4)

1) Полное объявление.

2) Объявление константной лямбды: объекты, захваченные копированием, не могут быть изменены.

3) Опущен возвращаемый тип в конце: возвращаемый тип operator() у замыкания выводится из оператора return словно для функции, чей возвращаемый тип объявлен auto.

4) Пропущен список параметров: функция не принимает аргументов, как если бы список параметров был ().

[править] Объяснение

mutable позволяет body изменять параметры, захваченные копированием, и вызывать их неконстантные функции-члены
exception обеспечивает спецификацию исключения или опцию noexcept для оператора () типа-замыкания
attribute
обеспечивает спецификацию атрибута для оператора () типа замыкания
Оригинал:
provides the attribute specification for operator() of the closure type
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
capture определяет, какие символы, видимые в области объявления функции, ​​будут видны внутри тела функции

Список символов может быть передан следующим образом:

  • [a,&b] где a захвачена по значению, а b захвачена по ссылке.
  • [this] захватывает указатель this по значению.
  • [&] захват всех символов по ссылке
  • [=] захват всех символов по значению
  • [] ничего не захватывает
params список параметров, как в объявлении функции
ret Возвращаемый тип. Если не указан, то выводится из возвращаемого значения (или void, если функция не возвращает никакого значения).


Лямбда-выражение создает безымянный временный объект уникального безымянного non-union, non-aggregate типа, известного как тип замыкания, который имеет следующие члены:
Оригинал:
The lambda expression constructs an unnamed temporary object of unique unnamed non-union non-aggregate type, known as closure type, which has the following members:
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

ClosureType::operator(params)

ret operator()(params) const { body }
(Ключевое слово mutable не было использовано)
ret operator()(params) { body }
(Ключевое слово mutable было использовано)
Исполняет тело лямбда-выражения при вызове. При попытке доступа к переменной получает доступ к захваченной копии (для сущностей, захваченных копированием), или к самому объекту (для сущностей, захваченных по ссылке). Если ключевое слово mutable не было использовано в лямбда-выражении, объекты, захваченные копированием, немодифицируемы внутри этого operator()
Оригинал:
Executes the body of the lambda-expression, when invoked. When accessing a variable, accesses its captured copy (for the entities captured by copy), or the original object (for the entities captured by reference). Unless the keyword mutable was used in the lamda-expression, the objects that were captured by copy are non-modifiable from inside this operator()
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
.

"Висячие" ссылки
Оригинал:
Dangling references
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

Если сущность захвачена по ссылке, явно или неявно, и оператор вызова функции объекта замыкания вызывается после окончания времени жизни этой сущности, это приводит к неопределенному поведению. Замыкания С++ не расширяют время жизни захваченных ссылок.
Оригинал:
If an entity is captured by reference, implicitly or explicitly, and the function call operator of the closure object is invoked after the entity's lifetime has ended, undefined behavior occurs. The C++ closures do not extend the lifetimes of the captured references.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

ClosureType::operator ret(*)(params)

typedef ret(*F)(params);
operator F() const;
Эта функция-член определена только если список захвата лямбда-выражения пуст.
Оригинал:
This member function is only defined if the capture list of the lambda-expression is empty.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.
Значение, возвращаемое этой функцией преобразования - указатель на функцию, который, будучи вызванным, имеет такой же эффект, как и при вызове функции оператора вызова объекта замыкания напрямую.
Оригинал:
The value returned by this conversion function is a function pointer that, when invoked, has the same effect as invoking the closure object's function call operator directly.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

ClosureType::ClosureType()

ClosureType() = delete;
ClosureType(const ClosureType& ) = default;
ClosureType(ClosureType&& ) = default;

Closure types are not DefaultConstructible. The copy constructor and the move constructor are implicitly-declared and may be implicitly-defined according to the usual rules for implicit конструктор копирования and конструктор перемещения.

ClosureType::operator=()

ClosureType& operator=(const ClosureType&) = delete;

Closure types are not CopyAssignable.

ClosureType::~ClosureType()

~ClosureType() = default;

The destructor is implicitly-declared.

ClosureType::CapturedParam

T1 a;

T2 b;

...

If the lambda-expression captures anything by copy (either implicitly with capture clause [=] or explicitly with a capture that does not include the character &, e.g. [a, b, c]), the closure type includes unnamed non-static data members, declared in unspecified order, that hold copies of all entities that were so captured.

The type of each data member is the type of the corresponding captured entity, except if the entity has reference type (in that case, references to functions are captured as-is, and references to objects are captured as copies of the referenced objects).

For the entities that are captured by reference (with the default capture [&] or when using the character &, e.g. [&a, &b, &c]), it is unspecified if additional data members are declared in the closure type.

[править] Пример

Этот пример показывает, как передать лямбду в общий алгоритм и что объекты, полученные в результате объявления лямбды, могут быть сохранены в объектах std::function.
Оригинал:
This example shows how to pass a lambda to a generic algorithm and that objects resulting from a lambda declaration, can be stored in std::function objects.
Текст был переведён автоматически используя Переводчик Google.
Вы можете проверить и исправить перевод. Для инструкций щёлкните сюда.

#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
 
int main()
{
    std::vector<int> c { 1,2,3,4,5,6,7 };
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; } ), c.end());
 
    std::cout << "c: ";
    for (auto i: c) {
        std::cout << i << ' ';
    }
    std::cout << '\n';
 
    std::function<int (int)> func = [](int i) { return i+4; };
    std::cout << "func: " << func(6) << '\n';
}

Вывод:

c: 5 6 7
func: 10

[править] См. также

}}
спецификатор auto задаёт тип, определяемый выражением (C++11) [править]
(C++11)
обёртывает вызываемый объект любого конструируемого копированием типа с указанной сигнатурой вызова функции
(шаблон класса) [править]
X Tutup