Question

I’d like to use lambda functions to asynchronously call a method on a reference counted object:

void RunAsync(const std::function<void()>& f) { /* ... */ }

SmartPtr<T> objPtr = ...
RunAsync([objPtr] { objPtr->Method(); });

Creating the lambda expression obviously creates a copy but I now have the problem that converting the lambda expression to a std::function object also creates a bunch of copies of my smart pointer and each copy increases the reference count.

The following code should demonstrate this behavior:

#include <functional>

struct C {
    C() {}
    C(const C& c) { ++s_copies; }

    void CallMe() const {}

    static int s_copies;
};

int C::s_copies = 0;

void Apply(const std::function<void()>& fct) { fct(); }

int main() {
    C c;
    std::function<void()> f0 = [c] { c.CallMe(); };
    Apply(f0);
    // s_copies = 4
}

While the amount of references goes back to normal afterwards, I’d like to prevent too many referencing operations for performance reasons. I’m not sure where all these copy operations come from.

Is there any way to achieve this with less copies of my smart pointer object?

Update: Compiler is Visual Studio 2010.

Answer 1

std::function probably won’t be as fast as a custom functor until compilers implement some serious special treatment of the simple cases.

But the reference-counting problem is symptomatic of copying when move is appropriate. As others have noted in the comments, MSVC doesn’t properly implement move. The usage you’ve described requires only moving, not copying, so the reference count should never be touched.

If you can, try compiling with GCC and see if the issue goes away.