有没有办法对不可复制的对象使用增强信号和插槽？

Question

I would like to pass a non-copyable object to a boost signal. See the code below (doesn't compile). Is there a possible workaround?

#include <boost/signals2.hpp>
#include <iostream>
#include <memory>

struct MySlot
{
  void operator()(std::unique_ptr<int>&& input) const
  {
    std::cout << "Signaled " << *input.get();
  }
};

int main(int argc, char* argv[])
{
  boost::signals2::signal<void(std::unique_ptr<int>)> signal;

  signal.connect(MySlot());

  auto ptr = std::make_unique<int>(20);
  signal(std::move(ptr));
}

Answer 1

UPDATE I misunderstood the question. You didn't want the handler types itself to be non-copyable, but rather their arguments.

The answer is: No, signals2 is is not move-aware.

NOTE In general, you should not have this situation, because many connections can subscribe to the same slot and you can only move from the parameter once. In all likelihood, you're better of passing a copy/const reference:

#include <boost/signals2.hpp>
#include <iostream>
#include <memory>

struct MySlot
{
    void operator()(std::unique_ptr<int> const& input) const
    {
        std::cout << "Signaled " << *input.get();
    }
};

int main()
{
    boost::signals2::signal<void(std::unique_ptr<int> const&)> signal;

    signal.connect(MySlot());

    auto ptr = std::make_unique<int>(20);
    signal(ptr);
}

You can use the usual approaches:

---

Old answer:

Use std::ref or std::cref

These wrappers transparently forward the function call operator.

The onus of making sure the lifetime of the non-copyable callable exceeds that of the connection is on you.

Make your own wrapper that's lifetime aware

You can make a callable object wrapper that stores the non-copyable object and forwards the function call operator, like std::reference_wrapper<> did. This time, though, you could store the object as a shared_ptr<> so the lifetime is automatically managed.