Is there a never-null unique owner of heap allocated objects?

Question

Currently, I'm storing a collection of std::unique_ptrs to heap allocated objects of a polymorphic type:

struct Foo {
  virtual ~Foo() = default;
};
Collection<std::unique_ptr<Foo>> foos;

The basic interface I need is putting / taking owners of Foo to / from foos. The objects stored in foos are never supposed to be nullptr so I'd like to replace runtime assert(owner_taken) with compile-time checks. Moreover, I would like to be capable of using non-null owners in the context where a nullable one may be expected.

Probably, I need to store something like unique_ref but how would I extract one from foos? I don't want a copy, I want the stored object itself, so owner->clone() isn't a solution. Neither I can std::move(owner) because the state of a "unique reference" would be invalid afterwards.

Is there a clean design decision?

Answer 1

Is there a never-null unique owner of heap allocated objects?

There is no such type in the standard library.

It is possible to implement such type. Simply define a type with unique_ptr member and mark the default constructor deleted. You can mark constructor from std::nullptr_t deleted also so that construction from nullptr will be prevented at compile time.

Whether you construct from an external pointer, or allocate in the constructor, there is no alternative for checking for null at runtime.

Answer 2

Reading your question, I interpret the following requirements:

1. You don't want to copy or move the object itself (Foo)
2. You don't want a wrapper which has some sort of empty state which excludes move semantics
3. The object itself (Foo) should be stored on the heap such that its lifetime is independent of the control flow
4. The object itself (Foo) should be deleted once it is not used any more

As construction / destruction, copy and move are the only ways to get objects into / out of a container, the only thing left is a wrapper object which is copied when moved into / out of the container.

You can create such an object yourself as follows:

// LICENSE: MIT

#include <memory>
#include <utility>

template<typename T>
class shared_ref {
public:
    template<typename ...Args>
    shared_ref(Args&&... args)
        : data{new T(std::forward<Args>(args)...)} 
    {}
    shared_ref(shared_ref&&) = delete;
    shared_ref& operator=(shared_ref&&) = delete;

    T& get() noexcept {
        return *data;
    }
    const T& get() const noexcept {
        return *data;
    }

    operator T&() noexcept {
        return get();
    }
    operator const T&() const noexcept {
        return get();
    }

    void swap(shared_ref& other) noexcept {
        return data.swap(other);
    }

private:
    std::shared_ptr<T> data;
};

template<class T>
void swap(shared_ref<T>& lhs, shared_ref<T>& rhs) noexcept {
    return lhs.swap(rhs);
}

I leave it as an exercise to the reader to add support for Allocator, Deleter, operator[], implicit conversion contructor to base classes.

This can then be used as follows:

#include <iostream>

int main() {
    shared_ref<int> r;  // default initialized
    std::cout << "r=" << r << std::endl;
    r = 5;  // type conversion operator to reference
    std::cout << "r=" << r << std::endl;

    shared_ref<int> s{7};  // initialized with forwarded arguments
    std::cout << "s=" << s << std::endl;

    std::swap(r, s);
    std::cout << "r=" << r << ", " << "s=" << s << std::endl;

    s = r;  // copy assignment operator
    std::cout << "s=" << s << std::endl;

    const shared_ref<int> t{s}; // copy constructor
    std::cout << "t=" << t << std::endl;
    //t = 8;  // const ref from a const object is immutable
    
    return 0;
}