Unique_Ptr Implementation
As mentioned in the original comment you leak on assignment:

Unique_Ptr&lt;int&gt;   a = new int(1);
Unique_Ptr&lt;int&gt;   b;

a = b;  // You leak the original a pointer.


Looking at the assignment operator:

Unique_Ptr&amp; operator = (Unique_Ptr&amp;&amp; ob) noexcept {
    if (this != &amp;ob) {
        m_ptr = ob.m_ptr;     // Here you overwrite the current value.
                              // and thus leak its original value.
        ob.m_ptr = nullptr;
    }
    return *this;
}


As mentioned in the comments the standard way of implementing move semantics is:

Unique_Ptr(Unique_Ptr&amp;&amp; ob) noexcept
    : m_ptr(nullptr)
{
    swap(ob);
}
Unique_Ptr&amp; operator = (Unique_Ptr&amp;&amp; ob) noexcept
{
    swap(ob);
    return *this;
}


This has a couple of benefits. Calling the destructor is not required. You are moving the actual data to the other object. Thus means the destructor of the other object will correctly handle destruction.

This also potentially allows for re-use. If the ob is in some other context and you the object could be re-used this can help in optimizations. If it can not be-reused it will correctly be deleted.

You remove the pesimizing check for self assignment.

You don't have a conversion too bool.

if (a) {
    // A is holding a value you can do stuff with it.
}

// Now you can do
if (a.get()) {
    // A is holding a value you can do stuff with it.
}
// But its not as neat. And the context changes.


This is simply fixed with:

// Note the explicit (added in C++11) to replace the safe-bool idiom
explicit operator bool() {
    return m_ptr;
}


Can you guarantee that the destructor of type T does not throw?

void reset(T* ptr = nullptr) noexcept;


I think not. I agree it should be but that is not something you can guarantee and thus your code should not guarantee that it does not. So this should probably be:

void reset(T* ptr = nullptr);


You can probably do some meta-programming to determine if the destructor is noexcept but I don't have that in my head.

Don't mark your destructor as noexcept.

~Unique_Ptr() noexcept; // this is not needed.
                        // Destructors are automatically noexcept


Your destructor is automatically noexcept unless specific conditions are met so the compiler will work it out correctly for you.