Why is "boost::function = boost::bind(...)" creating 13 temporaries?

Question

I have some pretty basic test code. I have a class that just logs all operations on it. I bound it to a boost::function object like this:

    void Function(const Foo&)
    {
        printf("Function invoked\n");
    }

    // ...

    boost::function<void(void)> func;
    {
        Foo f;
        printf("\nConstructing function\n");
        func = boost::bind(&Function, f);
        printf("Construction complete\n\n");
    }

I expect that the function object contains a copy of f. So creating at least one copy is mandatory. However, I find that I get 13 temporaries. Output is:

Constructing function
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::~Foo
Foo::Foo(const Foo&)
Foo::~Foo
Foo::~Foo
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::~Foo
Foo::~Foo
Foo::~Foo
Foo::~Foo
Foo::~Foo
Foo::Foo(const Foo&)
Foo::~Foo
Foo::Foo(const Foo&)
Foo::~Foo
Foo::~Foo
Foo::~Foo
Foo::~Foo
Construction complete

I can't use ref or cref because I do need it to make a copy of the object. Am I doing something horribly wrong? Or do I need to use a wrapper (like boost::shared_ptr) to avoid an absurd number of copies?

Full code and problem demonstration can be found on Codepad.

@NicolBolas Just compiling with `g++`, no special flags or options except `-O2`. Tried with and without c++11, no difference. — David Schwartz, Jan 31 '13 at 03:17
@chris: With `std::function` and `std::bind`, only [two temporaries](http://ideone.com/1aZ3VF) are created. — David Schwartz, Jan 31 '13 at 03:23
in my case boost::bind makes 14 copies and boost::function + std::bind makes 10 (gcc 4.7.2 -std=c++11 -O2). So it has to do with boost::function and boost::bind, not just boost::bind — nurettin, Jan 31 '13 at 06:58
I just had the same case and I was shocked http://stackoverflow.com/questions/20494516/boostbind-boostfunction-number-of-copies-of-value-passed-arguments . Have you tried using `std::function`? The performance is faaaar better (at least the copies are a lot fewer). +1 from me. — Kiril Kirov, Dec 10 '13 at 18:33

score 3 · Accepted Answer · answered Jan 31 '13 at 08:28

3

If you remove the "func = " assignment part the number of copies are lowered to 4 which is quite better than 13.

template <class F>
void callF(F fun)
{
}
callF(boost::bind(&func, fl));

So the solution is simple - don't use boost::function

answered Jan 31 '13 at 08:28

`boost::thread(boost::bind(&Function, q));` gives me 7 temporaries. – David Schwartz Jan 31 '13 at 08:42
`i.post(boost::bind(&Function, q));` gives 6 temporaries. – David Schwartz Jan 31 '13 at 08:50
hum, yes, in such case I think you were right to consider a shared_ptr if the object you are posting is not small enough to be faster passed by value or if you do not need too many of them. Test performance. – Jan 31 '13 at 09:10
1

I think you are right, the solution is to avoid `boost::function` if it all possible. If you can't, understand the costs. (Or go to c++11x) – David Schwartz Feb 02 '13 at 03:14

Why is "boost::function = boost::bind(...)" creating 13 temporaries?

1 Answers1

Linked