#include <iostream>
#include <string>
#include <cstring>
#include <cstddef>

template <typename T>
class TSharedPtr {
public:
    TSharedPtr():
        ptr_(nullptr),
        cnt_(nullptr)
    {}

    TSharedPtr(T* ptr):
        ptr_(ptr),
        cnt_(new size_t(1))
    {}

    TSharedPtr(const TSharedPtr &other):
        ptr_(nullptr),
        cnt_(nullptr)
    {
        ptr_ = other.ptr_;
        cnt_ = other.cnt_;

        if (cnt_) {
            ++*cnt_;
        }
    }

    ~TSharedPtr() {
        if (!cnt_) {
            return;
        }
        --*cnt_;
        if (*cnt_) {
            return;
        }
        delete cnt_;
        delete ptr_;
    }

    TSharedPtr& operator = (const TSharedPtr &other) {
        if (this == &other) {
            return *this;
        }

        TSharedPtr tmp(*this);

        if (cnt_) {
            --*cnt_;
            ptr_ = nullptr;
        }

        ptr_ = other.ptr_;
        cnt_ = other.cnt_;
        if (cnt_) {
            ++*cnt_;
        }

        return *this;
    }

    T& operator * () {
        return *ptr_;
    }

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

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

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

    T* Get() {
        return ptr_;
    }

    const T* Get() const {
        return ptr_;
    }

    size_t* Count() const {
        return cnt_;
    }

    operator bool () const {
        return ptr_;
    }
private:
    T* ptr_;
    size_t* cnt_;
};

template <typename T>
bool Equal(const T& left, const T& right, std::string name) {
    if (left == right) {
        std::cout << name << " OK: " << left << " == " << right << std::endl;
        return true;
    } else {
        std::cout << name << " FAIL: " << left << " == " << right << std::endl;
        return false;
    }
}

bool test() {
    bool ok = true;
    {
        TSharedPtr<int> ptr;
        ok &= Equal<int *>(ptr.Get(), nullptr, "default constructor ptr");
        ok &= Equal<size_t *>(ptr.Count(), nullptr, "default constructor cnt");
    }
    {
        struct CheckDestruct {
            CheckDestruct(bool &destruct):
                destruct_(destruct)
            {}
            ~CheckDestruct() {
                destruct_ = true;
            }
            bool &destruct_;
        };
        bool destruct = false;
        {
            TSharedPtr<CheckDestruct> ptr(new CheckDestruct(destruct));
        }
        ok &= Equal<bool>(destruct, true, "default destructor");
    }
    return ok;
}

int main(int argc, char **argv) {
    if (argc == 2 && !strcmp(argv[1], "--test")) {
        return !test();
    }
}

struct Uncopyable {
    Uncopyable(const Uncopyable &) = delete;
    Uncopyable& operator = (const Uncopyable &) = delete;
};


class MyClass {
    ...
};

typedef std::unique_ptr<MyClass> MyClassRef;