hse seminar: smart pointers

#include <memory>
#include <iostream>
#include <vector>
using namespace std;


template<typename T>
class MySharedPtr {
private:
    void decrement_cnt() {
        if (cnt == nullptr) {
            return;
        }
        --(*cnt);
        if (*cnt == 0) {
            delete ptr;
            delete cnt;
            ptr = nullptr;
            cnt = nullptr;
        }
    }

    void increment_cnt() {
        if (cnt != nullptr)
            ++(*cnt);
    }

    T* ptr = nullptr;
    size_t* cnt = nullptr;

public:
    MySharedPtr() = default;

    MySharedPtr(T* _ptr) : ptr(_ptr) {
        if (ptr == nullptr) {
            return;
        }
        cnt = new size_t(1);
    }

    MySharedPtr(const MySharedPtr& other) {
        ptr = other.ptr;
        cnt = other.cnt;
        increment_cnt();
    }

    MySharedPtr(MySharedPtr&& other) {
        std::swap(ptr, other.ptr);
        std::swap(cnt, other.cnt);
    }

    MySharedPtr& operator=(const MySharedPtr& other) {
        if (this != &other) {
            decrement_cnt();
            ptr = other.ptr;
            cnt = other.cnt;
            increment_cnt();
        }
        return *this;
    }

    MySharedPtr& operator=(MySharedPtr&& other) {
        // может быть стоит написать std::swap как в конструкторе MySharedPtr(MySharedPtr&&)
        if (this != &other) {
            decrement_cnt();
            ptr = other.ptr;
            cnt = other.cnt;
            other.ptr = nullptr;
            other.cnt = nullptr;
        }
        return *this;
    }

    size_t use_count() const {
        if (cnt == nullptr) {
            return 0;
        }
        return *cnt;
    }

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

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

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

    ~MySharedPtr() {
        decrement_cnt();
    }
};



struct Resource {
    int id;
};

class ResourceManager {
public:
    ResourceManager(size_t maxCount): allResources(maxCount) {}

    shared_ptr<Resource> create() {
        for (auto& resource : allResources) {
            if (resource.expired()) {
                std::shared_ptr<Resource> ptr(new Resource);
                resource = ptr;
                return ptr;
            }
        }
        return nullptr;
    }
    size_t current_resources_count() const {
        size_t result = 0;
        for (const auto& resource : allResources) {
            if (!resource.expired()) {
                ++result;
            }
        }
        return result;
    }
private:
    vector<weak_ptr<Resource>> allResources;
};

int main() {
    /*std::weak_ptr<int> wPtr;
    {
        std::shared_ptr<int> ptr(new int(19));
        wPtr = ptr;
        std::cout << wPtr.expired() << " " << wPtr.use_count() << std::endl;
        {
            std::shared_ptr<int> ptr2 = ptr;
            std::cout << wPtr.expired() << " " << wPtr.use_count() << std::endl;
        }
        std::cout << wPtr.expired() << " " << wPtr.use_count() << std::endl;
        shared_ptr<int> ptr3 = wPtr.lock();
        std::cout << wPtr.expired() << " " << wPtr.use_count() << std::endl;
    }
    std::cout << wPtr.expired() << " " << wPtr.use_count() << std::endl;
    return 0;*/

    ResourceManager manager(3);
    std::cout << "current: " << manager.current_resources_count() << std::endl;

    auto a = manager.create();
    auto b = manager.create();
    auto c = manager.create();
    auto d = manager.create(); // nullptr
    c = nullptr;
    std::cout << "c: " << c.use_count() << std::endl;
    std::cout << "current: " << manager.current_resources_count() << std::endl; // 2

    auto e = manager.create(); // e != nullptr
    std::cout << "current: " << manager.current_resources_count() << std::endl; // 3
}