#include <new>

template<typename T>
class unique_ptr {
private:
    T *ptr;
public:
    unique_ptr(T *ptr) : ptr(ptr) {}

    unique_ptr(const unique_ptr &) = delete;

    unique_ptr(unique_ptr &&another) noexcept {
        ptr = another.ptr;
        another.ptr = nullptr;
    };

    //Copying is not allowed
    unique_ptr &operator=(const unique_ptr &) = delete;

    unique_ptr &operator=(unique_ptr &&another) & noexcept {
        ~unique_ptr();
        ptr = another.ptr;
        another.ptr = nullptr;
    };

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

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

    ~unique_ptr() {
        delete ptr;
    }
};

template<typename T>
struct inner_ptr {
    T *ptr = nullptr; //Pointer to the object itself
    unsigned int shared_counter = 0; //how much shared_ptr is pointing to ptr
    unsigned int weak_counter = 0; //how much weak_ptr is pointing to ptr
    bool made = false;  //was shared_ptr constructed by make_shared or in ordinary way

};

template<typename T>
struct shared_ptr {
    //inner_ptr houses counter for how much shared_ptrs with common raw ptr exist

    inner_ptr<T> *inner;

    shared_ptr() = default;

    shared_ptr(inner_ptr<T> *inner) : inner(inner) {
        inner->shared_counter++;
    }

    //When constructing shared ptr from raw ptr, new 'colony' of shared_ptrs is created with new inner
    shared_ptr(T *ptr) {
        inner = new inner_ptr<T>;
        inner->shared_counter = 1;
        inner->ptr = ptr;
    }

    //inner_ptr is constructed on already allocated place - inner_ptr
    shared_ptr(T *ptr, void *inner_new) {
        inner = new(inner_new) inner_ptr<T>;
        inner->shared_counter = 1;
        inner->ptr = ptr;
        inner->made = true;
    }

    //Copy raw poiner, but increase shared_ptrs counter
    shared_ptr(const shared_ptr &another) {
        inner = another.inner;
        inner->shared_counter++;
    }

    //Copy pointer, but don't alter counter because we erase pointer from the old object
    shared_ptr(shared_ptr &&another) noexcept {
        inner = another.inner;
        another.inner = nullptr;
    }

    //Copy and swap logic: copy logic from constructor is used to avoid copypaste, old object destructs automatically
    //It is efficient in case of complicated copy and destruction logic
    shared_ptr &operator=(const shared_ptr &another) &{
        if (&another == this) {
            return *this;
        }
        shared_ptr copy(another);
        std::swap(copy, *this);
        return *this;
    }

    //Same, but with noexcept
    shared_ptr &operator=(shared_ptr &&another) & noexcept {
        if (&another == this) {
            return *this;
        }
        shared_ptr copy(another);
        std::swap(copy, *this);
        return *this;
    }

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

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

    ~shared_ptr() {
        inner->shared_counter--;
        //Memory is cleaned only when there is no shared_ptrs left that hold the same raw pointer
        if (inner->shared_counter == 0) {
            if (inner->weak_counter == 0) {
                //If shared_ptr is made from make_shared, then we can deallocate only one chunk of memory
                if (inner->made) {
                    inner->ptr->~T();
                    operator delete(inner, sizeof(inner_ptr<T>) + sizeof(T));
                } else {
                    delete inner->ptr;
                    delete inner;
                }
            } else {
                delete inner->ptr;
            }
        }
    }
};

template<typename T>
struct weak_ptr {
    inner_ptr<T> *helper;

    weak_ptr(const shared_ptr<T> &ptr) {
        helper = ptr.inner;
        ptr.inner->weak_counter++;
    }

    /* standard copy/move constructors/assignment operators */

    bool expired() const {
        return helper->shared_counter == 0;
    }

    shared_ptr<T> lock() const {
        if (expired()) {
            return shared_ptr<T>();
        }
        return shared_ptr(&helper);
    }

    ~weak_ptr() {
        helper->weak_counter--;
        if (helper->weak_counter == 0 && helper->shared_counter == 0) {
            delete helper;
        }

    }
};

template<typename T, typename... Args>
unique_ptr<T> make_unique(Args &&... args) {
    return unique_ptr(new T(std::forward<Args>(args)...));
}

template<typename T, typename... Args>
shared_ptr<T> make_shared(Args &&... args) {
    //allocate big chunk of memory for object and inner together
    char *p = new char[sizeof(T) + sizeof(inner_ptr<T>)];
    //Construct object
    T *ptr = new(p + sizeof(inner_ptr<T>)) T(std::forward<Args>(args)...);
    //Construct tweaked shared_ptr constructor that constructs inner_ptr on preallocated memory
    return shared_ptr(ptr, p);
}