1

I'm currently trying out a few of the new C++0x features, namely std::function and std::bind. These two functions seem rather suitable for a event-delegate-system for C++ that works like in C♯. I've tried myself to create something like delegates before, but the Hacks I would have needed for member-function-pointers were to much for me…

During my tests I noticed that std::bind copies every object you bind. While that surely enhances safety - can't delete a still registered eventhandler :) - it's also a problem with stateful objects. Is there a way to deactivate the copying - or at least a way to obtain the encapsulated object from the std::function again?

PS: Is there a reference for the features that are going to be included in C++0x (hopefully C++11!) In the end it's at major parts of TR1 and a few additions…

I tried cppreference.org, but they are still at an early stage at documentation, cplusplus.com on the other seems to not even have started on covering C++0x.

MFH
  • 1,664
  • 3
  • 18
  • 38
  • 1
    For now, you could always refer to the boost.bind and boost.function documentation. I've also found http://en.highscore.de/cpp/boost/ to be useful. – Ferruccio Mar 08 '11 at 17:05
  • thanks, I thought that the "new" implementations are derived from boost but were adapted… – MFH Mar 08 '11 at 17:34

3 Answers3

2

If you want to avoid copying use std::ref and/or std::cref. They wrap the object into a pseudoreference

Armen Tsirunyan
  • 130,161
  • 59
  • 324
  • 434
1

It isn't quite right that:

I noticed that std::bind copies every object you bind.

At least that isn't the intended specification. You should be able to move a non-copyable object into a bind:

std::bind(f, std::unique_ptr<int>(new int(3)))

However, now that the move-only object is stored in the binder, it is an lvalue. Therefore you can only call it if f accepts an lvalue move-only object (say by lvalue reference). If this is not acceptable, and if the source object outlives the binder, then use of std::ref is another good solution (as mentioned by Armen).

If you need to copy the bound object, then all of its bound arguments must be copyable. But if you only move construct the bound object, then it will only move construct its bound arguments.

The best reference is N3242. There isn't a good and comprehensive tutorial that I'm aware of yet. I might start with the boost documentation with the understanding that std::bind has been adapted to work with rvalue-refs as much as possible.

Howard Hinnant
  • 206,506
  • 52
  • 449
  • 577
  • I'll rephrase that: After binding an object I'm able to delete it and it is still called later when I'm calling the function -> ther must be a copy as the original object was deleted! – MFH Mar 08 '11 at 20:38
  • I recently had a question concerning this: http://stackoverflow.com/questions/5126219/is-there-a-reference-wrapper-for-rvalue-references (i.e rvalue ref forwarding with `std::bind`). – Johannes Schaub - litb Mar 09 '11 at 17:26
0

I have created a move compatable version of bind. there are still lots of problems with it like the binders constructor and a few buggylines here and there etc but it seems to work

check it out here http://code-slim-jim.blogspot.jp/2012/11/perfect-forwarding-bind-compatable-with.html

Ashley Smart
  • 2,098
  • 2
  • 13
  • 7