Что такое лямбда-выражение в C++11?

Question

Что такое лямбда-выражение в C++11? Когда я буду использовать один? Какой класс проблем они решают, что было невозможно до их введения?

Несколько примеров и вариантов использования будут полезны.

Answer 1

Эта проблема

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] захватывает переменные как с [=], но эпсилон по ссылке

Сгенерированный operator() является const по умолчанию подразумевается, что захват будет const когда вы получаете к ним доступ по умолчанию. Это приводит к тому, что каждый вызов с одним и тем же вводом будет давать один и тот же результат, однако вы можете пометить лямбду какmutable просить, чтобы operator() что производится не const,

Answer 2

Что такое лямбда-функция?

Концепция лямбда-функции в C++ берет свое начало в лямбда-исчислении и функциональном программировании. Лямбда - это безымянная функция, которая полезна (в реальном программировании, а не в теории) для коротких фрагментов кода, которые невозможно повторно использовать и которые не стоит называть.

В C++ лямбда-функция определяется следующим образом

[]() { } // barebone lambda

или во всей красе

[]() mutable -> T { } // T is the return type, still lacking throw()

[] это список захвата, () список аргументов и {} тело функции.

Список захвата

Список захвата определяет, что снаружи лямбды должно быть доступно внутри тела функции и как. Это может быть либо:

1. значение: [x]
2. ссылка [&x]
3. любая переменная в настоящее время в области видимости по ссылке [&]
4. такой же, как 3, но по значению [=]

Вы можете смешать любое из вышеперечисленного в списке через запятую [x, &y],

Список аргументов

Список аргументов такой же, как и в любой другой функции C++.

Тело функции

Код, который будет выполнен, когда лямбда будет вызвана.

Возвращаемый тип удержания

Если лямбда имеет только один оператор возврата, тип возврата может быть опущен и имеет неявный тип decltype(return_statement),

изменчивый

Если лямбда помечена как изменяемая (например, []() mutable { }) разрешено изменять значения, захваченные по значению.

Случаи применения

Библиотека, определяемая стандартом ISO, в значительной степени выигрывает от лямбд и повышает удобство использования на несколько тактов, поскольку теперь пользователям не нужно загромождать свой код маленькими функторами в некоторой доступной области видимости.

C++14

В C++14 лямбд были расширены различными предложениями.

Инициализированные лямбда-захваты

Элемент списка захвата теперь можно инициализировать с помощью =, Это позволяет переименовывать переменные и захватывать при перемещении. Пример взят из стандарта:

int x = 4;
auto y = [&r = x, x = x+1]()->int {
            r += 2;
            return x+2;
         }();  // Updates ::x to 6, and initializes y to 7.

и один взят из Википедии, показывающий, как захватить с std::move:

auto ptr = std::make_unique<int>(10); // See below for std::make_unique
auto lambda = [ptr = std::move(ptr)] {return *ptr;};

Универсальные лямбды

Лямбды теперь могут быть родовыми (auto будет эквивалентно T здесь, еслиT были аргументы шаблона типа где-то в окружающей области видимости):

auto lambda = [](auto x, auto y) {return x + y;};

Улучшено вычитание типа возврата

C++14 позволяет выводить типы возврата для каждой функции и не ограничивает ее функциями вида return expression;, Это также распространяется на лямбды.

Answer 3

Лямбда-выражения обычно используются для инкапсуляции алгоритмов, чтобы их можно было передать другой функции. Тем не менее, можно выполнить лямбду сразу после определения:

[&](){ ...your code... }(); // immediately executed lambda expression

функционально эквивалентно

{ ...your code... } // simple code block

Это делает лямбда-выражения мощным инструментом для рефакторинга сложных функций. Вы начинаете с обертывания секции кода в лямбда-функции, как показано выше. Процесс явной параметризации может затем выполняться постепенно с промежуточным тестированием после каждого шага. Как только у вас будет полностью параметризованный кодовый блок (что продемонстрировано удалением &), вы можете переместить код во внешнее местоположение и сделать его нормальной функцией.

Точно так же вы можете использовать лямбда-выражения для инициализации переменных на основе результата алгоритма...

int a = []( int b ){ int r=1; while (b>0) r*=b--; return r; }(5); // 5!

В качестве способа разделения логики вашей программы вы можете даже найти полезным передать лямбда-выражение в качестве аргумента другому лямбда-выражению...

[&]( std::function<void()> algorithm ) // wrapper section
   {
   ...your wrapper code...
   algorithm();
   ...your wrapper code...
   }
