#include <cstddef>
#include <iostream>

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

public:
    UniquePtr(): ptr(nullptr) {
//        std::cout << "UniqPtr()\n";
    }

    UniquePtr(T *ptr): ptr(ptr) {
//        std::cout << "UniqPtr(T *ptr)\n";
    }

    UniquePtr(UniquePtr<T> &&oth) {
//        std::cout << "UniqPtr(&&oth)\n";
        *this = nullptr;
        std::swap(ptr, oth.ptr);
    }

    UniquePtr(const UniquePtr &oth) = delete;

    UniquePtr& operator=(const UniquePtr<T> &oth) = delete;

    UniquePtr& operator=(UniquePtr<T> &&oth) {
//        std::cout << "operator=(&&oth)\n";
        *this = nullptr;
        std::swap(ptr, oth.ptr);
        return *this;
    }

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

    T& operator*() noexcept {
        return *ptr;
    }

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

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

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

    void reset(T * p) {
        *this = nullptr;
        ptr = p;
    }

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

    T* get() const {
        return ptr;
    }

    explicit operator bool() const noexcept {
        return ptr != nullptr;
    }

    ~UniquePtr() {
//        std::cout << "~UniqPtr()\n";
        delete ptr;
    }
};