c++ Should I define lambda out of for loop or inside it to keep small scope, what is best practice

Question

I have a code where I have two options, define lambda out of loop to save on lambda creation overhead or define it inside a loop to keep small scope.

Is this choice critical and will make any significant difference?

What are pros and cons of this two choices?

What is best practice?

#include <iostream>
#include <string>
#include <vector>
#include <memory>

int main()
{
  std::vector<std::function<void()>> functors;
  auto func = [] () { std::cout << "Hello world I am doing some action"; };
  //some code here
  for(int i = 0; i < 100; ++i)
  {
      // some code here
      functors.push_back(func);
      // some code here
  }
}

EDITED: simplified example

int main()
{
  auto sum = [](const int x, const  int y) { return x + y; };
  for(int i = 0; i < 100; ++i)
  {
      std::cout << sum(i, i + 1) << std::endl;
  }
}

Answer 1

For each lambda expression, the compiler will create a struct with operator () overloaded for it. It won't create a struct each time the control passes through a lambda, so in terms of generated code it does not matter whether you define it inside or outside the loop. Therefore, keep things local.

As a general rule, don't overthink these illusory optimization issues. Most likely, the performance bottleneck is going to be in your algorithm complexity.

Answer 2

I'd rather wipe out a copy construction and move construct instead by using emplace_back directly (not so useful in this case, but as a rule of thumb one should prefer it whenever possible):

#include <iostream>
#include <string>
#include <vector>
#include <memory>

int main()
{
    std::vector<std::function<void()>> functors;
    //some code here
    for(int i = 0; i < 100; ++i)
    {
        // some code here
        functors.emplace_back([] () { std::cout << "Hello world I am doing some action"; });
        // some code here
    }
}

That said, I agree with @ArmenTsirunyan and I'd avoid premature optimizations of such a type.