Просмотр кода страницы cpp/language/lambda

У вас нет прав на выполнение действия «редактирование этой страницы» по следующей причине:
Запрошенное действие могут выполнять участники одной из следующих групп: Участники, Администраторы.
Вы можете просмотреть и скопировать исходный код этой страницы.
{{title|Лямбда-выражения {{mark since c++11}}}}
{{cpp/language/expressions/functions/navbar}}

Создаёт {{enwikiru|Замыкание (программирование)|замыкание}}: безымянный функциональный объект, способный захватывать переменные в области видимости.

===Синтаксис===
=====Лямбда-выражения без явного списка параметров шаблона (возможно, неуниверсальные)=====
{{sdsc begin}}
{{sdsc|num=1|
{{ttb|[}}{{spar sep|захваты}}{{ttb|]}} {{spar optional|передние-атрибуты}} {{ttb|(}}{{spar sep|параметры}}{{ttb|)}} {{spar optional|specs}} {{spar optional|выражение}}<br>{{spar optional|задние-атрибуты}} {{spar optional|конечный-тип}} {{spar optional|requires}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=2|notes={{mark until c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|] {}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=2|notes={{mark since c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|]}} {{spar optional|передние-атрибуты}} {{spar optional|конечный-тип}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=3|notes={{mark since c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|]}} {{spar optional|передние-атрибуты}} {{spar|выражение}}<br>{{spar optional|задние-атрибуты}} {{spar optional|конечный-тип}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=4|notes={{mark since c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|]}} {{spar optional|передние-атрибуты}} {{spar|specs}} {{spar optional|выражение}}<br>{{spar optional|задние-атрибуты}} {{spar optional|конечный-тип}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc end}}

=====Лямбда-выражения с явным списком параметров шаблона (всегда общие) {{mark since c++20}}=====
{{sdsc begin}}
{{sdsc|num=1|
{{ttb|[}}{{spar sep|захваты}}{{ttb|] <}}{{spar sep|tпараметры}}{{ttb|>}} {{spar optional|t-requires}} {{spar optional|передние-атрибуты}} {{ttb|(}}{{spar sep|параметры}}{{ttb|)}} {{spar optional|specs}}<br>{{spar optional|выражение}} {{spar optional|задние-атрибуты}} {{spar optional|конечный-тип}} {{spar optional|requires}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=2|notes={{mark until c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|] <}}{{spar sep|tпараметры}}{{ttb|>}} {{spar optional|t-requires}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=2|notes={{mark since c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|] <}}{{spar sep|tпараметры}}{{ttb|>}} {{spar optional|t-requires}}<br>{{spar optional|передние-атрибуты}} {{spar optional|конечный-тип}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=3|notes={{mark since c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|] <}}{{spar sep|tпараметры}}{{ttb|>}} {{spar optional|t-requires}} {{spar optional|передние-атрибуты}} {{spar|выражение}}<br>{{spar optional|задние-атрибуты}} {{spar optional|конечный-тип}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc|num=4|notes={{mark since c++23}}|
{{ttb|[}}{{spar sep|захваты}}{{ttb|] <}}{{spar sep|tпараметры}}{{ttb|>}} {{spar optional|t-requires}} {{spar optional|передние-атрибуты}} {{spar|specs}} {{spar optional|выражение}}<br>{{spar optional|задние-атрибуты}} {{spar optional|конечный-тип}} {{ttb|{}} {{spar|тело}} {{ttb|}<!---->}}
}}
{{sdsc end}}

@1@ Лямбда-выражение со списком параметров.

@2-4@ Лямбда-выражение без списка параметров.
:@2@ Самый простой синтаксис. {{spar|задние-атрибуты}} нельзя применить.
:@3,4@ {{spar|задние-атрибуты}} могут применяться только в том случае, если присутствует какое-либо из {{spar|specs}} и {{spar|выражение}}.

===Объяснения===
{{par begin}}
{{par|{{spar|захваты}}|разделённый запятыми список из нуля или более [[#Лямбда-захват|захватов]], необязательно начинающийся с {{spar|захвата по умолчанию}}.

Смотрите [[#Лямбда-захват|ниже]] для подробного описания захватов.

Лямбда-выражение может использовать переменную без её захвата, если переменная
* является нелокальной переменной или имеет статическую или локальную к потоку {{rlp|storage duration|длительность хранения}} (в этом случае переменная не может быть захвачена), или
* это ссылка, которая была инициализирована {{rlp|constant expression#Константное выражение|константным выражением}}.

Лямбда-выражение может счит��вать значение переменной без её захвата, если переменная
* имеет константный не volatile целочисленный тип или тип перечисления и была инициализирована {{rlp|constant expression#Константное выражение|константным выражением}}, или
* является {{c/core|constexpr}} и не имеет mutable элементов.}}
{{par|{{spar|tпараметры}}|непустой список разделённых запятыми {{rlp|template parameters|параметров шаблона}}, используемый для предоставления имён параметрам шаблона общего лямбда-выражения (смотрите {{c/core|ClosureType::operator()}} ниже).}}
{{par|{{spar|t-requires}}|добавляет {{rlp|constraints|ограничения}} к {{spar|tпараметрам}}
{{rrev|since=c++23|
Если {{spar|t-requires}} заканчивается последовательностью спецификаторов атрибутов, атрибуты в последовательности рассматриваются как атрибуты в {{spar|передних-атрибутах}}.
}}}}
{{par|{{spar|передние-атрибуты}}|{{mark since c++23}} {{rlp|attributes|Последовательность спецификаторов атрибутов}} применяется к оператору вызова функции или шаблону оператора типа замыкания (и, следовательно, можно использовать атрибут {{attr|noreturn}}).}}
{{par|{{spar|параметры}}|Список параметров, как в {{rlp|function|именованных функциях}}.}}
{{par|{{spar|specs}}|Необязательная последовательность спецификаторов. Если не указано, объекты, захваченные копированием, являются константами в теле лямбды. Следующие спецификаторы разрешены не более одного раза в каждой последовательности:
* {{ttb|mutable}}: позволяет {{spar|телу}} изменять объекты, захваченные копированием, и вызывать их неконстантные функции-элементы
{{rrev|since=c++17|
* {{ttb|constexpr}}: явно указывает, что оператор вызова функции или любая заданная специализация шаблона оператора является функцией {{rlp|constexpr}}. Когда этот спецификатор отсутствует, оператор вызова функции или любая заданная специализация шаблона оператора будет в любом случае {{c/core|constexpr}}, если они соответствуют всем требованиям функции constexpr
}}
{{rrev|since=c++20|
* {{ttb|consteval}}: указывает, что оператор вызова функции или любая заданная специализация шаблона оператора является {{rlp|consteval|немедленной функцией}}. {{c/core|consteval}} и {{c/core|constexpr}} нельзя использовать одновременно.
}}}}
{{rrev|since=c++23|
* {{ttb|static}}: казывает, что оператор вызова функции или любая заданная специализация шаблона оператора представляет собой {{rlp|static#Статические функции-элементы|статическая функцию-элемент}}. {{c/core|mutable}} и {{c/core|static}} не могут использоваться одновременно, а {{spar|захваты}} должны быть пустыми, если присутствует {{c/core|static}}.
}}
{{par|{{spar|исключение}}|предоставляет{{rev inl|until=c++20| {{rlp|except spec|спецификацию динамического исключения}} или}} {{rlp|noexcept spec|спецификатор noexcept}} для {{c/core|operator()}} типа замыкания}}
{{par|{{spar|задние-атрибуты}}|{{rlp|attributes|Последовательность спецификаторов атрибутов}} применяется к типу оператора вызова функции или шаблону оператора типа замыкания. Любой указанный таким образом атрибут относится не к самому оператору вызова функции или шаблону оператора, а к его типу. (Например, атрибут {{attr|noreturn}} использовать нельзя.)}}
{{par|{{spar|конечный-тип}}|{{ttb|->}} {{spar|ret}}, где {{spar|ret}} указывает тип возвращаемого значения}}
{{par|{{spar|ограничения}}|{{mark since c++20}} добавляет {{rlp|constraints|ограничения}} типа замыкания оператора {{c/core|operator()}}}}
{{par|{{spar|тело}}|Тело функции}}
{{par end}}

{{rrev|since=c++14|Если в качестве типа параметра используется {{rlpt|auto}}{{rev inl|since=c++20| или предоставляется явный список параметров шаблона}}, лямбда является ''универсальной лямбдой''.}}

Переменная {{c|__func__}} неявно определена в начале {{spar|тела}}, с семантикой, описанной {{rlp|function#func|здесь}}.

Лямбда-выражение представляет собой выражение prvalue уникального безымянного класса, ��тличного от {{rlp|union}} не {{rlp|aggregate initialization|агрегатного}} не {{rlp|template parameters#Параметр шаблона не тип|структурного}} классвового типа, известного как ''тип замыкания'', который объявлен (для целей {{rlp|adl|ADL}}) в наименьшем блоке области видимости, области видимости класса или области видимости пространства имён, которая содержит лямбда-выражение. Тип замыкания имеет следующие элементы, они не могут быть {{rev inl|since=c++14|{{rlp|function template#Явное создание экземпляра|созданы явно}}, {{rlp|template specialization|явно специализированы}}, или}} именованы в {{rlp|friend|объявлении friend}}:

{{anchor|closure_type_fun_operator}}
{{member|{{small|ClosureType::}}operator()({{spar|параметры}})|2=
{{dcl begin}}
{{dcl|notes={{mark|ключевое слово mutable не используется}}|1=
возврат operator()(параметры) const { тело }
}}
{{dcl|notes={{mark|ключевое слово mutable используется}}|1=
возврат operator()(параметры) { тело }
}}
{{dcl|since=c++14|notes={{mark|общая лямбда}}|1=
template<параметры-шаблона>
возврат operator()(параметры) const { тело }
}}
{{dcl|since=c++14|notes={{mark|общая лямбда, использовалось ключевое слово mutable}}|1=
template<параметры-шаблона>
возврат operator()(параметры) { тело }
}}
{{dcl end}}
При вызове выполняет тело лямбда-выражения. При доступе к переменной обращается к её захваченной копии (для сущностей, захваченных копированием) или исходному объекту (для сущностей, захваченных по ссылке).

Список параметров {{c/core|operator()}} это {{spar|параметры}}, если он указан, в противном случае список параметров пуст.

Тип возвращаемого значения {{c/core|operator()}} это тип, указанный в {{spar|конечном-типе}}.
{{rev begin}}
{{rev|until=c++14|
Если {{spar|конечный-тип}} не указан, тип возвращаемого значения {{c/core|operator()}} определяется следующим образом:
* Если {{spar|тело}} состоит только из {{rlp|return|оператора return}}, который возвращает выражение, тип возвращаемого значения это тип этого выражения после преобразования lvalue в rvalue, преобразования массива в указатель и преобразование функции в указатель.
* Иначе тип возвращаемого значения {{c/core|void}}.
}}
{{rev|since=c++14|
Если {{spar|конечный-тип}} не указан или указан как {{ttb|-> auto}}, тип возвращаемого значения {{c/core|operator()}} автоматически {{rlp|function#Вывод возвращаемого типа|выводится}}.
}}
{{rev end}}

Если ключевое слово {{c/core|mutable}} не использовалось в лямбда-спецификаторах, cv-квалификатор оператора вызова функции или шаблона оператора равен {{c/core|const}}, а объекты, которые были захвачены копированием не подлежат изменению изнутри этого {{c/core|operator()}}. Явный квалификатор {{c/core|const}} не допускается. Оператор вызова функции или шаблон оператора никогда не являются виртуальными и не могут иметь квалификатор {{c/core|volatile}}.

{{rrev|since=c++17|
Оператор вызова функции или любой заданной специализации шаблона оператора всегда {{c/core|constexpr}}, если он соответствует требованиям {{rlp|constexpr|функции constexpr}}. Они также constexpr, если в лямбда-выражении использовалось ключевое слово constexpr.
}}
{{rrev|since=c++20|
Оператор вызова функции или любая заданная специализация шаблона оператора являются {{rlp|consteval|немедленной функцией}}, если в лямбда-выражении использовалось ключевое слово {{c/core|consteval}}.
}}
{{rrev|since=c++14|
Для каждого параметра в {{spar|параметрах}}, тип которого указан как {{c/core|auto}}, параметр придуманного шаблона добавляется в {{spar|параметры-шаблона}}, в порядке появления. Придуманный параметр шаблона может быть {{rlp|parameter pack|пакетом параметров}} , если соответствующий {{spar|параметр}} функции элемента является пакетом параметров функции.
<source style="width:45em; overflow-x: hidden;" lang=cpp>
// общая лямбда, operator() это шаблон с двумя параметрами
auto glambda = [](auto a, auto&& b) { return a < b; };
bool b = glambda(3, 3.14); // ok

// общая лямбда, operator() это шаблон с одним параметром
auto vglambda = [](auto printer)
{
    return [=](auto&&... ts) // общая лямбда, ts это пакет параметров
    { 
        printer(std::forward<decltype(ts)>(ts)...);
        // нулевая лямбда (не принимает параметров)
        return [=] { printer(ts...); };
    };
};
auto p = vglambda([](auto v1, auto v2, auto v3)
                  { std::cout << v1 << v2 << v3; });
auto q = p(1, 'a', 3.14); // выводит 1a3.14
q();                      // выводит 1a3.14
</source>
}}
{{rrev|since=c++20|
Если в определении лямбда используется явный список параметров шаблона, этот список параметров шаблона используется с {{c/core|operator()}}. Для каждого параметра в {{spar|параметрах}}, тип которого указан как {{c/core|auto}}, в конец этого списка параметров шаблона добавляется дополнительный параметр придуманного шаблона:
<source style="width:45em; overflow-x: hidden;" lang=cpp>
// общая лямбда, operator() это шаблон с двумя параметрами
auto glambda = []<class T>(T a, auto&& b) { return a < b; };

// общая лямбда, operator() это шаблон с одним пакетом параметров
auto f = []<typename... Ts>(Ts&&... ts)
{
    return foo(std::forward<Ts>(ts)...);
};
</source>
}}

Спецификация исключения {{spar|исключения}} в лямбда-выражении применяется к оператору или шаблону оператора вызова функции.

Для {{rlp|lookup|поиска имени}}, определения типа и значения {{rlp|this|указателя {{c/core|this}}}} и для доступа к нестатическим элементам класса, тело оператора или шаблона оператора вызова функции типа замыкания рассматривается в контексте лямбда-выражения.

{{source|1=
struct X
{
    int x, y;
    int operator()(int);
    void f()
    {
        // контекст следующей лямбды это функция-элемент X::f
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // это имеет тип X*
        };
    }
};
}}

===Висячие ссылки===
Если сущность, не являющийся ссылкой, захвачена по ссылке, явно или неявно, и оператор вызова функции или специализация шаблона оператора вызова функции объекта замыкания вызывается после окончания времени жизни сущности, возникает неопределённое поведение. Замыкания C++ не продлевают время жизни объектов, захваченных по ссылке.

То же самое относится к времени жизни текущего объекта {{c/core|*this}}, захваченного с помощью {{c/core|this}}.
}}

{{member|{{small|ClosureType::}}operator {{spar|возврат}}(*)({{spar|параметры}})()|2=

{{dcl begin}}
{{dcl h|неуниверсальная лямбда без захвата}}
{{dcl rev multi
|dcl1=
using F = возврат(*)(параметры);
operator F() const noexcept;
|since2=c++17|dcl2=
using F = возврат(*)(параметры);
constexpr operator F() const noexcept; 
}}
{{dcl h|общая лямбда без захвата}}
{{dcl rev multi
|since1=c++14|dcl1=
template<параметры-шаблона> using fptr_t = /*смотри ниже*/;
template<параметры-шаблона>
operator fptr_t<параметры-шаблона>() const noexcept;
|since2=c++17|dcl2=
template<параметры-шаблона> using fptr_t = /*смотри ниже*/;
template<параметры-шаблона>
constexpr operator fptr_t<параметры-шаблона>() const noexcept; 
}}
{{dcl end}}

Эта {{rlp|определяемая пользователем функция преобразования}} определяется только в том случае, если список захвата лямбда-выражения пуст. Это открытая, {{rev inl|since=c++17|constexpr,}} не виртуальная, неявная, функция-элемент объекта замыкания.
{{rrev|since=c++20|
Эта функция является {{rlp|consteval|немедленной функцией}}, если оператор вызова функции (или специализация для общих лямбда-выражений) является непосредственной функцией.
}}


{{rrev|since=c++14|
Общая лямбда без захвата имеет пользовательский шаблон функции преобразования с тем же списком параметров придуманного шаблона, что и у шаблона оператора вызова функции. Если тип возвращаемого значения пустой или auto, он получается путём вывода типа возвращаемого значения по специализации шаблона функции, которая, в свою очередь, получается путём {{rlp|template argument deduction|вывода аргумента шаблона}} для шаблонов функций преобразования.
<source style="width:45em; overflow-x: hidden;" lang=cpp>
void f1(int (*)(int)) {}
void f2(char (*)(int)) {}
void h(int (*)(int)) {}  // #1
void h(char (*)(int)) {} // #2

auto glambda = [](auto a) { return a; };
f1(glambda); // OK
f2(glambda); // ошибка: не преобразуется
h(glambda);  // OK: вызывает #1, так как #2 не преобразуется

int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK
</source>
}}

Значение, возвращаемое этой функцией преобразования {{rev inl|since=c++14|(шаблоном)}}, является указателем на функцию с {{rlp|языковым связыванием}} C++, которая при вызове имеет тот же эффект, что и:
* {{rev inl|since=c++14|для неуниверсальных лямбда-выражений,}} вызов оператора вызова функции типа замыкания для созданного по умолчанию экземпляра типа замыкания.
{{rrev|since=c++14|
* для универсальных лямбда-выражений вызов специализации шаблона оператора вызова функции, соответствующего универсальному лямбда-выражению, для созданного по умолчанию экземпляра типа замыкания.
}}


{{rrev|since=c++17|
Эта функция является constexpr, если оператор вызова функции (или специализации для общих лямбда-выражений) является constexpr.
<source style="width:45em; overflow-x: hidden;" lang=cpp>
auto Fwd = [](int(*fp)(int), auto a){ return fp(a); };
auto C = [](auto a){ return a; };
static_assert(Fwd(C, 3) == 3);  // OK

auto NC = [](auto a){ static int s; return a; };
static_assert(Fwd(NC, 3) == 3); // ошибка: никакая специализация не может
                                // constexpr из-за static s
</source>

Если {{c/core|operator()}} объекта замыкания имеет спецификацию исключения, не вызывающую исключение, то указатель, возвращаемый этой функцией, имеет тип указателя на функцию noexcept.
}}
}}
{{member|{{small|ClosureType::}}ClosureType()|2=
{{dcl begin}}
{{dcl|since=c++20|notes={{mark|только если захваты не указаны}}|1=
ClosureType() = default;
}}
{{dcl|1=
ClosureType(const ClosureType&) = default;
}}
{{dcl|1=
ClosureType(ClosureType&&) = default;
}}
{{dcl end}}
{{rrev multi|
until1=c++20|rev1=
Типы замыкания не являются {{named req|DefaultConstructible}}. Типы замыкания не имеют конструктора по умолчанию.
|rev2=Если {{spar|захваты}} не указаны, тип замыкания имеет конструктор по умолчанию по умолчанию. В противном случае у него нет конструктора по умолчанию (это включает в себя случай, когда есть {{spar|захват-по-умолчанию}}, даже если он на самом деле ничего не захватывает).
}}
Конструктор копирования и конструктор перемещения объявляются по умолчанию и могут быть определены неявно в соответствии с обычными правилами для {{rlp|copy constructor|конструкторов копирования}} и {{rlp|move constructor|конструкторов перемещения}}.
}}

{{member|{{small|ClosureType::}}operator{{=}}(const ClosureType&)|2=
{{dcl begin}}
{{dcl|until=c++20|1=
ClosureType& operator=(const ClosureType&) = delete;
}}
{{dcl|since=c++20|notes={{mark|только если захваты не указаны}}|1=
ClosureType& operator=(const ClosureType&) = default;
ClosureType& operator=(ClosureType&&) = default;
}}
{{dcl|since=c++20|notes={{mark|otherwise}}|1=
ClosureType& operator=(const ClosureType&) = delete;
}}
{{dcl end}}
{{rrev multi|
until1=c++20|rev1=
Оператор присваивания копированием определён как удалённый (а оператор присваивания перемещением не объявлен). Типы замыкания не являются {{named req|CopyAssignable}}.
|rev2=Если {{spar|захваты}} не указаны, тип замыкания имеет оператор присваивания копированием по умолчанию и оператор присваивания перемещением по умолчанию. В противном случае у него есть удалённый оператор присваивания копированием (включая случай, когда есть {{spar|захват-по-умолчанию}}, даже если он на самом деле ничего не захватывает).
}}
}}

{{member|{{small|ClosureType::}}~ClosureType()|2=
{{ddcl|1=
~ClosureType() = default;
}}
Деструктор объявлен неявно.
}}

{{member|{{small|ClosureType::}}{{spar|Захваты}}|2=
{{ddcl|1=
T1 a;
T2 b;
...
}}
Если лямбда-выражение захватывает что-либо копированием (либо неявно с предложением захвата {{ttb|[{{=}}]}} либо явно с захватом, который не включает символ &, например, {{ttb|[a, b, c]}}), тип замыкания включает неименованные нестатические элементы данных, объявленные в неопределённом порядке, которые содержат копии всех захваченных сущностей.
Те элементы данных, которые соответствуют захватам без инициализаторов, {{rlp|direct initialization|инициализируются напрямую}} при оценке лямбда-выражения. Те, которые соответствуют захватам с инициализаторами, инициализируются по требованию инициализатора (может быть инициализацией копированием или прямой инициализацией). Если захвачен массив, элементы массива инициализируются напрямую в порядке возрастания индекса. Порядок, в котором инициализируются элементы данных, совпадает с порядком их объявления (который не указан).

Тип каждого элемента данных это тип соответствующего захваченного объекта, за исключением случаев, когда объект имеет ссылочный тип (в этом случае ссылки на функции захватываются как ссылки lvalue на функции, на которые ссылаются, а ссылки на объекты захватываются как копии объектов, на которые они ссылаются).

Для сущностей, захваченных по ссылке (с захватом по умолчанию {{ttb|[&]}} или при использовании символа &, например, {{ttb|[&a, &b, &c]}}), не указано, если дополнительные элементы данных объявляются в типе замыкания{{rev inl|since=c++17|, но любые такие дополнительные элементы должны соответствовать {{named req|LiteralType}}}}.
}}

{{rrev|until=c++20|{{anchor|Lambdas in unevaluated contexts}}
Лямбда-выражения не допускаются в {{rlp|expressions#Невычисляемые выражения|невычисленных выражениях}}, {{rlp|template parameters|аргументах шаблона}}, {{rlp|type alias|объявлениях псевдонимов}}, {{rlp|typedef|объявлениях typedef}} и в любом месте объявления функции (или шаблона функции), за исключением тела функции и {{rlp|default arguments|аргументов по умолчанию}} функции.
}}

===Лямбда-захват===
{{spar|Захваты}} это разделённый запятыми список из нуля или более ''захватов'', необязательно начинающихся с {{spar|захвата-по-умолчанию}}. Список захвата определяет внешние переменные, доступные из тела лямбда-функции. Единственными значениями захвата по умолчанию являются
* {{ttb|&}} (неявные захваты используют переменные с автоматической длительностью хранения по ссылке) и
* {{ttb|{{=}}}} (неявные захваты используют переменные с автоматической длительностью хранения копированием).

Текущий объект ({{c/core|*this}}) может быть неявно захвачен, если присутствует одно из значений захвата по умолчанию. Если захвачен неявно, он всегда захватывается по ссылке, даже если захват по умолчанию равен {{tt|{{=}}}}. {{rev inl|since=c++20|Неявный захват {{c/core|*this}}, если по умолчанию используется захват {{tt|1==}}, устарел.}}

Синтаксис индивидуального захвата в {{spar|захватах}}:
{{sdsc begin}}
{{sdsc|num=1|{{spar|идентификатор}}}}
{{sdsc|num=2|{{spar|идентификатор}} {{ttb|...}}}}
{{sdsc|num=3|notes={{mark since c++14}}|{{spar|идентификатор}} {{spar|инициализатор}}}}
{{sdsc|num=4|{{ttb|&}} {{spar|идентификатор}}}}
{{sdsc|num=5|{{ttb|&}} {{spar|идентификатор}} {{ttb|...}}}}
{{sdsc|num=6|notes={{mark since c++14}}|{{ttb|&}} {{spar|идентификатор}} {{spar|инициализатор}}}}
{{sdsc|num=7|{{ttb|this}}}}
{{sdsc|num=8|{{ttb|*}} {{ttb|this}}|notes={{mark since c++17}}}}
{{sdsc|num=9|notes={{mark since c++20}}|{{ttb|...}} {{spar|идентификатор}} {{spar|инициализатор}}}}
{{sdsc|num=10|notes={{mark since c++20}}|{{ttb|&}} {{ttb|...}} <!--CWG2378-->{{spar|идентификатор}} {{spar|инициализатор}}}}
{{sdsc end}}
@1@ простой захват копированием
@2@ простой захват копированием, который представляет собой {{rlp|parameter pack|расширение пакета}}
@3@ захват копированием с {{rlp|initialization|инициализатором}}
@4@ простой захват по ссылке
@5@ простой захват по ссылке, который представляет собой {{rlp|parameter pack|расширение пакета}}
@6@ захват по ссылке с инициализатором
@7@ простой захват по ссылке текущего объекта
@8@ простой захват копированием текущего объекта
@9@ захват копированием с инициализатором, который является расширение пакета
@10@ захват по ссылке с инициализатором, который является расширение пакета

Если значение по умолчанию для захвата равно {{tt|&}}, последующие простые захваты не должны начинаться с {{tt|&}}.
{{source|1=
struct S2 { void f(int i); };
void S2::f(int i)
{
    [&]{};          // OK: захват по ссылке по умолчанию
    [&, i]{};       // OK: захват по ссылке, за исключением того, что i захвачена
                    // копированием
    [&, &i] {};     // Ошибка: захват по ссылке, когда по умолчанию используется ссылка
    [&, this] {};   // OK, эквивалентно [&]
    [&, this, i]{}; // OK, эквивалентно [&, i]
}
}}

Если значение по умолчанию для захвата равно {{tt|{{=}}}}, последующие простые захваты должны начинаться с {{tt|&}}{{rev inl|since=c++17| или быть {{c/core|*this}}}} {{rev inl|since=c++20|или {{c/core|this}}}}.
{{source|1=
struct S2 { void f(int i); };
void S2::f(int i)
{
    [=]{};        // OK: захват копированием по умолчанию
    [=, &i]{};    // OK: захват копированием, за исключением того, что i захвачена
                  // по ссылке
    [=, *this]{}; // до C++17: Ошибка: неверный синтаксис
                  // начиная с C++17: OK: захватывает включающую S2 копированием
    [=, this] {}; // до C++20: Ошибка: когда = по умолчанию
                  // начиная с C++20: OK, то же, что и [=]
}
}}

Любой захват может появиться только один раз, и его имя должно отличаться от любого имени параметра:
{{source|1=
struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // Ошибка: i повторяется
    [this, *this] {}; // Ошибка: "this" повторяется (C++17)
    
    [i] (int i) {};   // Ошибка: параметр и захват имеют одинаковое имя
}
}}

Только лямбда-выражения, определённые в области видимости блока или в {{rlp|data members#Инициализация элемента|инициализаторе элемента по умолчанию}}, могут иметь захват по умолчанию или захваты без инициализаторов. Для такого лямбда-выражения ''достигаемая область видимости'' определяется как набор объемлющих областей видимости вплоть до самой внутренней объемлющей функции (и её параметров) включительно. Сюда входят области видимости вложенных блоков и области видимости вложенных лямбд, если эта лямбда вложена.

{{spar|Идентификатор}} в любом захвате без инициализатора (кроме {{c/core|this}}-захвата) ищется с использованием обычного {{rlp|lookup|поиска по неполному имени}} в ''достигаемой области'' лямбды. Результатом поиска должна быть {{rlp|object|переменная}} с автоматической длительностью хранения, объявленной в области видимости достижения{{rev inl|since=c++20|, или {{rlp|structured binding|структурная привязка}}, соответствующая переменная которой соответствует таким требованиям}}. Сущность ''захвачена явно''.

{{rrev|since=c++14|
Захват с инициализатором действует так, как будто он объявляет и явно захватывает переменную, со спецификатором типа {{rlpt|auto}} и тем же инициализатором, чья декларативная область является телом лямбда-выражения (то есть она не находится в области видимости в своём инициализаторе), Кроме этого:
* если захват выполняется копированием, введённый нестатический элемент данных объекта замыкания является ещё одним способом сослаться на эту переменную;
** другими словами, исходная переменная на самом деле не существует, а определение типа через {{c/core|auto}} и инициализация применяются к нестатическому элементу данных;
* если захват осуществляется по ссылке, время жизни ссылочной переменной заканчивается, когда заканчивается время жизни объекта замыкания

Это используется для захвата типов только для перемещения с помощью захвата, такого как {{c|1=x = std::move(x)}}.

Это также позволяет захватывать константную ссылку с помощью {{c|1=&cr = std::as_const(x)}} или аналогичной конструкции.

{{source|1=
int x = 4;

auto y = [&r = x, x = x + 1]() -> int
{
    r += 2;
    return x * x;
}(); // обновляет ::x до 6 и инициализирует y до 25.
}}
}}

Если список захвата имеет значение по умолчанию и не захватывает явно включающий объект (например, {{c/core|this}} или {{c/core|*this}}) или автоматическую переменную {{rlp|definition#Использование ODR|используемую odr}} в теле лямбды{{rev inl|since=c++20| или {{rlp|structured binding|структурную привязку}}, чья соответствующая переменная имеет атомарную длительность хранения}}, он захватывает сущность ''неявно'', если сущность именована в {{rlp|expressions#Потенциально оцениваемые выражения|потенциально оцениваемом}} выражение внутри выражения (в том числе, когда неявный {{c/core|this->}} добавляется перед использованием нестатического элемента класса).

В целях определения неявных захватов {{rlpt|typeid}} никогда не считает, что его операнды не оцениваются.

{{rrev|since=c++17|
Сущности могут быть неявно захвачены, даже если они именованы в {{rlp|if#Constexpr if|отброшенном операторе}} только после создания экземпляра тела лямбда.
}}

{{source|1=
void f(int, const int (&)[2] = {}) {}   // #1
void f(const int&, const int (&)[1]) {} // #2

struct NoncopyableLiteralType
{
    constexpr explicit NoncopyableLiteralType(int n) : n_(n) {}
    NoncopyableLiteralType(const NoncopyableLiteralType&) = delete;

    int n_;
};

void test()
{
    const int x = 17;
    
    auto l0 = []{ f(x); };           // OK: вызывает #1, не захватывает x
    auto g0 = [](auto a) { f(x); };  // то же, что и выше

    auto l1 = [=]{ f(x); };          // OK: захватывает x (начиная с P0588R1) и вызывает #1
                                     // захват можно оптимизировать
    auto g1 = [=](auto a) { f(x); }; // то же, что и выше

    auto ltid = [=]{ typeid(x); };   // OK: захватывает x (начиная с P0588R1)
                                     // хотя x не оценивается
                                     // захват можно оптимизировать

    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: является зависимым выражением, поэтому захватывает x
    };
    
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // захватывает x независимо от того,
                        // является ли a + x невычисленным операндом
    };

    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: w не используется odr, захват не требуется
    // auto l5 = [=]{ return w.n_; };  // ошибка: w необходимо захватить по копии
}
}}

Если тело лямбды {{rlp|definition#Использование ODR|использует odr}} сущности, захваченной копированием, доступ осуществляется к элементу типа замыкания. Если объект не использует odr, доступ осуществляется к исходному объекту:
{{source|1=
void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // odr не используется: ссылается на const int N функции g
        f(&N); // используется odr: вызывает захват N (копированием)
               // &N это адрес элемента объекта замыкания N, не N функции g
    }();
}
}}

Если лямбда использует odr ссылки, захваченной по ссылке, она использует объект, на который ссылается исходная ссылка, а не саму захваченную ссылку:
{{example|code=
#include <iostream>

auto make_function(int& x)
{
    return [&]{ std::cout << x << '\n'; };
}

int main()
{
    int i = 3;
    auto f = make_function(i); // использование x в f напрямую связано с i
    i = 5;
    f(); // OK: печатает 5
}
}}

В теле лямбда-выражения со значением по умолчанию для захвата {{tt|1==}} тип любой захватываемой сущности такой же, как если бы она была захвачена (поэтому часто добавляется const квалификация, если лямбда не является {{c/core|mutable}}), даже если объект находится в невычисленном операнде и не захвачен (например, в {{rlpt|decltype}}):

{{source|1=
void f3()
{
    float x, &r = x;
    [=]
    { // x и r не захвачены (появление в операнде decltype не является использованием odr)
        decltype(x) y1;        // y1 имеет тип float
        decltype((x)) y2 = y1; // y2 имеет тип float const&, потому что эта лямбда
                               // не mutable, а x является lvalue
        decltype(r) r1 = y1;   // r1 имеет тип float& (преобразование не рассматривается)
        decltype((r)) r2 = y2; // r2 имеет тип float const&
    };
}
}}

Любая сущность, захваченная лямбдой (явно или неявно), используется odr лямбда-выражением (поэтому неявный захват вложенной лямбды запускает неявный захват во внешней лямбде).

Все неявно захваченные переменные должны быть объявлены в ''достигаемой области видимости'' лямбды.

Если лямбда захватывает объемлющий объект (как {{c/core|this}} или {{c/core|*this}}), либо ближайшая объемлющая функция должна быть нестатической функцией-элементом, либо лямбда-выражение должно находиться в {{rlp|data members#Инициализация элемента|инициализаторе элемента по умолчанию}}:
{{source|1=
struct s2
{
    double ohseven = .007;
    auto f() // ближайшая объемлющая функция для следующих двух лямбда-выражений
    {
        return [this]      // захватывает окружающую s2 по ссылке
        {
            return [*this] // захватывает окружающую s2 копированием (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    
    auto g()
    {
        return [] // ничего не захватывает
        { 
            return [*this]{}; // ошибка: *this не захвачен внешним лямбда-выражением
        }();
    }
};
}}

Если лямбда-выражение {{rev inl|since=c++14|(или экземпляр оператора вызова универсальной лямбда-функции)}} использует ODR {{c/core|*this}} или любой переменной с автоматической длительностью хранения, она должно быть захвачена лямбда-выражением.

{{source|1=
void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N и M не используются в odr
                         // (ok, они не захвачены)
            x[0][0] = i; // i явно захвачена лямбдой m2
                         // и неявно захвачена лямбдой m1
        };
    };

    struct s1 // локальный класс внутри f1()
    {
        int f;
        void work(int n) // нестатическая функция-элемент
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // ошибка: j не захватывается лямбдой m3
                {
                    int x = n; // ошибка: n неявно захватывается лямбдой m4
                               // но не захвачена лямбдой m3
                    x += m;    // OK: m неявно захвачена лямбдой m4
                               // и явно захвачена лямбдой m3
                    x += i;    // ошибка: i вне достижимой области видимости
                               // (которая заканчивается в work())
                    x += f;    // OK: неявно захвачена лямбдой m4
                               // и явно захвачена лямбдой m3
                };
            };
        }
    };
}
}}

Элементы класса не могут быть явно захвачены захватом без инициализатора (как упоминалось выше, в списке захвата разрешены только {{rlp|object|переменные}}):
{{source|1=
class S
{
    int x = 0;
    
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x]{ use(i, x); };    // ошибка: x не является переменной
        auto l2 = [i, x=x]{ use(i, x); };  // OK, захват копированием
        i = 1; x = 1; l2(); // вызов use(0,0)
        auto l3 = [i, &x=x]{ use(i, x); }; // OK, захват по ссылке
        i = 2; x = 2; l3(); // вызов use(1,2)
    }
};
}}

Когда лямбда-выражение захватывает элемент с помощью неявного захвата копированием, она не создаёт копию этой переменной-элемента: использование переменной-элемента {{c|m}} обрабатывается как выражение {{c/core|(*this).m}}, а {{c/core|*this}} всегда неявно захватывается по ссылке:
{{source|1=
class S
{
    int x = 0;
    
    void f()
    {
        int i = 0;
        
        auto l1 = [=]{ use(i, x); }; // захватывает копию i
                                     // и копию указателя this
        i = 1; x = 1; l1();          // вызывает use(0, 1), как если бы
                                     // i копированием, а x по ссылке
        
        auto l2 = [i, this]{ use(i, x); }; // то же, что и выше, сделано явным
        i = 2; x = 2; l2();          // вызывает use(1, 2), как если бы
                                     // i копированием, а x по ссылке
        
        auto l3 = [&]{ use(i, x); }; // захватывает i по ссылке
                                     // и копию указателя this
        i = 3; x = 2; l3();          // вызывает use(3, 2), как если бы
                                     // i и x по ссылке
        
        auto l4 = [i, *this]{ use(i, x); }; // делает копию *this,
                                            // включая копию x
        i = 4; x = 4; l4();          // вызывает use(3, 2), как если бы
                                     // i и x копированием
    }
};
}}

{{rrev|since=c++11|
Если лямбда-выражение появляется в {{rlp|default arguments|аргументе по умолчанию}}, оно не может явно или неявно захватить что-либо{{rev inl|since=c++14|, если только все захваты не имеют инициализаторов, которые соответствуют ограничениям выражения, появляющегося в аргументе по умолчанию}}:
{{source|1=
void f2()
{
    int i = 1;
    
    void g1(int = ([i]{ return i; })()); // ошибка: захватывает что-то
    void g2(int = ([i]{ return 0; })()); // ошибка: захватывает что-то
    void g3(int = ([=]{ return i; })()); // ошибка: захватывает что-то
    
    void g4(int = ([=]{ return 0; })());       // OK: без захвата
    void g5(int = ([]{ return sizeof i; })()); // OK: без захвата
    
    // C++14
    void g6(int = ([x = 1] { return x; }))(); // OK: 1 может появиться
                                              //     в аргументе по умолчанию
    void g7(int = ([x = i] { return x; }))(); // ошибка: i не может появиться
                                              //         в аргументе по умолчанию
}
}}
}}

Члены {{rlp|union|анонимных объединений}} не могут быть захвачены. {{rlp|bit field|Битовые поля}} могут быть захвачены только копированием.

Если вложенная лямбда {{c|m2}} захватывает что-то, что также захватывается непосредственно включающей лямбдой {{c|m1}}, то захват {{c|m2}} преобразуется следующим образом:
* если объемлющая лямбда {{c|m1}} захватывает копированием, {{c|m2}} захватывает нестатический элемент типа замыкания {{c|m1}}, а не исходную переменную или {{c/core|*this}}; если {{c|m1}} не является mutable, нестатический элемент данных считается константным.
* если объемлющая лямбда {{c|m1}} захватывает по ссылке, {{c|m2}} захватывает исходную переменную или {{c/core|*this}}.
{{example
|code=
#include <iostream>

int main()
{
    int a = 1, b = 1, c = 1;
    
    auto m1 = [a, &b, &c]() mutable
    {
        auto m2 = [a, b, &c]() mutable
        {
            std::cout << a << b << c << '\n';
            a = 4; b = 4; c = 4;
        };
        a = 3; b = 3; c = 3;
        m2();
    };
    
    a = 2; b = 2; c = 2;

    m1();                             // вызывает m2() и печатает 123
    std::cout << a << b << c << '\n'; // печатает 234
}
}}

===Примечание===
{{ftm begin|core=1|std=1|comment=1|sort=1}}
{{ftm|value=200907L|std=C++11|__cpp_lambdas|Лямбда-выражения}}
{{ftm|value=201304L|std=C++14|__cpp_generic_lambdas|Общие лямбда-выражения|rowspan="2"}}
{{ftm|value=201707L|std=C++20|-|Явный список параметров шаблона для общих лямбда-выражений}}
{{ftm|value=201304L|std=C++14|__cpp_init_captures|Захват инициализации лямбда|rowspan="2"}}
{{ftm|value=201803L|std=C++20|-|Разрешить расширение пакета в захвате инициализации лямбда}}
{{ftm|value=201603L|std=C++17|__cpp_capture_star_this|Лямбда-захват {{c/core|*this}} по значению как {{c/core|1=[=, *this]}}}}
{{ftm|value=201603L|std=C++17|__cpp_constexpr|Лямбда {{c/core|constexpr}}}}
{{ftm|value=202207L|std=C++23|__cpp_static_call_operator|static {{c/core|operator()}} для лямбда-выражений без захвата}}
{{ftm end}}

Правило неявного захвата лямбда-выражений немного изменено в отчете о дефекте {{wg21|P0588R1}}. По состоянию на 2023-10 некоторые основные реализации не полностью реализовали DR, и поэтому старое правило, которое обнаруживает [[cpp/language/definition#ODR-use|использование odr]], всё ещё используется в некоторых случаях.

{{cot|Старое правило до P0588R1}}
Если список захвата имеет значение по умолчанию и не захватывает явно включающий объект (например, {{c/core|this}} или {{c/core|*this}}) или автоматическую переменную, которая {{rlp|definition#Использование ODR|используется odr}} в теле лямбды{{rev inl|since=c++20|, или {{rlp|structured binding|структурную привязку}}, чья соответствующая переменная имеет атомарную длительность хранения}}, он захватывает сущность ''неявно'', если сущность
{{rrev|since=c++14|
* имя в {{rlp|expressions#Потенциально вычисляемые выражения|потенциально вычисляемом}} выражении внутри выражения, которое зависит от параметра шаблона универсальной лямбды, или
}}
* {{rlp|definition#Использование ODR|использует odr}} телом лямбды.
{{cob}}

===Пример===
{{example
|В этом примере показано, как передать лямбда-выражение универсальному алгоритму и как объекты, полученные в результате лямбда-выражения, могут быть сохранены в объектах {{lc|std::function}}.
|code=
#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>

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: ";
    std::for_each(c.begin(), c.end(), [](int i){ std::cout << i << ' '; });
    std::cout << '\n';

    // тип замыкания не может быть именован, но может быть выведен с помощью auto
    // начиная с C++14, лямбда может иметь аргументы по умолчанию
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';

    // как и все вызываемые объекты, замыкания могут быть захвачены в std::function
    // (это может привести к ненужным накладным расходам)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';

    constexpr int fib_max {8};
    std::cout << "Эмулирует `рекурсивные лямбда` вызовы:\nчисла Фибоначчи: ";
    auto nth_fibonacci = [](int n)
    {
        std::function<int(int, int, int)> fib = [&](int n, int a, int b)
        {
            return n ? fib(n - 1, a + b, a) : b;
        };
        return fib(n, 0, 1);
    };

    for (int i{1}; i <= fib_max; ++i)
    {
        std::cout << nth_fibonacci(i) << (i < fib_max ? ", " : "\n");
    }

    std::cout << "Альтернативный подход к лямбда-рекурсии:\nчисла Фибоначчи: ";
    auto nth_fibonacci2 = [](auto self, int n, int a = 0, int b = 1) -> int
    {
        return n ? self(self, n - 1, a + b, a) : b;
    };

    for (int i{1}; i <= fib_max; ++i)
    {
        std::cout << nth_fibonacci2(nth_fibonacci2, i) << (i < fib_max ? ", " : "\n");
    }

#ifdef __cpp_explicit_this_parameter
    std::cout << "С++23 подход к лямбда-рекурсии:\n";
    auto nth_fibonacci3 = [](this auto self, int n, int a = 0, int b = 1) -> int
    {
         return n ? self(n - 1, a + b, a) : b;
    };

    for (int i{1}; i <= fib_max; ++i)
    {
        std::cout << nth_fibonacci3(i) << (i < fib_max ? ", " : "\n");
    }
#endif
}
|p=true
|output=
c: 5 6 7
func1: 10
func2: 10
Эмулирует `рекурсивные лямбда` вызовы:
числа Фибоначчи: 0, 1, 1, 2, 3, 5, 8, 13
Альтернативный подход к лямбда-рекурсии:
числа Фибоначчи: 0, 1, 1, 2, 3, 5, 8, 13
}}

===Отчёты о дефектах===
{{dr list begin}}
{{dr list item|wg=cwg|dr=974|std=C++11|before=аргумент по умолчанию не был разрешён в списке параметров<br>лямбда-выражения|after=разрешён}}
{{dr list item|wg=cwg|dr=975<!-- фактическое разрешение в N3638 -->|std=C++11|before=возвращаемый тип замыкания {{c/core|operator()}} выводился только в<br>том случае, если тело лямбды содержит один return|after=выводится, как если бы для функции<br>возврата auto С++14}}
{{dr list item|wg=cwg|dr=1249|std=C++11|before=неясно, считается ли захваченный элемент объемлющей не<br>mutable лямбды {{c/core|const}} или нет|after=считается {{c/core|const}}}}
{{dr list item|wg=cwg|dr=1557|std=C++11|before=языковое связывание возвращаемого типа функции<br>преобразования типа замыкания не была указана|after=он имеет языковое связывание C++}}
{{dr list item|wg=cwg|dr=1607|std=C++11|before=лямбда-выражения могут появляться в сигнатурах функций и<br>шаблонах функций|after=не разрешено}}
{{dr list item|wg=cwg|dr=1612|std=C++11|before=элементы анонимных объединений могут быть захвачены|after=не разрешено}}
{{dr list item|wg=cwg|dr=1722|std=C++11|before=функция преобразования для лямбда-выражений без захвата<br>имела неуказанную спецификацию исключений|after=функция преобразования является noexcept}}
{{dr list item|wg=cwg|dr=1772|std=C++11|before=семантика {{c|__func__}} в теле лямбда была неясна|after=он относится к замыканию operator() класса}}
{{dr list item|wg=cwg|dr=1780|std=C++14|before=было неясно, могут ли элементы типов замыкания общих<br>лямбда-выражений быть явно созданы или явно<br>специализированы|after=ни то, ни другое не разрешено}}
{{dr list item|wg=cwg|dr=1891|std=C++11|before=замыкание имело удалённый конструктор по умолчанию и<br>неявные конструкторы копирования/перемещения|after=нет удалённого конструктора по умолчанию<br>и конструкторов копирования/перемещения<br>по умолчанию}}
{{dr list item|wg=cwg|dr=1937|std=C++11|before=что касается эффекта вызова результата функции<br>преобразования, не было указано, какой объект, вызывающий<br>свой operator(), имеет тот же эффект|after=на построенном по умолчанию экземпляре<br>типа замыкания}}
{{dr list item|wg=cwg|dr=1973|std=C++11|before=список параметров {{c/core|operator()}} типа замыкания может<br>ссылаться на список параметров, указанный в {{spar|конечном-типе}}|after=может ссылаться только на {{spar|параметры}}}}
{{dr list item|wg=cwg|dr=2011|std=C++11|before=для ссылки, захваченной по ссылке, не было указано, к какому<br>объекту относится идентификатор захвата|after=он относится к первоначально упомянутому<br>объекту}}
{{dr list item|wg=cwg|dr=2095|std=C++11|before=поведение захвата копированием ссылок rvalue на функции<br>было неясным|after=сделано ясным}}
{{dr list item|wg=cwg|dr=2211|std=C++11|before=поведение было неопределённым, если захват имеет то же имя,<br>что и параметр|after=в этом случае программа некорректна}}
{{dr list item|wg=cwg|dr=2358|std=C++14|before=лямбда-выражения, появляющиеся в аргументах по умолчанию,<br>должны были быть без захвата, даже если все захваты<br>инициализируются выражениями, которые могут появляться в<br>аргументах по умолчанию|after=такие лямбда-выражения с захватами<br>разрешены}}
{{dr list item|wg=cwg|dr=2509|std=C++17|before=каждый спецификатор может иметь несколько вхождений в<br>последовательности спецификаторов|after=каждый спецификатор может появляться не<br>более одного раза в последовательности<br>спецификаторов<!-- Примечание. В синтаксисе C++11/14 не используется последовательность-спецификаторов-объявления, потому что тогда единственным разрешённым спецификатором был 'mutable' -->}}
{{dr list item|wg=cwg|dr=2542|std=C++11|before=было неясно, является ли тип замыкания структурным|after=он не структурный}}
{{dr list item|paper=P0588R1|std=C++11|before=правило неявного захвата лямбда-выражений обнаруживает<br>использование odr|after=обнаружение упрощено}}
{{dr list end}}

===Смотрите также===
{{dsc begin}}
{{dsc inc|cpp/language/dsc auto}}
{{dsc inc|cpp/utility/functional/dsc function}}
{{dsc inc|cpp/utility/functional/dsc move_only_function}}
{{dsc end}}

===Внешние ссылки===
{{eli|{{enwiki|Nested function|Вложенная функция}} - функция, которая определена внутри другой (''включающей'') функции.}}

{{langlinks|de|en|es|fr|it|ja|pt|zh}}
Шаблоны, используемые на этой странице:
Возврат к странице cpp/language/lambda.
cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Просмотр кода страницы cpp/language/lambda

Навигация

Инструменты
