Vastly different things.
Remember that UObject pointers tagged as UProperties are reference counted so that whenever a UObject is no longer used anywhere, that object gets deleted by garbage collection. This means that if you have two UObjects referring to each other, they will always be using one another and therefore never get garbage collected. For instance, a controller might own a UI widget, but the widget needs access to the controller to poll certain values. In order to avoid these objects keeping each other alive, whichever widget is the “child” or dependent should refer to its parent through a weak pointer instead. Unlike regular pointers, weak pointers do not affect the reference counting, so that the controller can be deleted normally if everything else stops referring to it.
As the name says, TWeakObjectPtr is for objects, in this case specifically UObjects. There are many parts of the code where you might use native classes that don’t need to be UObjects. But if you just allocate such an object using “new FMyNonUObject()”, then you don’t get reference counting and the memory management advantages it brings. The engine therefore provides special pointer templates that do just this with non-UObjects. They are basically the UE4 version of std::shared_ptr. These pointer templates keep count of what is referring to the object and automatically delete the object so that memory is not leaked.
These templates are TSharedPtr and TSharedRef. The two are very similar, except that TSharedRef is treated like regular C++ references and can never be null or changed. You extract a TSharedRef by calling .ToSharedRef() on a valid TSharedPtr. If you try to do that on a null TSharedPtr, the engine will yell at you to enforce the validity of shared references. This can be very handy in certain parts of the code where you know for sure than an object will always exist and you don’t want to waste time null checking it.
Lastly, since all TSharedPtr and TSharedRef keep track of their references, you could end up with the same problem as with UObjects if you have two objects referring to each other. So the native non-refcounted equivalent of TWeakObjectPtr is TWeakPtr, which you build from a shared ref or shared ptr.
You cannot use UObjects with TSharedPtr/TSharedRef/TWeakPtr because they use a very different reference counting method. You can create a TSharedPtr by using MakeShareable, or making your class derive the TSharedFromThis template. Look throughout the engine code for examples of both.