Есть ли способ предотвратить передачу «нового T» моему конструкторуObserver_ptr?

Невозможно поставить такое ограничение на параметр конструктора. Если взять указатель, то это может быть любой указатель (совместимого типа).

Однако, на мой взгляд, это не то, что вы должны применять с языком, а скорее с контрактом и намерением класса, потому что, если вы посмотрите на классы интеллектуальных указателей, они также принимают любой тип указателя и полностью полагаются на документацию и здравый смысл, когда дело доходит до какой указатель они берут:

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

Кроме того, необработанный указатель T* — это обычный способ выражения некоторого указателя, которым объект не владеет. Так что, возможно, вы заново изобретаете колесо и, возможно, захотите переосмыслить это намерение.

Если вы принимаете входной указатель T* с помощью неконстантной ссылки, пользователи не могут вызывать new непосредственно в вызове конструктора, поскольку ссылка не сможет привязаться к временному объекту, который возвращает new, например:

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

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

Вместо этого им потребуется использовать локальную переменную T*, чтобы они лучше осознавали свою ответственность за время жизни создаваемого объекта, например:

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

Обратите внимание, однако, что этот подход не позволяет пользователям напрямую наблюдать за нединамическими объектами, адреса которых берутся operator& или std::addressof(), а также объектами unique_ptr и shared_ptr, например:

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!

Это также потребует использования локального указателя T*, например:

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!

Вы можете избежать этого, если добавите дополнительные конструкторы к observer_ptr, например:

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!

Так или иначе, вам нужно будет передать (умный) указатель или ссылку для создания observer_ptr, и пользователь всегда сможет это испортить. Вы могли бы сделать так, чтобы пользователь состояния вашего заголовка был более очевидным, несмотря на то, что он намеревается сделать, и, надеюсь, заставить его достаточно подумать о коде, который он пишет, чтобы самостоятельно поймать ошибку.

Вы можете добиться этого, добавив функцию для создания observer_ptr и потребовав ее использования через ограничения видимости. В следующем примере пользователь должен использовать make_unowned_ptr(...) для создания observer_ptr для чего угодно, кроме нулевого указателя:

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
}