How is std::function implemented?

by

The implementation of std::function can differ from one implementation to another, but the core idea is that it uses type-erasure. While there are multiple ways of doing it, you can imagine a trivial (not optimal) solution could be like this (simplified for the specific case of std::function<int (double)> for the sake of simplicity):

struct callable_base {
   virtual int operator()(double d) = 0;
   virtual ~callable_base() {}
};
template <typename F>
struct callable : callable_base {
   F functor;
   callable(F functor) : functor(functor) {}
   virtual int operator()(double d) { return functor(d); }
};
class function_int_double {
   std::unique_ptr<callable_base> c;
public:
   template <typename F>
   function(F f) {
      c.reset(new callable<F>(f));
   }
   int operator()(double d) { return c(d); }
// ...
};

In this simple approach the function object would store just a unique_ptr to a base type. For each different functor used with the function, a new type derived from the base is created and an object of that type instantiated dynamically. The std::function object is always of the same size and will allocate space as needed for the different functors in the heap.

In real life there are different optimizations that provide performance advantages but would complicate the answer. The type could use small object optimizations, the dynamic dispatch can be replaced by a free-function pointer that takes the functor as argument to avoid one level of indirection… but the idea is basically the same.

Regarding the issue of how copies of the std::function behave, a quick test indicates that copies of the internal callable object are done, rather than sharing the state.

// g++4.8
int main() {
   int value = 5;
   typedef std::function<void()> fun;
   fun f1 = [=]() mutable { std::cout << value++ << '\n' };
   fun f2 = f1;
   f1();                    // prints 5
   fun f3 = f1;
   f2();                    // prints 5
   f3();                    // prints 6 (copy after first increment)
}

The test indicates that f2 gets a copy of the callable entity, rather than a reference. If the callable entity was shared by the different std::function<> objects, the output of the program would have been 5, 6, 7.

More Related Contents:

  1. Declaring lambda with int type not working [closed]
  2. What is a lambda expression in C++11?
  3. Is it possible to figure out the parameter type and return type of a lambda?
  4. C++11 does not deduce type when std::function or lambda functions are involved
  5. Recursive lambda functions in C++11
  6. Passing capturing lambda as function pointer
  7. What is the type of lambda when deduced with “auto” in C++11?
  8. How to convert a lambda to an std::function using templates
  9. Resolving ambiguous overload on function pointer and std::function for a lambda using + (unary plus)
  10. Bind Vs Lambda?
  11. Capturing a reference by reference in a C++11 lambda
  12. C++11 lambda implementation and memory model
  13. Can lambda functions be templated?
  14. Inferring the call signature of a lambda or arbitrary callable for “make_function”
  15. I cannot pass lambda as std::function
  16. Lambda capture as const reference?
  17. Lifetime of lambda objects in relation to function pointer conversion
  18. Why can’t I capture this by-reference (‘&this’) in lambda?
  19. std::remove_if – lambda, not removing anything from the collection
  20. Lambda functions as base classes
  21. Are lambdas inlined like functions in C++?
  22. How can I pass a C++ lambda to a C-callback that expects a function pointer and a context?
  23. Specializing a template on a lambda in C++0x
  24. C++11 Change `auto` Lambda to a different Lambda?
  25. how to specify vc11 lambda calling convention
  26. Proper way to receive a lambda as parameter by reference
  27. When to use functors over lambdas
  28. Why can’t C++11 move a noncopyable functor to a std::function?
  29. Using Boost adaptors with C++11 lambdas
  30. When can we omit the return type in a C++11 lambda?

Leave a Comment