([&]() // algorithm section
   {
   ...your algorithm code...
   });

Лямбда-выражения также позволяют создавать именованные вложенные функции, что может быть удобным способом избежать дублирования логики. Использование именованных лямбд также, как правило, немного проще для глаз (по сравнению с анонимными встроенными лямбдами) при передаче нетривиальной функции в качестве параметра другой функции. Примечание: не забывайте точку с запятой после закрывающей фигурной скобки.

auto algorithm = [&]( double x, double m, double b ) -> double
   {
   return m*x+b;
   };

int a=algorithm(1,2,3), b=algorithm(4,5,6);

Если последующее профилирование обнаруживает значительные издержки инициализации для объекта функции, вы можете переписать это как обычную функцию.

Answer 4

ответы

Q: Что такое лямбда-выражение в C++ 11?

A: Под капотом это объект автоматически сгенерированного класса с перегрузкой operator () const. Такой объект называется закрытием и создается компилятором. Эта концепция "замыкания" близка к концепции связывания из C++11. Но лямбды обычно генерируют лучший код. И звонки через замыкания позволяют полное встраивание.

Q: Когда я буду использовать один?

A: Чтобы определить "простую и маленькую логику" и попросить компилятор выполнить генерацию из предыдущего вопроса. Вы даете компилятору несколько выражений, которые вы хотите использовать внутри operator(). Все остальные вещи компилятор сгенерирует вам.

В: Какой класс проблем они решают, что было невозможно до их появления?

A: Это какой-то синтаксический сахар, похожий на перегрузку операторов вместо функций для пользовательских операций добавления, операций с вложенными контактами... Но это экономит больше строк ненужного кода, чтобы обернуть 1-3 строки реальной логики в некоторые классы и т. Д.! Некоторые инженеры считают, что если число строк меньше, то вероятность ошибиться в нем меньше (я тоже так думаю)

Пример использования

auto x = [=](int arg1){printf("%i", arg1); };
void(*f)(int) = x;
f(1);
x(1);

---

Дополнения о лямбдах, не подпадающие под вопрос. Игнорируйте этот раздел, если вы не заинтересованы

1. Захваченные значения. Что вы можете поймать

1.1. Вы можете ссылаться на переменную со статической продолжительностью хранения в лямбдах. Все они захвачены в плен.

1.2. Вы можете использовать лямбду для захвата значений "по значению". В этом случае захваченные переменные будут скопированы в объект функции (замыкание).

[captureVar1,captureVar2](int arg1){}

1.3. Вы можете захватить ссылки. & - в этом контексте означает ссылку, а не указатели.

   [&captureVar1,&captureVar2](int arg1){}

1.4. Существует нотация для захвата всех нестатических переменных по значению или по ссылке

  [=](int arg1){} // capture all not-static vars by value

  [&](int arg1){} // capture all not-static vars by reference

1,5. Существует нотация для захвата всех нестатических переменных по значению или по ссылке и указания чего-либо. Больше. Примеры: захват всех нестатических переменных по значению, но по ссылке захват Param2

[=,&Param2](int arg1){} 

Захватить все нестатические переменные по ссылке, но по значению Param2

[&,Param2](int arg1){} 

2. Возвращаемый тип удержания

2.1. Лямбда-тип возврата может быть выведен, если лямбда-выражение является одним выражением. Или вы можете явно указать это.

[=](int arg1)->trailing_return_type{return trailing_return_type();}

Если лямбда имеет более одного выражения, тип возврата должен быть указан через конечный тип возврата. Кроме того, подобный синтаксис может быть применен к автоматическим функциям и функциям-членам.

3. Захваченные значения. Что вы не можете захватить

3.1. Вы можете захватывать только локальные переменные, а не переменную-член объекта.

4. Конверсии

4.1!! Лямбда не является указателем на функцию и не является анонимной функцией, но лямбды без захвата можно неявно преобразовать в указатель на функцию.

п.с.

1. Более подробную информацию о лямбда-грамматике можно найти в Рабочем проекте для языка программирования C++ #337, 2012-01-16, 5.1.2. Лямбда-выражения, стр.88

2. В C++14 была добавлена ​​дополнительная функция, названная как "захват init". Позволяет произвольно выполнить декларацию закрытия данных членов:

   auto toFloat = [](int value) { return float(value);};
   auto interpolate = [min = toFloat(0), max = toFloat(255)](int value)->float { return (value - min) / (max - min);};
   

Answer 5

