Lazy shared pointer - assignment operator - c++

Question

I have created simple lazy shared pointer class. However, currently I can have only single instance of it and my design does not support copy assignment.
/// <summary>
/// Simple lazy shared pointer
/// Pointer is initialized when first needed
///
/// Create new instance with CreateLazy static method
///
/// Copy is disabled, pointer can only be moved
/// If we would copy it not initialized
/// then two instances can be created
/// - from original and from copy
/// </summary>
template <class T>
class LazySharedPtr{
public:
static LazySharedPtr<T> Create(){
std::function<std::shared_ptr<T>()> customInit = [](){
return std::make_shared<T>();
};
return LazySharedPtr(customInit);
};
template <typename ... Args>
static LazySharedPtr<T> Create(Args ... args){
return LazySharedPtr(std::forward<Args>(args) ...);
};
LazySharedPtr() :
init(nullptr),
ptr(nullptr){
};
LazySharedPtr(std::function<std::shared_ptr<T>()> customInit) :
init(customInit),
ptr(nullptr){
};
template <typename Y>
LazySharedPtr(LazySharedPtr<Y> && other) :
init(other.init),
ptr(other.ptr){
other.init = nullptr;
other.ptr = nullptr;
};
LazySharedPtr(const LazySharedPtr& other) = delete;
virtual ~LazySharedPtr() = default;
T* operator->(){
return InitAndGet().get();
}
const T* operator->() const{
return InitAndGet().get();
}
T* operator*(){
return InitAndGet().get();
}
const T* operator*() const{
return InitAndGet().get();
}
explicit operator bool() const noexcept{
return (ptr != nullptr);
}
explicit operator std::shared_ptr<T>() const{
return InitAndGet();
}
template <typename U>
friend class LazySharedPtr;
protected:
std::function<std::shared_ptr<T>()> init;
mutable std::shared_ptr<T> ptr;
template <typename ... Args>
LazySharedPtr(Args ... args) :
init([args = std::make_tuple(std::forward<Args>(args) ...)]() mutable {
return std::apply(std::make_shared<T, Args...>, std::move(args));
}),
ptr(nullptr){
};
std::shared_ptr<T>& InitAndGet() const {
if (!ptr) { ptr = init(); }
return ptr;
}
};
Do you have any idea, how to improve this to support copy assignment?
Current design does not support this:
class MyObject { };
LazySharedPtr<MyObject> t1 = LazySharedPtr<MyObject>::Create();
LazySharedPtr<MyObject> t2 = t1;
because after initialization of t2, t1 wont be inited.
I have thought to have internal shared_ptr as pointer to pointer and pass it around. However, with raw pointer I have to manage reference count and doing std::shared_ptr<std::shared_ptr<T>> seems weird. Or does not?
Do you have any other idea?

Answer 1

Here's a sketch - not tested, with missing pieces that should be easy to fill in. I hope the general idea is clear.
template <class T>
class LazySharedPtr {
struct ControlBlock {
std::shared_ptr<T> ptr;
std::function<std::shared_ptr<T>()> factory;
std::shared_ptr<T> InitAndGet() {
// Add thread safety here.
if (!ptr) {
ptr = factory();
factory = nullptr;
}
return ptr;
}
};
std::function<std::shared_ptr<T>()> init;
// This member is not strictly necessary, it's just a cache.
// An alternative would be to call `init` every time.
std::shared_ptr<T> ptr;
public:
// For exposition, assume all `T`s are constructible from `int`
LazySharedPtr(int x) {
auto control = std::make_shared<ControlBlock>();
control->factory = [x]() { return std::make_shared<T>(x); };
init = [control]() {return control->InitAndGet(); }
}
template <typename U>
LazySharedPtr(const LazySharedPtr<U>& other)
: ptr(other.ptr) {
if (!ptr) {
auto other_init = other.init;
init = [other_init]() { return std::shared_ptr<T>(other_init()); };
}
}
std::shared_ptr<T> InitAndGet() {
if (!ptr) {
ptr = init();
init = nullptr;
}
return ptr;
}
};
Basically, type erasure all the way down.