Passing capturing lambda as function pointer

Question

Is it possible to pass a lambda function as a function pointer  If so  I must be doing something incorrectly because I am getting a compile error   Consider the following example  using DecisionFn   bool        class Decide   public      Decide DecisionFn dec     dec dec     private      DecisionFn  dec      int main         int x   5      Decide greaterThanThree   x     return x  gt  3           return 0      When I try to compile this  I get the following compilation error   In function  int main     17 31  error  the value of  x  is not usable in a constant expression 16 9   note   int x  is not const 17 53  error  no matching function for call to  Decide  Decide  lt brace-enclosed initializer list gt    17 53  note  candidates are  9 5    note  Decide  Decide DecisionFn  9 5    note  no known conversion for argument 1 from  main     lt lambda   gt   to  DecisionFn  aka bool         6 7    note  constexpr Decide  Decide const Decide amp   6 7    note  no known conversion for argument 1 from  main     lt lambda   gt   to  const Decide amp   6 7    note  constexpr Decide  Decide Decide amp  amp   6 7    note  no known conversion for argument 1 from  main     lt lambda   gt   to  Decide amp  amp     That s one heck of an error message to digest  but I think what I m getting out of it is that the lambda cannot be treated as a constexpr so therefore I cannot pass it as a function pointer  I ve tried making x const as well  but that doesn t seem to help

User · Answer

While the template approach is clever for various reasons, it is important to remember the lifecycle of the lambda and the captured variables. If any form of a lambda pointer is is going to be used and the lambda is not a downward continuation, then only a copying [=] lambda should used. I.e., even then, capturing a pointer to a variable on the stack is UNSAFE if the lifetime of those captured pointers (stack unwind) is shorter than the lifetime of the lambda.

A simpler solution for capturing a lambda as a pointer is:

auto pLamdba = new std::function<...fn-sig...>([=](...fn-sig...){...});

