Is there a way to prevent passing "new T" to my observer_ptr constructor?

I want to implement my own observer_ptr class which I want to use to indicate no ownership of a pointer. I'm wondering if it'd be possible to somehow prevent someone from using the following syntax:

observer_ptr<T> var_name(new T);

since it would completely invalidate the whole purpose of this class and lead to memory leaks. My guess would be that I would have to delete/make private a certain type of constructor, but I don't know what argument type I should choose to achieve that.

I'm not writing any sharable library, I'm asking more for myself so I can learn.

If you accept the input T* pointer by a non-const reference, users can't call new directly in the constructor call, as the reference won't be able to bind to the temporary that new returns, eg:

template <typename T>
class observer_ptr
{
public:
    observer_ptr(T*& ptr);
    ...
};

observer_ptr<T> var_name(new T); // error!

They would be required to use a local T* variable instead, making them more aware of their responsibility for the lifetime of the object they create, eg:

T *ptr = new T;
observer_ptr<T> var_name(ptr); // OK!

Note, however, that this approach does prevent users from being able to directly observe non-dynamic objects whose addresses are taken by operator& or std::addressof(), as well as unique_ptr and shared_ptr objects, eg:

T obj;
observer_ptr<T> var_name(&obj); // error!

auto ptr = make_unique<T>(); // or make_shared()
observer_ptr<T> var_name(ptr.get()); // error!

This would also require the use of a local T* pointer, eg:

T obj;
T* ptr = &obj;
observer_ptr<T> var_name(ptr); // OK!

auto obj = make_unique<T>(); // or make_shared()
T* ptr = obj.get();
observer_ptr<T> var_name(ptr); // OK!

You can avoid that if you add some additional constructors to observer_ptr, eg:

template <typename T>
class observer_ptr
{
private:
    T* m_ptr;
public:
    observer_ptr(T*& ptr) : m_ptr(ptr) {}
    observer_ptr(T& obj) : m_ptr(addressof(obj)) {}
    observer_ptr(const unique_ptr<T>& ptr) : m_ptr(ptr.get()) {}
    observer_ptr(const shared_ptr<T>& ptr) : m_ptr(ptr.get()) {}
    observer_ptr(unique_ptr<T>&&) = delete;
    observer_ptr(shared_ptr<T>&&) = delete;
    ...
};

T obj;
observer_ptr<T> var_name(obj); // OK!

auto ptr = make_unique<T>(); // or make_shared()
observer_ptr<T> var_name(ptr); // OK!

observer_ptr<T> var_name(make_unique<T>()); // error!

observer_ptr<T> var_name(make_shared<T>()); // error!

It's impossible to put such a restriction on the constructor parameter. If you take a pointer, it can be any pointer (of compatible type).

However in my opinion it's not something you should enforce with the language, but rather with a contract and the class intention, because if you look at smart pointer classes they also accept any pointer type and completely rely on documentation and common sense when it comes to what kind of pointer they take:

int stackValue;
std::unique_ptr myPtr{ &stackValue }; // it will be UB upon myPtr destruction but compiles anyway

Also, a raw pointer T* is conventional way of expressing some pointer an object doesn't own. So you might be re-inventing the wheel here and may want to rethink this intention.

One way or another you'll need to be able to pass a (smart) pointer or a reference to create an observer_ptr and the user will always be able to screw this up. You could make the user of your header state in a more obvious way though what they intend to do and hopefully have them think enough about the code they're writing to catch the error themselves.

You could accomplish this by adding a function for creating the observer_ptr and requiring its use via visibility restrictions. The following example requires the user to use make_unowned_ptr(...) for creating an observer_ptr for anything other than a null pointer:

template<class T>
class observer_ptr;

template<class T>
constexpr observer_ptr<T> make_unowned_ptr(T* ptr)
{
    return { ptr };
}

template<class T>
class observer_ptr
{
    T* m_ptr;

    constexpr observer_ptr(T* ptr)
        : m_ptr(ptr)
    {
    }

    friend constexpr observer_ptr<T> make_unowned_ptr<T>(T*);
public:
    constexpr observer_ptr(std::nullptr_t = nullptr)
        : m_ptr(nullptr)
    {
    }
};

int main()
{
    int value = 1;
    observer_ptr<int> ptr1(&value); // compiler error: constructor not visible
    auto ptr2 = make_unowned_ptr(&value); // ok
}