How to safely use callbacks when the bound function could be deleted

Question

In the following code, we are creating an object, bind one function and call it before then after deleting the object.

This obviously leads to a segmentation fault as the underlying object was used after deletion.

In the context of a library providing callbacks for asynchronous data, how are we supposed to prevent callback functions to point to a nullptr?

You can test at cpp.sh/5ubbg

#include <memory>
#include <functional>
#include <iostream>

class CallbackContainer {
 public:
  std::string data_;
  CallbackContainer(std::string data): data_(data) {}
  ~CallbackContainer() {}
  void rawTest(const std::string& some_data);
};

void CallbackContainer::rawTest(const std::string& some_data) {
  std::cout << data_ << " " << some_data << std::endl;
}

int main(int /* argc */, char const** /* argv */) {
  std::unique_ptr<CallbackContainer> container;
  container.reset(new CallbackContainer("Internal data"));

  auto callback = std::bind(&CallbackContainer::rawTest, container.get(), std::placeholders::_1);
  callback("Before");
  std::cout << &callback << std::endl;
  container.reset();
  std::cout << &callback << std::endl;
  callback("After");
  return 0;
}

Returns:

> Internal data Before 
> 0x7178a3bf6570 
> 0x7178a3bf6570 
> Error launching program (Segmentation fault)

Answer 1

As a followup, we decided to use roscpp method which is similar to Alex Guteniev's proposition.

Instead of doing std::bind explicitly, we use it internally and keep the parent as std::weak_ptr<const void> pointer to the std::shared_ptr<P> (as it would conflict with unique_ptr).

The API looks like:

  std::shared_ptr<Container> container;
  queue.subscribe(&Container::callback_method, container);

The subscription function is as following with T the explicit type of the data (Class-wise) but P the implicit class of the Parent class (Container in this case).

template <class P>
std::shared_ptr<ThreadedQueue<T>> subscribe(void (P::*function_pointer)(std::shared_ptr<const T>), std::shared_ptr<P> parent, size_t queue_size = -1) {
  callback_ = std::bind(function_pointer, parent.get(), std::placeholders::_1);
  parent_ = std::weak_ptr<const void>(parent);
}

When calling the callback, we do the following check:

if(auto lock = parent_.lock()) {
  callback_(data);
}

Answer 2

The way I prefer while working with boost asio:

I faced the same issue while working with boost asio. We need to register callbacks to io_service and it was difficult to implement some sort of Manager class which manages lifetime of the objects we may create.

So, I implement something that was suggested by Michael Caisse in cppcon2016. I started passing the shared_ptr to the object to the std::bind.

I used to extend the lifetime of the object and in the callback, you can decide to either extend the lifetime of the object again (by registering the callback again) or let it die automatically.

std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
auto func = std::bind(&MyClass::MyMemFunc, this, ptr);
ptr.reset();

In the context of a library providing callbacks for asynchronous data, how are we supposed to prevent callback functions to point to a nullptr?

I wouldn't say that's the best solution but using by my above approach, you can detect if you need to proceed further in your callback or not.

It might not be the efficient way but it won't cause any undefined behavior.

void CallbackContainer::rawTest(const std::string& some_data, std::shared<CallbackContainer> ptr) 
{
    if (ptr.use_count() == 1) {
        // We are the only owner of the object.
        return; // and the object dies after this
    }
    std::cout << data_ << " " << some_data << std::endl;
}

EDIT:

An example code that shows how to do it using std::enable_shared_from_this:

#include <iostream>
#include <memory>
#include <functional>


class ABCD: public std::enable_shared_from_this<ABCD> {
public:
    void call_me_anytime()
    {
        std::cout << "Thanks for Calling Me" << std::endl;
    }

public:
    ABCD(void)
    {
        std::cout << "CONSTRUCTOR" << std::endl;
    }

    ~ABCD(void)
    {
        std::cout << "DESTRUCTOR" << std::endl;
    }
};

int main(void)
{
    auto ptr = std::make_shared<ABCD>();
    auto cb = std::bind(&ABCD::call_me_anytime, ptr->shared_from_this());
    ptr.reset();

    std::cout << "RESETING SHARED_PTR" << std::endl;
    std::cout << "CALLING CALLBACK" << std::endl;
    cb();
    std::cout << "RETURNING" << std::endl;
    return 0;
}

Output:

CONSTRUCTOR
RESETING SHARED_PTR
CALLING CALLBACK
Thanks for Calling Me
RETURNING
DESTRUCTOR

Answer 3

If you can share ownership, do this:

int main(int /* argc */, char const** /* argv */) {
  std::shared_ptr<CallbackContainer> container; // shared pointer
  container.reset(new CallbackContainer("Internal data"));
  // shared with functor
  auto callback = std::bind(&CallbackContainer::rawTest, container, std::placeholders::_1); 
  callback("Before");
  std::cout << &callback << std::endl;
  container.reset();
  std::cout << &callback << std::endl;
  callback("After");
  return 0;
}

If not, you should somehow pass invalidity to function object explicitly. This assumes that you know when container is deleted, and manually invalidate explicitly before that:

int main(int /* argc */, char const** /* argv */) {
  std::unique_ptr<CallbackContainer> container;
  container.reset(new CallbackContainer("Internal data"));
  std::atomic<CallbackContainer*> container_raw(container.get());
  auto callback = [&container_raw] (std::string data)
  {
    if (auto c = container_raw.load())
      c->rawTest(data);
  };
  callback("Before");
  std::cout << &callback << std::endl;
  container_raw.store(nullptr);
  container.reset();
  std::cout << &callback << std::endl;
  callback("After");
  return 0;
}

For asio cases, usually shared_from_this() is used, like std::bind(&MyClass::MyMemFunc, shared_from_this(), ptr);