Question

If I do this :-

class Thing  
{
    ...
    void function (const std::string& message);
};

std::list<std::function<void()>> work;

and in some member of “Thing”

work.push_back(std::bind(&Thing::function, this, "Hello"));

Does either the call to std::bind or the use of std::function<> cause any dynamic memory allocation using new or otherwise? Or is all the storage allocated at compile time? If the standard doesn’t say anything, what about in visual studio 2012 as my program will only need to build on there, and for efficiency I probably need to avoid dynamic memory allocations in the place where I am thinking of using this mechanism.

Answer 1

The standard doesn’t specify, but in general it’s easy to see that std::function must allocate memory at least in some cases:

struct huge { char c[10000]; };
void foo(const huge &);
std::function<void()>{std::bind(foo, huge{})};

On the other hand it’s possible for it to avoid allocation in at least some cases by siting its function object inside a preallocated buffer inside the function object’s footprint; obviously there is a tradeoff as this could make other uses take more stack memory. A good implementation would be able to avoid memory allocation when storing a raw function pointer in a function object, and possibly also for a mem_fn, but it’s less likely that it’d do so for a bind.

For example, libstdc++ (g++) inlines (functor) object pointers, function pointers, and (non-virtual) member function pointers, as well as anything else that’d fit in the same footprint, e.g. stateless functors (union _Nocopy_types).

If you can, by inverting your control flow to accept templated functor objects instead of function you can avoid any extra memory allocation:

template<typename F>
void my_algorithm(const F &);
my_algorithm(std::bind(foo, huge{}));