kinda c++ rust things

#include <cstdio>

template <typename T>
struct const_ref;

template <typename T>
struct mut_ref;

struct unsafe_op {};

template <typename T>
struct safe_ptr {
    long refcnt;
    T *data;

    safe_ptr() : refcnt(0), data(new T) {}
    safe_ptr(T val) : refcnt(0), data(new T) {
        *data = val;
    }
    ~safe_ptr() { delete data; }
    safe_ptr(safe_ptr const&) = delete;

    const_ref<T> operator &() {
        if (refcnt >= 0)
            return const_ref<T>{this};
        else
            throw unsafe_op{};
    }

    mut_ref<T> operator +() {
        if (refcnt == 0)
            return mut_ref<T>{this};
        else
            throw unsafe_op{};
    }
};

template <typename T>
struct const_ref {
    safe_ptr<T>& ptr;

    const_ref(safe_ptr<T> *upstream)
      : ptr(*upstream) {
        ptr.refcnt += 1;
    }

    ~const_ref() {
        ptr.refcnt -= 1;
    }

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

template <typename T>
struct mut_ref {
    safe_ptr<T>& ptr;

    mut_ref(safe_ptr<T> *upstream)
      : ptr(*upstream) {
        ptr.refcnt -= 1;
    }

    ~mut_ref() {
        ptr.refcnt += 1;
    }

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

int main() {
    safe_ptr<int> x { 1 };

    {
        auto ref = &x;
        // *ref = 100; // would fail for modification of const
        auto ref2 = &x;
        printf("%i", *ref, *ref2);

        // auto mut_ref = +x; // would fail for taking mutable ref while const refs exist
    }

    {
        auto mut_ref = +x;
        *mut_ref = 10;
    }

    {
        auto ref = &x;
        printf("%i", *ref);
    }
}