A type that can hold both Foo* and std::shared_ptr<Foo>

Question

What's the most convenient way to be able to store either std::shared_ptr or Foo* in the same type?

Foo* a = ...;
std::shared_ptr<Foo> b = ...;

Bar c = a; // Success, Bar type can hold Foo*
Bar d = b; // Success, Bar type can also hold std::shared_ptr<Foo>

std::variant<Foo*, std::shared_ptr< Foo>> is okay, but it's not possible to dereference it directly and that is kind of annoying. Is there a better way?

Answer 1

Just use a std::shared_ptr<Foo>.

While it is rarely useful, you can in fact construct a non-owning non-counting std::shared_ptr:

auto p = std::shared_ptr<Foo>{std::shared_ptr<void>(), raw_pointer};

---

If you want to cater to weird people disrespecting the abstraction (looking at the reference-counts, to be specific), you could also stash an eternal anchor somewhere and use that:

struct pass_t {
    template <class... T>
    constexpr int operator()(T&&...) noexcept
    { return 0; }
};
constexpr inline pass_t pass;

inline const std::shared_ptr<void> anchor {nullptr, pass};

auto p = std::shared_ptr<Foo>{anchor, raw_pointer};

Answer 2

Basically the same as Caleth's, but more generic and exposing the variant nature of that new type:

template <class... PointerTypes>
struct PointerHolder : std::variant<PointerTypes...> {
    using std::variant<PointerTypes...>::variant;
    
    auto *operator -> () const {
        return &operator*();
    }
    
    auto &operator * () const {
        return std::visit([](auto const &p) -> auto & { return *p; }, *this);
    }
};

See it live on Wandbox