Лямбда-функция - это анонимная функция, которую вы создаете в строке. Он может захватывать переменные, как объяснили некоторые (например, http://www.stroustrup.com/C++11FAQ.html), но есть некоторые ограничения. Например, если есть такой интерфейс обратного вызова,

void apply(void (*f)(int)) {
    f(10);
    f(20);
    f(30);
}

Вы можете написать функцию на месте, чтобы использовать ее так же, как переданную ниже для применения:

int col=0;
void output() {
    apply([](int data) {
        cout << data << ((++col % 10) ? ' ' : '\n');
    });
}

Но вы не можете сделать это:

void output(int n) {
    int col=0;
    apply([&col,n](int data) {
        cout << data << ((++col % 10) ? ' ' : '\n');
    });
}

из-за ограничений в стандарте C++ 11. Если вы хотите использовать снимки, вы должны полагаться на библиотеку и

#include <functional> 

(или какой-нибудь другой библиотеке STL, такой как алгоритм, чтобы получить ее косвенно), а затем работать с std::function вместо передачи нормальных функций в качестве параметров, подобных этому:

#include <functional>
void apply(std::function<void(int)> f) {
    f(10);
    f(20);
    f(30);
}
void output(int width) {
    int col;
    apply([width,&col](int data) {
        cout << data << ((++col % width) ? ' ' : '\n');
    });
}

Answer 6

Одно из лучших объяснений lambda expression дан от автора C++ Бьярне Страуструпа в его книге ***The C++ Programming Language*** глава 11 ( ISBN-13: 978-0321563842):

What is a lambda expression?

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

When would I use one?

Это особенно полезно, когда мы хотим передать операцию в качестве аргумента алгоритму. В контексте графических пользовательских интерфейсов (и в других местах) такие операции часто называют обратными вызовами.

What class of problem do they solve that wasn't possible prior to their introduction?

Здесь я думаю, что каждое действие, выполненное с помощью лямбда-выражения, может быть решено без них, но с гораздо большим количеством кода и гораздо большей сложностью. Лямбда-выражение - это способ оптимизации вашего кода и способ сделать его более привлекательным. Как грустно от Страуступа:

эффективные способы оптимизации

Some examples

через лямбда-выражение

void print_modulo(const vector<int>& v, ostream& os, int m) // output v[i] to os if v[i]%m==0
{
    for_each(begin(v),end(v),
        [&os,m](int x) { 
           if (x%m==0) os << x << '\n';
         });
}

или через функцию

class Modulo_print {
         ostream& os; // members to hold the capture list int m;
     public:
         Modulo_print(ostream& s, int mm) :os(s), m(mm) {} 
         void operator()(int x) const
           { 
             if (x%m==0) os << x << '\n'; 
           }
};

или даже

void print_modulo(const vector<int>& v, ostream& os, int m) 
     // output v[i] to os if v[i]%m==0
{
    class Modulo_print {
        ostream& os; // members to hold the capture list
        int m; 
        public:
           Modulo_print (ostream& s, int mm) :os(s), m(mm) {}
           void operator()(int x) const
           { 
               if (x%m==0) os << x << '\n';
           }
     };
     for_each(begin(v),end(v),Modulo_print{os,m}); 
}

если вам нужно, вы можете назвать lambda expression как ниже:

void print_modulo(const vector<int>& v, ostream& os, int m)
    // output v[i] to os if v[i]%m==0
{
      auto Modulo_print = [&os,m] (int x) { if (x%m==0) os << x << '\n'; };
      for_each(begin(v),end(v),Modulo_print);
 }

Или предположим другой простой пример

void TestFunctions::simpleLambda() {
    bool sensitive = true;
    std::vector<int> v = std::vector<int>({1,33,3,4,5,6,7});

    sort(v.begin(),v.end(),
         [sensitive](int x, int y) {
             printf("\n%i\n",  x < y);
             return sensitive ? x < y : abs(x) < abs(y);
         });


    printf("sorted");
    for_each(v.begin(), v.end(),
             [](int x) {
                 printf("x - %i;", x);
             }
             );
}

будет генерировать следующий

0

1

0

1

0

1

0

1

0

1

0 отсортировано - 1; х - 3; х - 4; х - 5; х - 6; х - 7; х - 33;

[] - это список захвата или lambda introducer: если lambdas не требуют доступа к их местной среде, мы можем использовать его.

Цитата из книги:

Первым символом лямбда-выражения всегда является [. Лямбда-интродьюсер может принимать различные формы:

• []: пустой список захвата. Это означает, что никакие локальные имена из окружающего контекста не могут использоваться в лямбда-теле. Для таких лямбда-выражений данные получают из аргументов или из нелокальных переменных.

• [&]: неявный захват по ссылке. Все местные имена могут быть использованы. Все локальные переменные доступны по ссылке.

• [=]: неявный захват по значению. Все местные имена могут быть использованы. Все имена относятся к копиям локальных переменных, взятых в точке вызова лямбда-выражения.

• [capture-list]: явный захват; список захвата - это список имен локальных переменных, которые должны быть захвачены (то есть, сохранены в объекте) по ссылке или по значению. Переменные с именами, начинающимися с &, фиксируются по ссылке. Другие переменные фиксируются по значению. Список захвата может также содержать это и имена, сопровождаемые... как элементы.

• [&, capture-list]: неявно захватывает по ссылке все локальные переменные с именами, не упомянутыми в списке. Список захвата может содержать это. Перечисленным именам не может предшествовать &. Переменные, названные в списке захвата, фиксируются по значению.

• [=, capture-list]: неявно захватывать по значению все локальные переменные с именами, не упомянутыми в списке. Список захвата не может содержать это. Перечисленным именам должен предшествовать &. Переменные, названные в списке захвата, захватываются по ссылке.

Обратите внимание, что локальное имя, которому предшествует &, всегда захватывается ссылкой, а локальное имя, которому не предшествует &, всегда захватывается значением. Только захват по ссылке позволяет модифицировать переменные в вызывающей среде.

Additional

Lambda expression формат

Дополнительные ссылки:

• Wiki
• open-std.org, глава 5.1.2

Answer 7

Лямбда в C++ обрабатывается как "функция, доступная на ходу". да, буквально на ходу, вы определяете это; используй это; и когда родительская функция завершает область действия, лямбда-функция исчезает.

C++ представил его в C++ 11, и все начали использовать его, как и везде. пример и что такое лямбда можно найти здесь https://en.cppreference.com/w/cpp/language/lambda

я опишу, чего нет, но важно знать каждому программисту на C++

Лямбда не предназначена для использования везде, и каждая функция не может быть заменена лямбда. Это также не самый быстрый по сравнению с обычной функцией. потому что у него есть некоторые накладные расходы, которые должны обрабатываться лямбда-выражением.

это, безусловно, поможет в некоторых случаях сократить количество строк. он может быть в основном использован для раздела кода, который вызывается в одной и той же функции один или несколько раз, и этот фрагмент кода больше нигде не нужен, так что вы можете создать для него отдельную функцию.

Ниже приведен основной пример лямбды и что происходит в фоновом режиме.

Код пользователя:

int main()
{
  // Lambda & auto
  int member=10;
  auto endGame = [=](int a, int b){ return a+b+member;};

  endGame(4,5);

  return 0;

}

Как компиляция расширяет это:

int main()
{
  int member = 10;

  class __lambda_6_18
  {
    int member;
    public: 
    inline /*constexpr */ int operator()(int a, int b) const
    {
      return a + b + member;
    }

    public: __lambda_6_18(int _member)
    : member{_member}
    {}

  };

  __lambda_6_18 endGame = __lambda_6_18{member};
  endGame.operator()(4, 5);

  return 0;
}

так что, как вы можете видеть, какие накладные расходы добавляются при использовании. так что не стоит использовать их везде. это может использоваться в местах, где они применимы.

Answer 8

Ну, одно практическое применение, которое я обнаружил, - это сокращение кода котельной плиты. Например:

void process_z_vec(vector<int>& vec)
{
  auto print_2d = [](const vector<int>& board, int bsize)
  {
    for(int i = 0; i<bsize; i++)
    {
      for(int j=0; j<bsize; j++)
      {
        cout << board[bsize*i+j] << " ";
      }
      cout << "\n";
    }
  };
  // Do sth with the vec.
  print_2d(vec,x_size);
  // Do sth else with the vec.
  print_2d(vec,y_size);
  //... 
}

Без лямбды может понадобиться что-то сделать для разных bsize случаев. Конечно, вы могли бы создать функцию, но что, если вы хотите ограничить использование в рамках пользовательской функции Soul? природа лямбда выполняет это требование, и я использую его для этого случая.

Answer 9

В C++ 11 введено лямбда-выражение, позволяющее нам написать встроенную функцию, которую можно использовать для коротких фрагментов кода.

      [ capture clause ] (parameters) -> return-type
{
   definition of method
}

Обычно возвращаемый тип в лямбда-выражении оценивается самим компилятором, и нам не нужно указывать, что явно и -> часть возвращаемого типа может быть проигнорирована, но в некоторых сложных случаях, как в условном выражении, компилятор не может разобрать возврат type, и нам нужно это указать.

      // C++ program to demonstrate lambda expression in C++
#include <bits/stdc++.h>
using namespace std;

// Function to print vector
void printVector(vector<int> v)
{
    // lambda expression to print vector
    for_each(v.begin(), v.end(), [](int i)
    {
        std::cout << i << " ";
    });
    cout << endl;
}

int main()
{
    vector<int> v {4, 1, 3, 5, 2, 3, 1, 7};

    printVector(v);

    // below snippet find first number greater than 4
    // find_if searches for an element for which
    // function(third argument) returns true
    vector<int>:: iterator p = find_if(v.begin(), v.end(), [](int i)
    {
        return i > 4;
    });
    cout << "First number greater than 4 is : " << *p << endl;


    // function to sort vector, lambda expression is for sorting in
    // non-decreasing order Compiler can make out return type as
    // bool, but shown here just for explanation
    sort(v.begin(), v.end(), [](const int& a, const int& b) -> bool
    {
        return a > b;
    });

    printVector(v);

    // function to count numbers greater than or equal to 5
    int count_5 = count_if(v.begin(), v.end(), [](int a)
    {
        return (a >= 5);
    });
    cout << "The number of elements greater than or equal to 5 is : "
        << count_5 << endl;

    // function for removing duplicate element (after sorting all
    // duplicate comes together)
    p = unique(v.begin(), v.end(), [](int a, int b)
    {
        return a == b;
    });

    // resizing vector to make size equal to total different number
    v.resize(distance(v.begin(), p));
    printVector(v);

    // accumulate function accumulate the container on the basis of
    // function provided as third argument
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int f = accumulate(arr, arr + 10, 1, [](int i, int j)
    {
        return i * j;
    });

    cout << "Factorial of 10 is : " << f << endl;

    //   We can also access function by storing this into variable
    auto square = [](int i)
    {
        return i * i;
    };

    cout << "Square of 5 is : " << square(5) << endl;
}

Выход

      4 1 3 5 2 3 1 7
First number greater than 4 is : 5
7 5 4 3 3 2 1 1
The number of elements greater than or equal to 5 is : 2
7 5 4 3 2 1
Factorial of 10 is : 3628800
Square of 5 is : 25

Лямбда-выражение может иметь больше возможностей, чем обычная функция, за счет доступа к переменным из окружающей области. Мы можем захватить внешние переменные из области видимости тремя способами:

• Захват по ссылке
• Захват по значению
• Захват обоими (смешанный захват)

Синтаксис, используемый для захвата переменных:

• [&]: захватить все внешние переменные по ссылке
• [=]: захватить все внешние переменные по значению
• [a, &b]: захватить a по значению и b по ссылке. Лямбда с пустым предложением захвата [] может получить доступ только к той переменной, которая является локальной для него.

          #include <bits/stdc++.h>
    using namespace std;
    
    int main()
    {
        vector<int> v1 = {3, 1, 7, 9};
        vector<int> v2 = {10, 2, 7, 16, 9};
    
        // access v1 and v2 by reference
        auto pushinto = [&] (int m)
        {
            v1.push_back(m);
            v2.push_back(m);
        };
    
        // it pushes 20 in both v1 and v2
        pushinto(20);
    
        // access v1 by copy
        [v1]()
        {
            for (auto p = v1.begin(); p != v1.end(); p++)
            {
                cout << *p << " ";
            }
        };
    
        int N = 5;
    
        // below snippet find first number greater than N
        // [N] denotes, can access only N by value
        vector<int>:: iterator p = find_if(v1.begin(), v1.end(), [N](int i)
        {
            return i > N;
        });
    
        cout << "First number greater than 5 is : " << *p << endl;
    
        // function to count numbers greater than or equal to N
        // [=] denotes, can access all variable
        int count_N = count_if(v1.begin(), v1.end(), [=](int a)
        {
            return (a >= N);
        });
    
        cout << "The number of elements greater than or equal to 5 is : "
            << count_N << endl;
    }

Выход:

         First number greater than 5 is : 7
   The number of elements greater than or equal to 5 is : 3

Answer 10

Решается одна проблема: код, более простой, чем лямбда, для вызова в конструкторе, который использует функцию выходного параметра для инициализации константного члена

Вы можете инициализировать константный член вашего класса с помощью вызова функции, которая устанавливает его значение, возвращая его вывод в качестве выходного параметра.