trjhtr

I've been finding myself wanting the following pattern recently:

void perform_async_operation(std::function<void(int)>);

class some_class 
 public:
 void foo() 
 perform_async_operation([this](int result) 
 data_ = result;
 );
 

 private:
 int data_;
;

Now, the issue here is that the lifetime of some_class if fully disconnected from when the callback will be invoked, and I do not want to move to shared ownership to put a shared_ptr in the lambda (like how the boost::ASIO examples handle that situation).

I do, however, have a saving grace: I know for certain that the callback will be invoked in the same thread that manages the lifetime of some_class.

In order to solve this, I've created a bastardized version of weak_ptr (with a matching equivalent of enabled_shared_from_this) that does not require the object to be managed by a shared_ptr in the first place.

#ifndef SLT_WEAK_REF_INCLUDED_H
#define SLT_WEAK_REF_INCLUDED_H

#include <memory>

template <typename T>
class weak_ref 
 public:
 weak_ref(std::shared_ptr<T*> weak_data) : weak_data_(std::move(weak_data)) 

 operator bool() const return *weak_data_ != nullptr; 
 T* operator->() const return *weak_data_; 

 private:
 // Can be safely assumed to always be set.
 std::shared_ptr<T*> weak_data_;
;

template <typename CRTP>
class enable_weak_ref 
 public:
 enable_weak_ref() = default;
 enable_weak_ref(enable_weak_ref&& rhs)
 : weak_data_(std::move(rhs.weak_data_)) 
 if (weak_data_) 
 *weak_data_ = this;
 
 

 enable_weak_ref& operator=(enable_weak_ref&& rhs) 
 weak_data_ = std::move(rhs.weak_data_);
 if (weak_data_) 
 *weak_data_ = static_cast<CRTP*>(this);
 
 

 // explicitely do nothing
 enable_weak_ref(enable_weak_ref const& rhs) 
 enable_weak_ref& operator=(enable_weak_ref const&) 

 ~enable_weak_ref() 
 if (weak_data_) 
 *weak_data_ = nullptr;
 
 

 weak_ref<CRTP> get_weak_ref() 
 if (!weak_data_) 
 weak_data_ = std::make_shared<CRTP*>(static_cast<CRTP*>(this));
 

 return weak_ref<CRTP>(weak_data_);
 

 private:
 // TODO: perhaps switch to a simple manually ref-counted type here.
 // instead of the overkill shared_ptr<>
 std::shared_ptr<CRTP*> weak_data_;
;

#endif

sample usage:

#include "weak_ref.h"

#include <queue>
#include <iostream>
#include <functional>

std::queue<std::function<void(int)>> queue_;

void queue_delayed(std::function<void(int)> cb) 
 queue_.emplace(std::move(cb));


class my_class : public enable_weak_ref<my_class> 
public:
 my_class() 
 queue_delayed([ref = get_weak_ref()](int v)
 if(ref) 
 std::cout << "passed " << v << std::endl;
 ref->value = v;
 
 else 
 std::cout << "saved " << v << std::endl;
 
 );
 

 int value = 0;
;

int main() 
 my_class a;
 queue_.front()(12);
 queue_.pop();
 
 my_class b;
 
 queue_.front()(5);
 queue_.pop();

 return 0;

Notes:

• Moving an object in a lambda is a C++14 feature, without which, a lot of back-and-forth ref-counting happens.


• As mentioned, this is intentionally not thread-safe. Thread safety can be added if anyone needs it eventually.

Issues:

• Is there a nicer way to tackle this I'm overlooking here?


• 
  weak_ref is very weak name, I'd gladly welcome better suggestions.


• As always, comments on general code quality are most desired.

I never saw a similar pattern so it was really interesting to understand your code !

First, about the name weak_ref, it implies that it has the syntax of a reference, but it is not the case (for instance, operator-> is for pointers). I personnaly named it something like ptr_to_instance.

Then, it seems the weak_ref should not be used on its own, without calling enable_weak_ref::get_weak_ref(). So I will make the weak_ref constructor private, making enable_weak_ref a friend. I will put the weak_ref class inside enable_weak_ref :

template<typename CRTP>
class enable_weak_ref 
 public:
 class weak_ref /**/ ;
 /**/
;

So instead of weak_ref<T> we have enable_weak_ref<T>::weak_ref. I think it makes more understandable the use of these classes.

Also, because weak_ref should not modify the pointer in weak_data_, I would use std::shared_ptr<T* const> so it is clear that this pointer is for read-only use.

If you do not want to use std::shared_ptr, you should create a int* (counting references), a CRTP** (which will hold this or nullptr) in enable_weak_ref, and weak_ref should have a int* const and a CRTP const* const (const specifier shows that weak_ref is linked to only one enable_weak_ref and can not be changed).