e.g., new std::function<void()>([=]() -> void {...}

Just remember to later delete pLamdba so ensure that you don't leak the lambda memory. Secret to realize here is that lambdas can capture lambdas (ask yourself how that works) and also that in order for std::function to work generically the lambda implementation needs to contain sufficient internal information to provide access to the size of the lambda (and captured) data (which is why the delete should work [running destructors of captured types]).

User · Answer

A shortcut for using a lambda with as a C function pointer is this    auto fun              Using Curl as exmample  curl debug info    auto callback       CURL  handle  curl infotype type  char  data  size t size  void      add code here  -     curl easy setopt curlHande  CURLOPT VERBOSE  1L   curl easy setopt curlHande CURLOPT DEBUGFUNCTION callback

User · Answer

Capturing lambdas cannot be converted to function pointers  as this answer pointed out   However  it is often quite a pain to supply a function pointer to an API that only accepts one  The most often cited method to do so is to provide a function and call a static object with it   static Callable callable  static bool wrapper         return callable        This is tedious  We take this idea further and automate the process of creating wrapper and make life much easier    include lt type traits gt   include lt utility gt   template lt typename Callable gt  union storage       storage          std  decay t lt Callable gt  callable      template lt int  typename Callable  typename Ret  typename    Args gt  auto fnptr  Callable amp  amp  c  Ret     Args            static bool used   false      static storage lt Callable gt  s      using type   decltype s callable        if used          s callable  type        new   amp s callable  type std  forward lt Callable gt  c        used   true       return    Args    args  - gt  Ret           return Ret s callable std  forward lt Args gt  args                  template lt typename Fn  int N   0  typename Callable gt  Fn  fnptr Callable amp  amp  c        return fnptr  lt N gt  std  forward lt Callable gt  c    Fn  nullptr       And use it as  void foo void   fn           fn          int main         int i   42      auto fn   fnptr lt void   gt   i  std  cout  lt  lt  i         foo fn       compiles      Live  This is essentially declaring an anonymous function at each occurrence of fnptr   Note that invocations of fnptr overwrite the previously written callable given callables of the same type  We remedy this  to a certain degree  with the int parameter N   std  function lt void   gt  func1  func2  auto fn1   fnptr lt void    1 gt  func1   auto fn2   fnptr lt void    2 gt  func2       different function

User · Answer

A simular answer but i made it so you don t have to specify the type of returned pointer  note that the generic version requires C  20    include  lt iostream gt    template lt typename Function gt  struct function traits   template  lt typename Ret  typename    Args gt  struct function traits lt Ret Args     gt        typedef Ret  ptr  Args          template  lt typename Ret  typename    Args gt  struct function traits lt Ret  const  Args     gt    function traits lt Ret Args     gt       template  lt typename Cls  typename Ret  typename    Args gt  struct function traits lt Ret Cls     Args     const gt    function traits lt Ret Args     gt       using voidfun   void        template  lt typename F gt  voidfun lambda to void function F lambda        static auto lambda copy   lambda       return                lambda copy                 requires C  20 template  lt typename F gt  auto lambda to pointer F lambda  - gt  typename function traits lt decltype  amp F  operator    gt   ptr       static auto lambda copy   lambda           return    lt typename    Args gt  Args    args            return lambda copy args                  int main         int num       void  foo      lambda to void function   amp num              num   1234              foo        std  cout  lt  lt  num  lt  lt  std  endl     1234      int  bar  int    lambda to pointer   amp   int a  - gt  int           num   a          return a              std  cout  lt  lt  bar 4321   lt  lt  std  endl     4321     std  cout  lt  lt  num  lt  lt  std  endl     4321

User · Answer

Lambda expressions  even captured ones  can be handled as a function pointer  pointer to member function    It is tricky because an lambda expression is not a simple function  It is actually an object with an operator     When you are creative  you can use this   Think of an  function  class in style of std  function   If you save the object you also can use the function pointer   To use the function pointer  you can use the following   int first   5  auto lambda       int x  int z        return x   z   first     int decltype lambda    ptr  int  int const    amp decltype lambda   operator    std  cout  lt  lt   test      lt  lt   lambda  ptr  2  3   lt  lt  std  endl    To build a class that can start working like a  std  function   first you need a class struct than can store object and function pointer  Also you need an operator   to execute it      OT   gt  Object Type    RT   gt  Return Type    A       gt  Arguments template lt typename OT  typename RT  typename     A gt  struct lambda expression       OT  object      RT OT    function  A    const       lambda expression const OT  amp  object             object object    function  amp decltype  object   operator            RT operator    A     args  const           return   object   function  args                 With this you can now run captured  non-captured lambdas  just like you are using the original   auto capture lambda         int first   5      auto lambda       int x  int z            return x   z   first             return lambda expression lt decltype lambda   int  int  int gt  lambda      auto noncapture lambda         auto lambda      int x  int z            return x   z             return lambda expression lt decltype lambda   int  int  int gt  lambda      void refcapture lambda         int test      auto lambda     amp   int x  int z            test   x   z             lambda expression lt decltype lambda   void  int  int gt f lambda       f 2  3        std  cout  lt  lt   test value      lt  lt  test  lt  lt  std  endl     int main int argc  char   argv        auto f capture   capture lambda        auto f noncapture   noncapture lambda         std  cout  lt  lt   main test      lt  lt  f capture 2  3   lt  lt  std  endl      std  cout  lt  lt   main test      lt  lt  f noncapture 2  3   lt  lt  std  endl       refcapture lambda         system  PAUSE        return 0      This code works with VS2015  Update 04 07 17   template  lt typename CT  typename     A gt  struct function   public function lt decltype  amp CT  operator    A     gt       template  lt typename C gt  struct function lt C gt    private      C mObject   public      function const C  amp  obj            mObject obj          template lt typename    Args gt  typename      std  result of lt C Args     gt   type operator   Args    a            return this- gt mObject operator   a                 template lt typename    Args gt  typename      std  result of lt const C Args     gt   type operator   Args    a  const           return this- gt mObject operator   a                namespace make       template lt typename C gt  auto function const C  amp  obj            return   function lt C gt  obj            int main int argc  char    argv       auto func   make  function    int y  int x    return x y         std  cout  lt  lt  func 2  4   lt  lt  std  endl     system  PAUSE       return 0

User · Answer

Shafik Yaghmour s answer correctly explains why the lambda cannot be passed as a function pointer if it has a capture   I d like to show two simple fixes for the problem    Use std  function instead of raw function pointers   This is a very clean solution   Note however that it includes some additional overhead for the type erasure  probably a virtual function call     include  lt functional gt   include  lt utility gt   struct Decide     using DecisionFn   std  function lt bool   gt     Decide DecisionFn dec    dec   std  move dec        DecisionFn dec       int main       int x   5    Decide greaterThanThree    x     return x  gt  3          Use a lambda expression that doesn t capture anything   Since your predicate is really just a boolean constant  the following would quickly work around the current issue   See this answer for a good explanation why and how this is working      Your  Decide  class as in your post   int main       int x   5    Decide greaterThanThree        x  gt  3          return true            return false

User · Answer

As it was mentioned by the others you can substitute Lambda function instead of function pointer  I am using this method in my C   interface to F77 ODE solver RKSUITE     C interface to Fortran subroutine UT extern  C   void UT void    double  double  double   double  double  double   double  double  double  int        C   wrapper which calls extern  C  void UT routine static  void   rk ut void    double  double  double   double  double  double   double  double  double  int         Call of rk ut with lambda passed instead of function pointer to derivative     routine mathlib  RungeKuttaSolver  rk ut    double  T double  Y double  YP - gt void YP 0  Y 1   YP 1   -Y 0     TWANT T Y YP YMAX WORK UFLAG

User · Answer

A lambda can only be converted to a function pointer if it does not capture  from the draft C  11 standard section 5 1 2  expr prim lambda  says  emphasis mine       The closure type for a lambda-expression with no lambda-capture has a   public non-virtual non-explicit const conversion function to pointer   to function having the same parameter and return types as the closure   type   s function call operator  The value returned by this conversion   function shall be the address of a function that  when invoked  has   the same effect as invoking the closure type   s function call operator    Note  cppreference also covers this in their section on Lambda functions   So the following alternatives would work   typedef bool  DecisionFn  int    Decide greaterThanThree      int x    return x  gt  3         and so would this   typedef bool  DecisionFn      Decide greaterThanThree        return true          and as 5gon12eder points out  you can also use std  function  but note that std  function is heavy weight  so it is not a cost-less trade-off

User · Answer

Not a direct answer  but a slight variation to use the  functor  template pattern to hide away the specifics of the lambda type and keeps the code nice and simple   I was not sure how you wanted to use the decide class so I had to extend the class with a function that uses it  See full example here  https   godbolt org z jtByqE  The basic form of your class might look like this   template  lt typename Functor gt  class Decide   public      Decide Functor dec     dec dec     private      Functor  dec       Where you pass the type of the function in as part of the class type used like   auto decide fc      int x   return x  gt  3     Decide lt decltype decide fc  gt  greaterThanThree decide fc     Again  I was not sure why you are capturing x it made more sense  to me  to have a parameter that you pass in to the lambda  so you can use like   int result    dec 5      or whatever value   See the link for a complete example

[c++] Passing capturing lambda as function pointer

Examples related to c++

Examples related to c++11

Examples related to lambda

Examples related to function-pointers