how to avoid static member function when using gsl with c++

by

You can easily wrap member functions using the following code (which is a well known solution)

 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);
   }
};

Then you can use std::bind to wrap the member function in a std::function. Example:

gsl_function_pp Fp( std::bind(&Class::member_function, &(*this),  std::placeholders::_1) );
gsl_function *F = static_cast<gsl_function*>(&Fp);

However, you should be aware about the performance penalties of std::function before wrapping member functions inside gsl integration routine. See template vs std::function . To avoid this performance hit (which may or may not be critical for you), you should use templates as shown below 

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);
  }
};

In this case, to call a member function you need the following

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

PS: the link template vs std::function explains that compiler usually has an easier time optimizing templates than std::function (which is critical for performance if your code is doing heavy numerical calculation). So even tough the workaround in the second example seems more cumbersome, I would prefer templates than std::function.

More Related Contents:

  1. std::function vs template
  2. Should I use std::function or a function pointer in C++?
  3. Isn’t the template argument (the signature) of std::function part of its type?
  4. regex replace with callback in c++11?
  5. Vector of std::function with different signatures
  6. How to directly bind a member function to an std::function in Visual Studio 11?
  7. Comparing std::functions for equality?
  8. std::function fails to distinguish overloaded functions
  9. C function pointers with C++11 lambdas
  10. std::function and std::bind: what are they, and when should they be used?
  11. Using `std::function` to call non-void function
  12. What is the purpose of std::function and how to use it?
  13. Using ‘void’ template arguments in C++
  14. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  15. Is cout synchronized/thread-safe?
  16. Is local static variable initialization thread-safe in C++11? [duplicate]
  17. Do rvalue references to const have any use?
  18. How to succinctly, portably, and thoroughly seed the mt19937 PRNG?
  19. Does constexpr imply inline?
  20. Do rvalue references allow dangling references?
  21. Why is my object not being copied when move constructor is deleted?
  22. What is std::promise?
  23. Random output different between implementations
  24. Equivalent of “using namespace X” for scoped enumerations?
  25. The implementation of random_device in VS2010?
  26. sqlite3_exec() Callback function clarification
  27. Which greedy initializer-list examples are lurking in the Standard Library?
  28. How does std::forward receive the correct argument?
  29. Undefined reference to process(std::__cxx11::basic_string … ) when compiling affdex linux sample applications
  30. C++ view types: pass by const& or by value?

Leave a Comment