Re: Work-around for missing "move-capture" syntax in C++0x

From:

SG <s.gesemann@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sun, 19 Dec 2010 04:53:14 -0800 (PST)

Message-ID:

<5e397192-54fe-437d-974b-9cdb980124e9@q18g2000vbm.googlegroups.com>

On 19 Dez., 13:19, Bo Persson wrote:

SG wrote:

   void foo() {
       unique_ptr<big> p (new big);
       // ... set up *p
       invoke_later([=]{ // <-- Oops! unique_ptr cannot be co=

pied.

           // work on *p
       });
   }

Isn't that a good thing? Why use a unique_ptr if you really want to
have copies?

Who says I'm interested in copying it? I just want to be able to move
things into a lambda function object. In other words, C++0x lacks a
std::move-equivalent of the capture-clause. This bugged me for quite a
while and I even informally proposed a syntax for that:

    template<class Fun>
    void invoke_later(Fun && f)
    {
        // jobqueue could be a vector<function<void()>>
        jobqueue.emplace_back(std::forward<Fun>(f));
    }

    void foo() {
        unique_ptr<big> p (new big);
        // ... set up *p
        invoke_later([-p]{ // "move-capture"
            // work on *p
        });
    }

But the chance that something like this is going to make it into C++0x
this late in the game is probably zero.

On the upside, we can work around this lacking "move-capture" via
std::bind. It may or may be obvious to most. This std::bind work-
around just dawned on me and I thought it would be worth sharing.

Cheers!
SG