Does the compiler design a different type for each lambda?

Disclaimer: Do not use code in this question. It invokes undefined behavior. The basic question is whether the compiler generates a new type for each lambda, and the corresponding answer is still valid.

To get a lambda pointer function with capturing I came up with the following trick:

auto f = [&a] (double x) { return a*x; };
static auto proxy = f;
double(*ptr)(double) = [] (double x) { return proxy(x); };
// do something with ptr

      

        
        
        
      

    

I am assigning a capturing lambda (which could be a function parameter) to a static variable inside a function, so I don't need to capture it when using it in another lambda. Then another light-hearted lambda can happily decay into a function pointer that I can pass into some kind of shared library.

Now we can try to generalize this:

template < typename F >
decltype(auto) get_ptr(F f)
{
  static auto proxy = f;
  return [] (auto ... args) { return proxy(args...); };
}

      

        
        
        
      

    

However, since it proxy

is a static variable, it will be overwritten every time the function is called. Since this is a template, I think it will only be overwritten when I call the same instance, i.e. Each instance has its own static one proxy

.

However, the following works:

#include <cassert>

template < typename F >
decltype(auto) get_ptr(F f)
{
  static auto proxy = f;
  return [] (auto ... args) { return proxy(args...); };
}

int main()
{
  auto f1 = [ ](double,double) { return 1; };
  auto f2 = [=](double,double) { return 2; };
  auto f3 = [&](double,double) { return 3; };
  auto f4 = [&](double,double) { return 4; };
  auto f5 = [ ](double,double) { return 5; };

  int(*p1)(double,double) = get_ptr(f1);
  int(*p2)(double,double) = get_ptr(f2);
  int(*p3)(double,double) = get_ptr(f3);
  int(*p4)(double,double) = get_ptr(f4);
  int(*p5)(double,double) = get_ptr(f5);

  assert( p1(0,0) == 1 );
  assert( p2(0,0) == 2 );
  assert( p3(0,0) == 3 );
  assert( p4(0,0) == 4 );
  assert( p5(0,0) == 5 );
}

      

        
        
        
      

    

This looks suspicious as for get_ptr(f1)

and get_ptr(f5)

the same types can be expected to be inferred. However, lambdas are compiler-generated structures, and it looks like the compiler created a different type for each lambda, regardless of whether the previous lambdas look like they can be reused.

So the above trick would be very helpful to me, provided that the compiler would definitely create a different type for each lambda. If it is not, then generalizing my hack is useless.