bruxisma / retain-ptr Goto Github PK

#include <iostream>

using std::cout;
using std::endl;

class S
{
public:
    S(int x_) : x(x_) {}
    ~S()
    {
        cout << __PRETTY_FUNCTION__ << ":" << endl;
    }
public:
    int x;
    mutable unsigned int _rc = 1;
};

struct S_traits final
{
    static void increment (S* x) noexcept
    {
        cout << __PRETTY_FUNCTION__ << ":" << endl;
        x->_rc += 1;
    }
    static void decrement (S* x) noexcept
    {
        x->_rc -= 1;
        cout << __PRETTY_FUNCTION__ << ": rc=" << x->_rc << endl;
        if (x->_rc == 0) { delete x; }
    }
};

#include "sg14/memory.hpp"
using SP = sg14::retain_ptr<S, S_traits>;

int main(__attribute__((unused)) int argc,
         __attribute__((unused)) const char * argv[],
         __attribute__((unused)) const char * envp[])
{
    cout << "sizeof(S): " << sizeof(S) << endl;
    cout << "sizeof(SP): " << sizeof(SP) << endl;
    {
        auto rp = SP(new S(42));
    }
    return 0;
}

#include <iostream>
#include <memory>
#include "sg14/memory.hpp"

using namespace std;

class Base
{
public:
    Base()
    {
    }
    mutable unsigned int _rc = 1;
};

class Sub : public Base
{
public:
    Sub(int x_)
        : Base(), x(x_)
    {
        cout << __PRETTY_FUNCTION__ << ":" << endl;
    }
    ~Sub() { cout << __PRETTY_FUNCTION__ << ":" << endl; }
public:
    int x;
};

void test_shared()
{
    using SharedBase = std::shared_ptr<const Base>;
    using SharedSub = std::shared_ptr<const Sub>;
    SharedBase base;
    SharedSub sub;
    base = sub;                 // compiles!
}

struct Base_traits final
{
    static void increment(const Base* x) noexcept
    {
        x->_rc += 1;
        cout << __PRETTY_FUNCTION__ << ": rc=" << x->_rc << endl;
    }
    static void decrement(const Base* x) noexcept
    {
        x->_rc -= 1;
        cout << __PRETTY_FUNCTION__ << ": rc=" << x->_rc << endl;
        if (x->_rc == 0)
        {
            delete x;
        }
    }
};

struct Sub_traits final
{
    static void increment(Sub* x) noexcept
    {
        x->_rc += 1;
        cout << __PRETTY_FUNCTION__ << ": rc=" << x->_rc << endl;
    }
    static void decrement(Sub* x) noexcept
    {
        x->_rc -= 1;
        cout << __PRETTY_FUNCTION__ << ": rc=" << x->_rc << endl;
        if (x->_rc == 0)
        {
            delete x;
        }
    }
};

using RetainBase = sg14::retain_ptr<const Base, Base_traits>;
using RetainSub = sg14::retain_ptr<const Sub, Base_traits>;

void test_retain()
{
    cout << "sizeof(Sub): " << sizeof(Sub) << endl;
    cout << "sizeof(RetainSub): " << sizeof(RetainSub) << endl;
    auto sub = RetainSub(new Sub(42));
    auto base = RetainBase(new Base());
    base = sub; // this errors
}

int main(__attribute__((unused)) int argc,
         __attribute__((unused)) const char* argv[],
         __attribute__((unused)) const char* envp[])
{
    test_shared();
    test_retain();
    return 0;
}

    template <class U>
    using enable_if_sub = std::enable_if_t<std::is_base_of_v<T, U>>;

    template <class S, class = enable_if_sub<S>>
    retain_ptr& operator = (retain_ptr<S, R> &&that) {
        if (*this) { traits_type::decrement(this->get()); } // drop
        ptr = that.detach();
        return *this;
    }

    template <class S, class = enable_if_sub<S>>
    retain_ptr& operator = (retain_ptr<S, R> &&that) {
        *this = *reinterpret_cast<retain_ptr<T, R> *>(&that);
        return *this;
    }

  static void decrement (atomic_reference_count<T>* ptr) noexcept {
    ptr->count.fetch_sub(1, std::memory_order_acq_rel);
    if (not use_count(ptr)) { delete static_cast<T*>(ptr); }
}

  static void decrement (reference_count<T>* ptr) noexcept {
    if (ptr->count -= 1) { delete static_cast<T*>(ptr); }
}