C function pointers with C++11 lambdas

by

Using a void* is typical of C callback interfaces to pass some “state” to the function. However, std::function does not need this because std::function supports “stateful functions”. So, you could do something like this:

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

and store a reference to the parameter vector as part of the functor that will be encapsulated in the std::function object or do something like this:

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

However, this solution would use rather many indirections. GSL would invoke your lambda. Your lambda would invoke the std::function<>::operator() which in turn would inwoke some kind of virtual function that is used for type erasure which would in turn invoke the actual computation.

So, if you care about performance, you could get rid of a couple of layers there, specifically std::function. Here’s a another approach with a function template:

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

I guess I would prefer this over the std::function solution.

More Related Contents:

  1. how to avoid static member function when using gsl with c++
  2. Legality of COW std::string implementation in C++11
  3. What are the advantages of list initialization (using curly braces)?
  4. std::thread pass by reference calls copy constructor
  5. Static Data Member Initialization
  6. Difference between std::regex_match & std::regex_search?
  7. What does the standard library guarantee about self move assignment?
  8. Calling a function for each variadic template argument and an array
  9. C++ unordered_set of vectors
  10. Can returning a local variable by value in C++11/14 result in the return value being constructed by rvalue when no copy/move is involved?
  11. std::optional specialization for reference types
  12. What is decltype with two arguments?
  13. Lambda capture as const reference?
  14. C++11 member initializer list vs in-class initializer?
  15. Lifetime of lambda objects in relation to function pointer conversion
  16. Is there an automatic noexcept specifier?
  17. std::shared_ptr thread safety explained
  18. Check traits for all variadic template arguments
  19. Convert between string, u16string & u32string
  20. Has the new C++11 member initialization feature at declaration made initialization lists obsolete?
  21. What happens if ‘throw’ fails to allocate memory for exception object?
  22. What is the purpose of a declaration like int (x); or int (x) = 10;
  23. What is different between join() and detach() for multi threading in C++?
  24. std::thread error (thread not member of std)
  25. Advantage of using trailing return type in C++11 functions
  26. What is the purpose of std::function and how to use it?
  27. Idiomatic Way to declare C++ Immutable Classes
  28. const auto std::initializer_list difference between Clang and GCC
  29. Workaround for error C2536: cannot specify explicit initializer for arrays in Visual Studio 2013
  30. Is it possible to write an agile Pimpl in c++?

Leave a Comment