#include <iostream>
#include <algorithm>
#include <cstddef>

template <typename T>
class UniquePtr {
private:
    T* ptr;

public:
    UniquePtr() :ptr(nullptr) {}

    UniquePtr(T *p) : ptr(p) {}

    UniquePtr(UniquePtr && p) : ptr(p.ptr) {
        p.ptr = nullptr;
    }

    UniquePtr(const UniquePtr & p) noexcept = delete;

    T * release() {
        T *tmp = ptr;
        ptr = nullptr;
        return tmp;
    }

    void reset(T *p) {
        T* tmp = ptr;
        ptr = p;
        if (tmp != nullptr) {
            delete(tmp);
        }
    }

    ~UniquePtr() {
        reset(0);
    }

    UniquePtr &operator=(UniquePtr&& p) {
        this->reset(p.release());
        return *this;
    }

    UniquePtr &operator=(const UniquePtr& p) noexcept = delete;

    UniquePtr& operator = (std::nullptr_t p) {
        ptr = nullptr;
        return *this;
    }

    T operator*() const {
        return *ptr;
    }

    T operator*() {
        return *ptr;
    }

    T * operator->() const {
        return ptr;
    }

    T * operator->() {
        return ptr;
    }

    void swap(UniquePtr &p) {
        std::swap(ptr, p.ptr);
    }

    T * get() const {
        return ptr;
    }

    explicit operator bool() const {
        if (ptr != 0) {
            return true;
        } else {
            return false;
        }
    }
};