Указатели функций C с лямбда-выражениями C++11

Использование void* типично для интерфейсов обратного вызова C для передачи некоторого «состояния» функции. Однако std::function в этом не нуждается, потому что std::function поддерживает «функции с отслеживанием состояния». Итак, вы можете сделать что-то вроде этого:

double Integrate(
          std::function<double(double)> func,
          double a, double b)
{
    typedef std::function<double(double)> fun_type;
    :::
    F.function = [](double x, void* p){
        return (*static_cast<fun_type*>(p))(x);
    };
    F.params = &func;
    :::
}

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

void Another_function()
{
    double m = 2;
    double b = 3;
    auto func = [&](double x){return m*x+b};
    auto r1 = Integrate(func,0,3);
    :::
}

Однако это решение будет использовать довольно много косвенных действий. GSL вызовет вашу лямбду. Ваша лямбда вызовет std::function‹>::operator(), который, в свою очередь, вызовет какую-то виртуальную функцию, используемую для стирания типа, которая, в свою очередь, вызовет фактическое вычисление.

Итак, если вы заботитесь о производительности, вы можете избавиться от пары слоев, в частности от std::function. Вот еще один подход с шаблоном функции:

template<class Func>
double Integrate(
          Func func,
          double a, double b)
{
    :::
    F.function = [](double x, void* p)->double{
        return (*static_cast<Func*>(p))(x);
    };
    F.params = &func;
    :::
}

Думаю, я бы предпочел это решению std::function.

Похоже, для библиотеки gsl требуется указатель на функцию. Лямбда, которая не захватывает, может быть преобразована в указатель функции. Любую лямбду можно преобразовать в std::function. Но std::function нельзя преобразовать в указатель на функцию.

Вы можете попробовать:

struct functor_and_params {
  std::function<double(double, void*)> f;
  void* params;
  static double invoke(double x, void* ptr) {
      functor_and_params& f_and_p = *reinterpret_cast<functor_and_params*>(ptr);
      return f_and_p.f(x, f_and_p.params);
  }
};

double Integrate(std::function<double(double,void*)> func,
                 double a,double b,std::vector<double> & params) {
    functor_and_params f_and_p{ func, &params };
    gsl_function F;
    F.function = &functor_and_params::invoke;
    F.params = &f_and_p;
    //...
 }

std::function<> нельзя преобразовать в указатель функции. std::function<> - это функциональные объекты, которые потенциально могут хранить состояние, в то время как обычные функции не имеют состояния (вроде, у вас потенциально могут быть static переменные, но это другое дело).

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

double Integrate(double(*func)(double,void*), double a, double b, 
                 std::vector<double> & params) // !!!

std::vector<double> p{2,3};
Integrate([](double a,void* param)
   {
      std::vector<double> *p = static_cast<std::vector<double>*>param;
      return p->at(0)*a+p->at(1);
   }
   ,0,3,p);

Обратите внимание, что недопустимо связывать rvalue с неконстантной ссылкой, поэтому вы не можете законно передать {2,3} в качестве последнего аргумента для Integrate (даже если Visual Studio позволяет вам это сделать), вам нужно будет создать именованная переменная.

Лучше всего инкапсулировать преобразование void * внутри вашей функции-оболочки:

double Integrate(std::function<double(double)> func, double a, double b)
{
  gsl_integration_workspace * w = gsl_integration_workspace_alloc (1000);
  gsl_function F;
  F.function = [](double a, void *param) {
    return (*static_cast<std::function<double(double)> *>(param))(a); };
  F.params = (void*)&func;
  double error,result;
  gsl_integration_qag (&F, a, b, 0, 1e-7, 1000,GSL_INTEG_GAUSS61,w, &result, &error);
  gsl_integration_workspace_free (w);
  return result;
}

void Another_function()
{
  //...
  std::vector<double> params = {2, 3};
  Integrate([params](double a) { return (params[0]*a+params[1]; }, 0, 3);
}

Здесь есть определенная избыточная косвенность (через std::function), но предсказатель ветвления ЦП сможет работать хорошо, поскольку косвенность всегда будет относиться к одной и той же лямбда-выражению.

Если вам нужно интегрировать лямбда-функцию с захватом (в этом случае нет преобразования в необработанный указатель), и если вы не хотите иметь штрафы за производительность, связанные с std::function (как указано sellibitze - см. std::function vs template), вы можете использовать следующую оболочку

 template< typename F >  class gsl_function_pp : public gsl_function {
 public:
 gsl_function_pp(const F& func) : _func(func) {
   function = &gsl_function_pp::invoke;
   params=this;
 }
 private:
 const F& _func;
 static double invoke(double x, void *params) {
 return static_cast<gsl_function_pp*>(params)->_func(x);
 }
 };

Вот тестовый код, который показывает, как его использовать

 double a = 1;
 auto ptr = [=](double x)->double{return a*x;};
 gsl_function_pp<decltype(ptr)> Fp(ptr);
 gsl_function *F = static_cast<gsl_function*>(&Fp);   

Если вы действительно хотите использовать std::function, вы можете использовать эту версию оболочки

class gsl_function_pp : public gsl_function
{
   public:
   gsl_function_pp(std::function<double(double)> const& func) : _func(func){
   function=&gsl_function_pp::invoke;
   params=this;
   }     
   private:
   std::function<double(double)> _func;
   static double invoke(double x, void *params) {
   return static_cast<gsl_function_pp*>(params)->_func(x);
   }
};

Код теста в этом случае еще проще

double a = 1;
gsl_function_pp Fp([=](double x)->double{return a*x;}); 
gsl_function *F = static_cast<gsl_function*>(&Fp);  

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