C++ Return a functor object as std::function

Question

I have a factory method returning a std::function

class Builder {
public:
    function<void(Data&)> build();
}

and a functor object

class Processor {
protected:
    vector<int> content_;
public:
    void operator()(Data&) { 
         ....
    }
}

Now I want to return the functor in the factory method, and I write

function<void(Data&)> build() {
    Processor p;
    // Add items to p.content_

    function<void(Data&)> ret(p);

    return ret;
}

My question is: will ret maintain a copy of p? If so, when p.content_ is large, will that become a burden? What will be a suggested way to implement this?

Use `void operator()(Data&&)` and `function ret(std::move(p));`. You'll need to implement move constructor (remember also rule of 5) for `Processor` class. — Coral Kashri, Jun 06 '20 at 19:59
Hmm.. shouldn't the synthesised move ctor be enough? Rule of zero! You do need to return `std::move(ret)` though — Asteroids With Wings, Jun 06 '20 at 20:02
@AsteroidsWithWings Moving from a local on return [is implicit](https://stackoverflow.com/a/14856553/501250). — cdhowie, Jun 06 '20 at 20:03
Your code is OK as written (assuming you don't mind `Processor` being copied). Indeed, `ret` makes a copy of `p`. You could have it moved instead with `function ret(std::move(p))` — Igor Tandetnik, Jun 06 '20 at 20:03
@AsteroidsWithWings I'm pretty sure that the return value optimization take care for `std::move(ret)`. — Coral Kashri, Jun 06 '20 at 20:05

Guillaume Racicot · Accepted Answer · 2020-06-06T20:13:12.260

4

A std::function hold and own its value. In fact, it requires callable object that are copiable so it can copy it when itself is copied.

Your function would be perfectly fine like this, and potentially faster:

function<void(Data&)> build() {
    Processor p;

    // fill items

    return p; // p moved into the returned std::function (since C++14)
}

However, if you copy the std::function around, the Processor object will be copied too, so the cost of copying the std::function depends on the type it contains (just as with any type erasure tools)

edited Jun 06 '20 at 20:13

answered Jun 06 '20 at 20:08

Guillaume Racicot

39,621
9
77
141

Thanks for answering. I also need to make changes to the local variable p (e.g., adding items to its content) so I need the local variable to be there. – Harper Jun 06 '20 at 20:10
@Harper I just added the last paragraph. Hope it helps – Guillaume Racicot Jun 06 '20 at 20:17

score 2 · Answer 2 · answered Jun 06 '20 at 20:10

The constructor that will be used is this:

template< class F >
function( F f );

You can see that the object will be copied. If you want to avoid this, you can move the callable:

function<void(Data&)> ret(std::move(p));

The constructor will then move f to the internal storage.

If your callable is small, it will be stored directly in the function object. If it is too large, the internal storage will be allocated dynamically. Either way, moving resulting function object should be no more complex than moving the original callable object (when stored directly in the function) or probably even cheaper (when stored dynamically).

Copying should be avoided when performance is important, as it might involve dynamic allocations even if your callable doesn't need them.

C++ Return a functor object as std::function

2 Answers2