Указатель на лямбда функцию c
Добавил пользователь Дмитрий К. Обновлено: 19.09.2024
В данной статье приводится описание методов использования лямбда-выражений в программах. Общие сведения о лямбда-выражениях см. в разделе лямбда-выражения. Дополнительные сведения о структуре лямбда-выражения см. в разделе синтаксис лямбда-выражения.
Объявление лямбда-выражений
Пример 1
Поскольку лямбда-выражение типизировано, его auto можно назначить переменной или function объекту, как показано ниже:
В примере получается следующий результат.
Remarks
Дополнительные сведения см. в разделе auto , function класси вызов функции.
Хотя лямбда-выражения чаще всего объявляются в теле функции, можно объявлять их в любом месте, где можно инициализировать переменные.
Пример 2
Компилятор Microsoft C++ привязывает лямбда-выражение к захваченным переменным при объявлении выражения, а не при вызове выражения. В следующем примере содержится лямбда-выражение, которое фиксирует локальную переменную i по значению, а локальную переменную j — по ссылке. Поскольку лямбда-выражение захватывает i по значению, переопределение i далее в программе не влияет на результат выражения. Однако, поскольку лямбда-выражение захватывает j по ссылке, переопределение j влияет на результат выражения.
В примере получается следующий результат.
Вызов лямбда-выражений
Можно вызывать лямбда-выражение сразу же, как показано в следующем фрагменте кода. Во втором фрагменте показано, как передать лямбда-выражение в качестве аргумента в алгоритмы стандартной библиотеки C++, такие как find_if .
Пример 1
В этом примере объявляется лямбда-выражение, которое возвращает сумму двух целых чисел и сразу же вызывает выражение с аргументами 5 и 4 .
В примере получается следующий результат.
Пример 2
В этом примере лямбда-выражение передается в качестве аргумента функции find_if . Лямбда-выражение возвращает true значение, если его параметр имеет четное число.
В примере получается следующий результат.
Remarks
Дополнительные сведения о функции см. в find_if разделе find_if . Дополнительные сведения о функциях стандартной библиотеки C++, которые выполняют стандартные алгоритмы, см. в разделе .
Вложение лямбда-выражений
Пример
Можно вложить одно лямбда-выражение в другое, как показано в следующем примере. Внутреннее лямбда-выражение умножает его аргумент на 2 и возвращает результат. Внешнее лямбда-выражение вызывает внутреннее лямбда-выражение с использованием его аргумента и добавляет к результату 3.
В примере получается следующий результат.
Remarks
В этом примере значение параметра [](int y) < return y * 2; >является вложенным лямбда-выражением.
Лямбда-функции высшего порядка
Пример
Многие языки программирования поддерживают концепцию функции более высокого порядка. Функция более высокого порядка — это лямбда-выражение, которое принимает другое лямбда-выражение в качестве аргумента или возвращает лямбда-выражение. Класс можно использовать function , чтобы разрешить лямбда-выражение C++ работать как функция высшего порядка. В следующем примере показано лямбда-выражение, которое возвращает объект function , и лямбда-выражение, которое принимает объект function в качестве аргумента.
В примере получается следующий результат.
Использование лямбда-выражения в функции
Пример
Лямбда-выражения можно использовать в теле функции. Лямбда-выражение может получать доступ к любой функции или данным-членам, которые способна использовать включающая функция. Можно явно или неявно захватывать this указатель, чтобы предоставить доступ к функциям и элементам данных включающего класса. Visual Studio 2017 версии 15,3 и более поздних версий (доступно в /std:c++17 и более поздних версиях): захват this по значению ( [*this] ), если лямбда-выражение будет использоваться в асинхронных или параллельных операциях, где код может выполняться после того, как исходный объект выходит из области действия.
Указатель можно использовать this явно в функции, как показано ниже:
Кроме того, this указатель можно захватывать неявно:
В следующем примере показан класс Scale , который инкапсулирует значение масштаба.
В примере получается следующий результат.
Remarks
Функция ApplyScale использует лямбда-выражение для выведения произведения масштаба на каждый элемент объекта vector . Лямбда-выражение неявно захватывает this , чтобы он мог получить доступ к _scale элементу.
Использование лямбда-выражения с шаблонами
Пример
Поскольку лямбда-выражения имеют тип, их можно использовать с шаблонами C++. В следующем примере показаны функции negate_all и print_all . negate_all Функция применяет унарный operator- к каждому элементу в vector объекте. Функция print_all печатает каждый элемент в объекте vector в консоли.
В примере получается следующий результат.
Remarks
Дополнительные сведения о шаблонах C++ см. в разделе шаблоны.
Обработка исключений
Пример
Тело лямбда-выражения выполняет правила как для структурированной обработки исключений (SEH), так и для обработки исключений C++. Можно обработать возникшее исключение в теле лямбда-выражения или перенести обработку исключения во включающий фрагмент. В следующем примере используется for_each функция и лямбда-выражение для заполнения vector объекта значениями другого. Он использует try / catch блок для управления недопустимым доступом к первому вектору.
В примере получается следующий результат.
Remarks
Дополнительные сведения об обработке исключений см. в разделе обработка исключений.
Использование лямбда-выражений с управляемыми типами (C++/CLI)
Пример
Предложение захвата лямбда-выражения не может содержать переменную, которая имеет управляемый тип. Однако можно передать аргумент с управляемым типом в список параметров лямбда-выражения. В следующем примере содержится лямбда-выражение, которое захватывает локальную неуправляемую переменную ch по значению и принимает объект System.String в качестве параметра.
В примере получается следующий результат.
Remarks
Можно также использовать лямбда-выражения с библиотекой STL/CLR. Дополнительные сведения см. в разделе Справочник по библиотеке STL/CLR.
Лямбда-выражения не поддерживаются в следующих управляемых сущностях среды CLR: ref class , ref struct , value class и value struct .
По роду деятельности мне часто приходится иметь дело с вычислительными задачами. В них нередко нужно передавать указатель на функцию, чтобы, например, построить график этой функции, или решить уравнение. Кроме того, указатели на функцию обычно используются в различных GUI фреймворках, чтобы указать, какое действие будет совершено при нажатии на определённую кнопку.
В новом стандарте C++0x появились зымыкания. Не вдаваясь в подробности, замыкания — это такие объекты, которые позволяют создавать функции прямо в теле других функций. Если подробнее — замыкания позволяют создавать функциональные объекты — то есть объекты, для которых определён operator(). На хабре уже писали о них: например тут.
Мне очень понравилось нововведение и я начал им пользоваться. Но только вот незадача: по смыслу, замыкания и функции — почти одно и то же, а использовать замыкания там, где должны использоваться указатели на функции, сходу не получается. По стандарту, замыкания без списка захвата должны свободно конвертироваться в указатели на функции, но на практике такого не наблюдалось, видимо ещё не реализовано. И я задался вопросом, можно ли использовать замыкания там, где используются указатели на функции?
Рассмотрим пример. Пусть у нас уже есть функция printFunctionTable, которая позволяет распечатать таблицу значений функции, при этом аргумент пробегает значения от 1 до 10.
Конечно мы могли бы переписать эту функцию сразу под замыкания, а не под указатели на функции, но такая функция может быть расположена в закрытой библиотеке (как чаще всего и бывает), поэтому будем искать способ конвертации одного в другое.
Так же определим функцию, значения которой нам нужно распечатать:
Не выходит — при компиляции — ошибка! Конечно — типы то — разные!
Как же нам это обойти? На помощь нам придут шаблоны.
Тут мы определили шаблон функции, параметризованный типом CL — то есть типом нашего замыкания. Всё что нам нужно от нашего замыкания — вызвать его и вернуть значение.
Теперь можно использовать замыкание в том месте, где мы раньше использовали указатель на функцию. Выглядеть это будет так:
Для справки: decltype — это новое ключевое слово в C++0x, позволяющее определить тип выражения, то есть, в данном случае — тип нашего замыкания cube.
Вот собственно и всё — задача решена, теперь мы можем в удобном виде определять функции для каких-то действий прямо по ходу текста программы, а не скакать туда-сюда по исходнику, чтобы оформлять эти действия в отдельные функции.
Дополнительно хочется отметить, что мы создали только шаблон для сигнатуры int(int). По мере надобности можно добавлять и другие сигнатуры — double(int,double) к примеру, итд. Также, для удобства можно сделать макрос
P.S. Тестировалось на компиляторе Intel C++ Compiler 11.1, по идее, должно работать в g++ 4.5 и в visual studio 2010, главное не забыть проставить при компиляции флаги, позволяющие использовать c++0x.
Лямбда-выражения являются одним из наиболее мощных дополнений в C++11 и продолжают развиваться с каждым новым стандартом языка. В этой статье мы пройдемся по их истории и посмотрим на эволюцию этой важной части современного C++.
Вторая часть доступна по ссылке:
Lambdas: From C++11 to C++20, Part 2
Вступление
Я решил взять код у Томаса (с его разрешения!), описать его и создать отдельную статью.
Мы начнем с изучения C++03 и с необходимости в компактных локальных функциональных выражениях. Затем мы перейдем к C++11 и C++14. Во второй части серии мы увидим изменения в C++17 и даже взглянем на то, что произойдет в C++ 20.
С самого начала STL std::algorithms , такие как std::sort , могли принимать любой вызываемый объект и вызывать его для элементов контейнера. Однако в C++03 это предполагало только указатели на функции и функторы.
Но проблема заключалась в том, что вы должны были написать отдельную функцию или функтор в другой области видимости, а не в области видимости вызова алгоритма.
В качестве потенциального решения вы могли бы подумать о написании локального класса функторов — поскольку C++ всегда поддерживает этот синтаксис. Но это не работает…
Посмотрите на этот код:
Попробуйте скомпилировать его с -std=c++98 , и вы увидите следующую ошибку в GCC:
Если мы посмотрим на N3337 — окончательный вариант C++11, то увидим отдельный раздел для лямбд: [expr.prim.lambda].
Далее к C++11
Вот базовый пример кода, который также показывает соответствующий объект локального функтора:
Вы также можете проверить CppInsights, который показывает, как компилятор расширяет код:
Посмотрите на этот пример:
В этом примере компилятор преобразует:
Во что-то похожее на это (упрощенная форма):
Некоторые определения, прежде чем мы начнем:
Вычисление лямбда-выражения приводит к временному prvalue. Этот временный объект называется объектом-замыканием (closure object).
Тип лямбда-выражения (который также является типом объекта-замыкания) является уникальным безымянным non-union типом класса, который называется типом замыкания (closure type).
Несколько примеров лямбда-выражений:
Поскольку компилятор генерирует уникальное имя для каждой лямбды, узнать его заранее не представляется возможным.
Более того [expr.prim.lambda]:
Тип замыкания, связанный с лямбда-выражением, имеет удаленный ([dcl.fct.def.delete]) конструктор по умолчанию и удаленный оператор присваивания.
Поэтому вы не можете написать:
Это приведет к следующей ошибке в GCC:
Оператор вызова
По умолчанию это встроенный константный метод. Вы можете изменить его, указав mutable после объявления параметров:
Захватив переменную, вы создаете член-копию этой переменной в типе замыкания. Затем внутри тела лямбды вы можете получить к нему доступ.
- [&] — захват по ссылке, все переменные в автоматическом хранилище объявлены в области охвата
- [=] — захват по значению, значение копируется
- [x, & y] — явно захватывает x по значению, а y по ссылке
Вы можете поиграться с полным примером здесь: @Wandbox
Хотя указание [=] или [&] может быть удобно — поскольку оно захватывает все переменные в автоматическом хранилище, более очевидно захватывать переменные явно. Таким образом, компилятор может предупредить вас о нежелательных эффектах (см., например, примечания о глобальных и статических переменных)
И важная цитата:
По умолчанию operator() типа замыкания является константным, и вы не можете изменять захваченные переменные внутри тела лямбда-выражения.
Если вы хотите изменить это поведение, вам нужно добавить ключевое слово mutable после списка параметров:
В приведенном выше примере мы можем изменить значения x и y… но это только копии x и y из прилагаемой области видимости.
Захват глобальных переменных
Если у вас есть глобальное значение, а затем вы используете [=] в лямбде, вы можете подумать, что глобальное значение также захвачено по значению… но это не так.
Поиграть с кодом можно здесь: @Wandbox
Захватываются только переменные в автоматическом хранилище. GCC может даже выдать следующее предупреждение:
Это предупреждение появится только в том случае, если вы явно захватите глобальную переменную, поэтому, если вы используете [=] , компилятор вам не поможет.
Компилятор Clang более полезен, так как генерирует ошибку:
Захват статических переменных
Захват статических переменных аналогичен захвату глобальных:
Поиграть с кодом можно здесь: @Wandbox
И снова, предупреждение появится, только если вы явно захватите статическую переменную, поэтому, если вы используете [=] , компилятор вам не поможет.
Захват члена класса
Знаете ли вы, что произойдет после выполнения следующего кода:
Код объявляет объект Baz, а затем вызывает foo() . Обратите внимание, что foo() возвращает лямбду (хранящуюся в std::function ), которая захватывает член класса.
Поскольку мы используем временные объекты, мы не можем быть уверены, что произойдет, при вызове f1 и f2. Это проблема висячих ссылок, которая порождает неопределенное поведение.
Опять же, если вы укажете захват явно ([s]):
Компилятор предотвратит вашу ошибку:
Move-able-only объекты
Если у вас есть объект, который может быть только перемещен (например, unique_ptr), то вы не можете поместить его в лямбду в качестве захваченной переменной. Захват по значению не работает, поэтому вы можете захватывать только по ссылке… однако это не передаст его вам во владение, и, вероятно, это не то, что вы хотели.
Сохранение констант
Если вы захватываете константную переменную, то константность сохраняется:
Возвращаемый тип
В C++11 вы можете пропустить trailing возвращаемый тип лямбды, и тогда компилятор выведет его за вас.
Первоначально вывод возвращаемого типа значения был ограничен лямбдами, содержащими один оператор return, но это ограничение было быстро снято, поскольку не было проблем с реализацией более удобной версии.
Таким образом, начиная с C++11, компилятор может вывести тип возвращаемого значения, если все операторы return могут быть преобразованы в один и тот же тип.
Если все операторы return возвращают выражение и типы возвращаемых выражений после преобразования lvalue-to-rvalue (7.1 [conv.lval]), array-to-pointer (7.2 [conv.array]) и function-to-pointer (7.3 [conv.func]) такое же, как у общего типа;
Поиграться с кодом можно здесь: @Wandbox
В вышеприведенной лямбде есть два оператора return , но все они указывают на double , поэтому компилятор может вывести тип.
IIFE — Немедленно вызываемые выражения (Immediately Invoked Function Expression)
В наших примерах я определял лямбду, а затем вызвал ее, используя объект замыкания… но ее также можно вызывать немедленно:
Такое выражение может быть полезно при сложной инициализации константных объектов.
Преобразование в указатель на функцию
Тип замыкания для лямбда-выражения без захвата имеет открытую невиртуальную неявную функцию преобразования константы в указатель на функцию, имеющую тот же параметр и возвращаемые типы, что и оператор вызова функции типа замыкания. Значение, возвращаемое этой функцией преобразования, должно быть адресом функции, которая при вызове имеет тот же эффект, что и вызов оператора функции типа сходного с типом замыкания.
Другими словами, вы можете преобразовывать лямбды без захватов в указатель на функцию.
Поиграться с кодом можно здесь: @Wandbox
Улучшения в C++14
C++14 добавил два значительных улучшения в лямбда-выражения:
- Захваты с инициализатором
- Общие лямбды
Возвращаемый тип
Вывод типа возвращаемого значения лямбда-выражения был обновлен, чтобы соответствовать правилам автоматического вывода для функций.
Возвращаемый тип лямбды — auto, который заменяется trailing возвращаемым типом, если он предоставляется и/или выводится из операторов возврата, как описано в [dcl.spec.auto].
Захваты с инициализатором
Короче говоря, мы можем создать новую переменную-член типа замыкания и затем использовать ее внутри лямбда-выражения.
Это может решить несколько проблем, например, с типами, доступными только для перемещения.
Перемещение
Теперь мы можем переместить объект в член типа замыкания:
Оптимизация
Другая идея состоит в том, чтобы использовать его как потенциальную технику оптимизации. Вместо того, чтобы вычислять какое-то значение каждый раз, когда мы вызываем лямбду, мы можем вычислить его один раз в инициализаторе:
Захват переменной-члена
Инициализатор также можно использовать для захвата переменной-члена. Затем мы можем получить копию переменной-члена и не беспокоиться о висячих ссылках.
Поиграться с кодом можно здесь: @Wandbox
В foo() мы захватываем переменную-член, копируя ее в тип замыкания. Кроме того, мы используем auto для вывода всего метода (ранее, в C++11 мы могли использовать std::function ).
Обобщенные лямбда-выражения
Еще одно существенное улучшение — это обобщенная лямбда.
Начиная с C++14 можно написать:
Это эквивалентно использованию объявления шаблона в операторе вызова типа замыкания:
Такая обобщенная лямбда может быть очень полезна, когда трудно вывести тип.
В этой статье мы начали с первых дней лямбда-выражений в C++03 и C++11 и перешли к улучшенной версии в C++14.
Вы увидели, как создавать лямбду, какова основная структура этого выражения, что такое список захвата и многое другое.
В следующей части статьи мы перейдем к C++17 и познакомимся с будущими фичами C++20.
Вторая часть доступна здесь:
В C++ 11 и более поздних версиях лямбда-выражение, часто называемое лямбда– — это удобный способ определения объекта анонимной функции ( замыкания) непосредственно в расположении, где оно вызывается или передается в качестве аргумента функции. Обычно лямбда-выражения используются для инкапсуляции нескольких строк кода, передаваемых алгоритмам или асинхронным функциям. В этой статье определяются лямбда-выражения и их сравнение с другими методами программирования. Он описывает их преимущества и предоставляет некоторые основные примеры.
Похожие статьи
Части лямбда-выражения
В стандарте ISO C++ демонстрируется простое лямбда-выражение, передаваемое функции std::sort() в качестве третьего аргумента:
На следующем рисунке показана структура лямбда-выражения:
предложение Capture (также известное как оператор лямбда-выражения в спецификации C++).
список параметров Используемых. (Также называется лямбда-объявлением)
изменяемая спецификация Используемых.
Спецификация Exception Используемых.
замыкающий-возвращаемый тип Используемых.
Предложение Capture
Лямбда-выражение может добавлять новые переменные в тексте (в C++ 14), а также получать доступ к переменным из окружающей области или записыватьих. Лямбда-выражение начинается с предложения Capture. Он указывает, какие переменные фиксируются, а также указывает, является ли запись по значению или по ссылке. Доступ к переменным с префиксом амперсанда ( & ) осуществляется по ссылке и к переменным, к которым нет доступа по значению.
Пустое предложение фиксации ( [ ] ) показывает, что тело лямбда-выражения не осуществляет доступ к переменным во внешней области видимости.
Можно использовать режим захвата по умолчанию, чтобы указать, как фиксировать все внешние переменные, упоминаемые в теле лямбда-выражения: [&] означает, что все переменные, на которые вы ссылаетесь, захватываются по ссылке, а [=] значит, они записываются по значению. Можно сначала использовать режим фиксации по умолчанию, а затем применить для определенных переменных другой режим. Например, если тело лямбда-выражения осуществляет доступ к внешней переменной total по ссылке, а к внешней переменной factor по значению, следующие предложения фиксации эквивалентны:
При использовании записи по умолчанию фиксируются только те переменные, которые упоминаются в теле лямбда-выражения.
Если предложение Capture включает запись-Default & , то ни один идентификатор в записи этого предложения записи не может иметь форму &identifier . Аналогично, если предложение Capture включает запись по умолчанию = , то ни один из этих предложений не может иметь форму =identifier . Идентификатор или this не может использоваться в предложении Capture более одного раза. В следующем фрагменте кода показаны некоторые примеры.
Захват, за которым следует многоточие, — это расширение пакета, как показано в следующем примере шаблона Variadic :
Чтобы использовать лямбда-выражения в теле функции члена класса, передайте this указатель в предложение Capture, чтобы предоставить доступ к функциям и членам данных включающего класса.
Visual Studio 2017 версии 15,3 и более поздних версий (доступно в /std:c++17 режиме и более поздних версиях): this указатель может быть записан по значению путем указания *this в предложении capture. Захват по значению копирует весь замыкание на каждый узел вызова, где вызывается лямбда-выражение. (Замыканием является объект анонимной функции, инкапсулирующий лямбда-выражение.) Захват по значению полезен, когда лямбда выполняется в параллельных или асинхронных операциях. Это особенно полезно на некоторых аппаратных архитектурах, таких как NUMA.
Пример, демонстрирующий использование лямбда-выражений с функциями членов класса, см. в разделе "пример: использование лямбда-выражения в методе" в примерах лямбда-выражений.
При использовании предложения Capture рекомендуется учитывать такие моменты, особенно при использовании лямбда-выражений с многопоточностью:
Захваты ссылок можно использовать для изменения переменных вне, но захваты значений не могут. ( mutable позволяет изменять копии, но не оригиналы.)
Захват ссылок отражает обновления переменных вне, но не фиксирует значения.
Фиксация ссылки вводит зависимость от времени существования, тогда как фиксация значения не обладает зависимостями от времени существования. Это особенно важно при асинхронном выполнении лямбда-выражения. Если вы захватываете локальную по ссылке в асинхронном лямбда-выражении, это локально может быть легко пропала в момент выполнения лямбда-выражения. Код может вызвать нарушение прав доступа во время выполнения.
Обобщенная фиксация (C++14)
В C++14 вы можете объявлять и инициализировать новые переменные в предложении фиксации. Для этого не требуется, чтобы эти переменные существовали во внешней области видимости лямбда-функции. Инициализация может быть выражена в качестве любого произвольного выражения. Тип новой переменной определяется типом, который создается выражением. Эта функция позволяет собирать переменные только для перемещения (например, std::unique_ptr ) из окружающей области и использовать их в лямбда-выражении.
Список параметров
Лямбда-выражения могут записывать переменные и принимать входные параметры. Список параметров (лямбда-декларатор в стандартном синтаксисе) является необязательным и в большинстве аспектов напоминает список параметров для функции.
В C++ 14, если тип параметра является универсальным, можно использовать auto ключевое слово в качестве спецификатора типа. Это ключевое слово указывает компилятору создать оператор вызова функции в качестве шаблона. Каждый экземпляр auto в списке параметров эквивалентен отдельному параметру типа.
Поскольку список параметров является необязательным, можно опустить пустые скобки, если аргументы не передаются в лямбда-выражение и его лямбда-декларатор не содержит спецификацию Exception, завершающего-Return-Typeили mutable .
Изменяемая спецификация
Как правило, оператор вызова функции лямбда-выражения является константой по значению, но использование mutable ключевого слова отменяет это. Он не создает изменяемых элементов данных. mutable Спецификация позволяет тексту лямбда-выражения изменять переменные, захваченные по значению. В некоторых примерах, приведенных далее в этой статье, показано, как использовать mutable .
Спецификация исключений
Можно использовать noexcept спецификацию исключения, чтобы указать, что лямбда-выражение не создает никаких исключений. Как и в случае с обычными функциями, компилятор Microsoft C++ создает предупреждение C4297 , если лямбда-выражение объявляет noexcept спецификацию исключения, а тело лямбда-выражения создает исключение, как показано ниже:
Дополнительные сведения см. в разделе спецификации исключений (throw).
Возвращаемый тип
Возвращаемый тип лямбда-выражения выводится автоматически. Не обязательно использовать ключевое слово, auto если не указан завершающий возвращаемый тип. Замыкающий возвращаемый тип напоминает часть функции, возвращающей возвращаемый тип, и функцию-член. Однако тип возвращаемого значения следует списку параметров, и необходимо включить ключевое слово -> элемента trailing-return-type перед типом возвращаемого значения.
Можно опустить часть возвращаемого типа лямбда-выражения, если тело лямбды содержит только один оператор return. Или, если выражение не возвращает значение. Если тело лямбда-выражения содержит один оператор return, компилятор выводит тип возвращаемого значения из типа возвращаемого выражения. В противном случае компилятор выводит тип возвращаемого значения как void . Рассмотрим следующие примеры фрагментов кода, иллюстрирующих этот принцип:
Лямбда-выражение может создавать другое лямбда-выражение в качестве своего возвращаемого значения. Дополнительные сведения см. в разделе "лямбда-выражения более высокого порядка" в примерах лямбда-выражений.
Тело лямбды
Тело лямбда-выражения является составным оператором. Он может содержать все, что разрешено в теле обычной функции или функции-члена. Тело обычной функции и лямбда-выражения может осуществлять доступ к следующим типам переменных:
Фиксированные переменные из внешней области видимости (см. выше).
Локально объявленные переменные.
Члены данных класса, объявленные внутри класса и this захваченные.
Любая переменная, имеющая статическую длительность хранения, например глобальные переменные.
В следующем примере содержится лямбда-выражение, которое явно фиксирует переменную n по значению и неявно фиксирует переменную m по ссылке.
Поскольку переменная n фиксируется по значению, ее значение после вызова лямбда-выражения остается равным 0 . mutable Спецификацию n можно изменить в лямбда-выражении.
Лямбда-выражение может записывать только переменные с автоматическим длительностью хранения. Однако можно использовать переменные со статической длительностью хранения в теле лямбда-выражения. В следующем примере функция generate и лямбда-выражение используются для присвоения значения каждому элементу объекта vector . Лямбда-выражение изменяет статическую переменную для получения значения следующего элемента.
Дополнительные сведения см. в разделе Generate.
В следующем примере кода используется функция из предыдущего примера и добавляется пример лямбда-выражения, использующего алгоритм generate_n стандартной библиотеки C++. Это лямбда-выражение назначает элемент объекта vector сумме предыдущих двух элементов. mutable Ключевое слово используется, чтобы тело лямбда-выражения может изменить свои копии внешних переменных x и y , которое захватывает лямбда-выражение по значению. Поскольку лямбда-выражение захватывает исходные переменные x и y по значению, их значения остаются равными 1 после выполнения лямбда-выражения.
Дополнительные сведения см. в разделе generate_n.
constexpr лямбда-выражения
Visual Studio 2017 версии 15,3 и более поздних версий (доступно в /std:c++17 режиме и более поздних версиях): лямбда-выражение можно объявить как constexpr (или использовать его в константном выражении), если инициализация каждого захваченного или введенного элемента данных разрешена в константном выражении.
Лямбда-выражение неявно constexpr , если его результат удовлетворяет требованиям constexpr функции:
Если лямбда-выражение неявно или неявное constexpr , то преобразование в указатель функции создает constexpr функцию:
Специально для систем Майкрософт
Лямбда-выражения не поддерживаются в следующих управляемых сущностях среды CLR: ref class , ref struct , value class или value struct .
Если вы используете модификатор, зависящий от Майкрософт, например __declspec , его можно вставить в лямбда-выражение сразу после parameter-declaration-clause . Например:
Чтобы определить, поддерживается ли определенный модификатор лямбда-выражениями, см. статью об модификаторе в разделе модификаторы, относящиеся к Microsoft .
Visual Studio поддерживает стандартную лямбда-функцию c++ 11 и лямбда-выражения без отслеживания состояния. Лямбда без отслеживания состояния преобразуется в указатель функции, который использует произвольное соглашение о вызовах.
В этой статье демонстрируется синтаксис и структурные элементы лямбда-выражений. Описание лямбда-выражений см. в разделе лямбда-выражения.
Объекты функций и лямбда-выражения
При написании кода вы, вероятно, используете указатели функций и объекты функций для решения проблем и выполнения вычислений, особенно при использовании алгоритмов стандартной библиотеки C++. У объектов-функций и указателей на функции есть как преимущества, так и недостатки. Например, указатели на функции отличаются минимальными требованиями к синтаксису, но не сохраняют состояние в области видимости. Объекты-функции, в свою очередь, могут сохранять состояние, но требуют дополнительного синтаксиса в определении класса.
Лямбда-выражение сочетает преимущества указателей на функции и объектов-функций, избегая их недостатков. Как и объект функции, лямбда-выражение является гибким и может поддерживать состояние, но в отличие от объекта функции, его синтаксис Compact не требует явного определения класса. С помощью лямбда-выражений можно написать код, который более простым и менее подверженным появлению ошибок, чем код для соответствующего объекта функции.
В следующих примерах сравнивается использование лямбда-выражения и объекта функции. В первом примере лямбда-выражение используется для вывода на консоль независимо от того, четным или нечетным является каждый элемент в объекте vector . Во втором примере для выполнения той же задачи используется объект функции.
Пример 1: использование лямбда-выражения
Комментарии
В примере третий аргумент функции for_each является лямбда-выражением. Часть [&evenCount] указывает предложение захвата выражения, (int n) определяет список параметров, а оставшаяся часть определяет тело выражения.
Пример 2: использование объекта-функции
Иногда лямбда-выражение может быть слишком громоздким для значительного расширения из состояния, показанного в предыдущем примере. В следующем примере вместо лямбда-выражения используется объект функции, а также функция for_each для получения тех же результатов, что и в примере 1. Оба примера хранят количество четных чисел в объекте vector . Для поддержания состояния операции класс FunctorClass хранит переменную m_evenCount по ссылке как переменную-член. Для выполнения операции FunctorClass реализует оператор вызова функции, оператор (). Компилятор Microsoft C++ создает код, сравнимый по размеру и производительности, с лямбда-кодом в примере 1. Для несложной проблемы, такой как в этом примере, более простая конструкция лямбда-выражения, возможно, лучше, чем конструкция объекта-функции. Однако если вы считаете, что в будущем потребуется значительно расширить функциональность, используйте конструкцию объекта-функции, чтобы упростить обслуживание кода.
Дополнительные сведения об операторе ()см. в разделе вызов функции. Дополнительные сведения о функции for_each см. в разделе for_each.
Читайте также: