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

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

public:
    // 1
    UniquePtr() : ptr{nullptr} {}
    // 2
    UniquePtr(T *p) : ptr{p} {}
    // 3
    UniquePtr(UniquePtr && p) : ptr(p.ptr) {
        p.ptr = nullptr;
    }
    // Copy constructor
    UniquePtr(const UniquePtr& p) noexcept = delete;
    // 4
    UniquePtr &operator=(std::nullptr_t p) {
        ptr = nullptr;
        return *this;
    }
    // 5
    UniquePtr &operator=(UniquePtr&& p) {
        this->reset(p.release());
        return *this;
    }
    // = exception
    UniquePtr &operator=(const UniquePtr& p) noexcept = delete;
    // 6
    ~UniquePtr() {
        reset(0);
    }
    // 7
    T &operator*() const {
        return *ptr;
    }

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

    T* operator->() {
        return ptr;
    }
    // 9
    T * release() {
        T* aux = ptr;
        ptr = nullptr;
        return aux;
    }
    // 10
    void reset(T *p) {
        T* aux = ptr;
        ptr = p;
        if (aux != nullptr)
            delete(aux);
    }
    // 11
    void swap(UniquePtr &p) {
        std::swap(ptr, p.ptr);
    }
    // 12
    T * get() const {
        return ptr;
    }
    // 13
    explicit operator bool() const {
        if (ptr) {
            return true;
        } else {
            return false;
        }
    }
};