Pointers in Qt look naked, but they are not. As said before widgets own all their child widgets and handle them being cleaned up. And certainly there is a place in C++ for non-owning raw pointers. Don't use shared_ptr in every single place. If you call a function it is okay if it expects a raw pointer while you have the shared_ptr. If you start copying the shared_ptr into every function you call you will loose a lot of performance. Sure, you can use a const std::shared_ptr & instead, but that is also defeating the purpose and no different than raw pointers. Raw pointers are not evil, but owning raw pointers are.
In your tiny example the raw pointer is owning for just a very short time (most likely only for the the two lines if there is nothing in between). If you want to be pedantic you could follow the approach of @IgKh and use a std::unique_ptr. But, it is most certainly mandatory to use std::make_unique to create the object. Otherwise allocation might still fail and throw an exception and the unique_ptr does not become the owner and the destructor of partially created objects (if you are using inheritance) are not called. You see from this that just using smart pointers does not always solve the problem because you can still use them wrong if you don't understand everything about them. And there is very little gain in your specific case in using a smart pointer (correctly). And for most programs it is true that they don't catch out-of-memory errors and handle them properly to free up some memory.
I would personally never use smart pointers with Qt widget types. (Unless Qt in new versions rewrites their library to make them mandatory.)
