my_shared_ptr_no_heap.cc

my_shared_ptr_no_heap.cc

#include <iostream>
#include <memory>
#include <string>
#include <vector>

template <typename T>
class my_shared_ptr {
public:
    my_shared_ptr(T* raw_ptr)
        : raw_ptr_(raw_ptr),
          ref_count_value_(1),
          ref_count_(&ref_count_value_) {

    }

    my_shared_ptr(const my_shared_ptr<T>& other)
        : raw_ptr_(other.raw_ptr_),
          ref_count_(other.ref_count_) {
        inc();
    }

    ~my_shared_ptr() {
        dec();
    }

    my_shared_ptr<T>& operator=(const my_shared_ptr<T> other) {
        dec();

        raw_ptr_ = other.raw_ptr_;
        ref_count_ = other.ref_count_;

        inc();

        return *this;
    }

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

protected:
    void inc() {
        ++*ref_count_;
    }

    void dec() {
        if (*ref_count_ != 0) {
            --*ref_count_;
        }

        if (*ref_count_ == 0) {
            delete raw_ptr_;
            raw_ptr_ = nullptr;
        }
    }

private:
    T* raw_ptr_ = nullptr;

    size_t ref_count_value_;
    size_t* ref_count_;
};

class A {
public:
    A(const std::string& name)
        : name_(name) {
        std::cout << "A(" << name_ << ")" << std::endl;
    }

    ~A() {
        std::cout << "~A(" << name_ << ")" << std::endl;
    }

    void some_method() {
        std::cout << "some_method(" << name_ << ")" << std::endl;
    }

private:
    std::string name_;
};


void fun(my_shared_ptr<A> p) {
    p->some_method();
}

int main() {
    my_shared_ptr<A> a(new A("a"));
    my_shared_ptr<A> b(new A("b"));

    a = b;

    fun(a);
    fun(b);

    my_shared_ptr<A> c(a);

    std::vector<my_shared_ptr<A>> vec = {
        a, b, a, b,
        my_shared_ptr<A>(new A("c"))
    };

    for (auto p : vec) {
        p->some_method();
    }
}