Reference counted smart pointer with concept

Question

I wrote a simple reference counted smart pointer. The reference count is supposed to be inside the object it owns (not the smart ptr itself, like std::shared_ptr) and is currently not intended for use with concurrent access in mind. I use C++20 concept to constrain the type so T provides functionality for reference counting.

#ifndef REFCNT_PTR_HPP_INCLUDED
#define REFCNT_PTR_HPP_INCLUDED
#include <memory>
#include <utility>
#include <concepts>
namespace refcnt {
    template <typename T>
    concept ref_counted = requires(T* obj) {
        { obj->add_ref() } -> std::same_as<void>;
        { obj->release() } -> std::same_as<int>;
    };
    template <ref_counted T, typename Deleter = std::default_delete<T>>
    class refcnt_ptr {
        void release() {
            if(ptr && ptr->release() == 0) {
                deleter(ptr);
            }
        }
        T* ptr;
        Deleter deleter;

    public:
        refcnt_ptr() noexcept: ptr(nullptr), deleter({}) { }

        refcnt_ptr(T* ptr, Deleter deleter = {}) noexcept
            : ptr(ptr), deleter(deleter) {
            if(ptr) {
                ptr->add_ref();
            }
        }

        refcnt_ptr(const refcnt_ptr& other) noexcept : ptr(other.ptr), deleter(other.deleter) {
            if(ptr) {
                ptr->add_ref();
            }
        }

        refcnt_ptr(refcnt_ptr&& other) noexcept : ptr(other.ptr), deleter(std::move(other.deleter)) {
            other.ptr = nullptr;
        }

        ~refcnt_ptr() {
            release();
        }

        refcnt_ptr& operator=(const refcnt_ptr& other) noexcept {
            if(this != &other) {
                release();
                ptr = other.ptr;
                deleter = other.deleter;
                if(ptr) {
                    ptr->add_ref();
                }
            }
            return *this;
        }

        refcnt_ptr& operator=(refcnt_ptr&& other) noexcept {
            if(this != &other) {
                release();
                ptr = other.ptr;
                deleter = std::move(other.deleter);
                other.ptr = nullptr;
            }
            return *this;
        }

        T* get() const noexcept {
            return ptr;
        }
        T& operator*() const noexcept {
            return *ptr;
        }
        T* operator->() const noexcept {
            return ptr;
        }
        explicit operator bool() const noexcept {
            return ptr != nullptr;
        }
    };

} // namespace refcnt
#endif

Simple test program:

#include "refcnt_ptr.hpp"
#include <cstdio>
#include <memory>

struct test {
    int ref;
    void add_ref() {
        printf("add_ref\n");
        ++ref;
    }

    int release() {
        printf("release\n");
        return --ref;
    }

    test& operator=(const test&) = delete;
    test& operator=(test&&) = delete;
    test() = default;
    test(const test&) = delete;
    test(test&&) = delete;

    ~test() {
        printf("Delete\n");
    }
};

void func2(refcnt::refcnt_ptr<test> ptr) {
}
void func(refcnt::refcnt_ptr<test> ptr) {
    func2(ptr);
}
int main() {
    auto smart = refcnt::refcnt_ptr<test>(new test());
    func(smart);
    func(smart);

}

Deduplicator · Accepted Answer · 2025-09-29 19:22:00Z

The deleter not being a trivial empty type is rare. Ensure it doesn't waste space by employing EBO, [[no_unique_address]] or eliminating it (see next).
It is quite unnatural that managed->release() is not responsible for destroying the object if applicable.
You define your private .release() in your smart-pointer to adapt it, have a more restrictive concept (return-types), and adapting to other intrusive pointer like boost's is difficult.
Your copy- and move-operators are optimised for self-assignment, the rare case. It's a pessimisation.
Your copy- and move-operators are just wrong. Always add your new reference before removing the old one. What happens if the source-pointer is owned by the released target, and that was the last owner? Can easily happen when adjusting a DAG.

Both aforementioned problems are easily avoided using the idiomatic definition:

        void swap(refcnt_ptr& other) noexcept {
            using std::swap;
            swap(ptr, other.ptr);
            swap(deleter, other.deleter);
        }
        refcnt_ptr& operator=(const refcnt_ptr& other) noexcept {
            refcnt_ptr(other).swap(*this);
            return *this;
        }
        refcnt_ptr& operator=(refcnt_ptr&& other) noexcept {
            refcnt_ptr(std::move(other)).swap(*this);
            return *this;
        }
// or
        refcnt_ptr& operator=(refcnt_ptr other) noexcept {
            *this = std::move(other);
            return *this;
        }

Toby Speight · Accepted Answer · 2025-09-30 09:26:39Z

int ref;

seems problematic. Why would we want a negative number of references? What about signed integer overflow? (In a common case, we'll soon end up at 0 again, and delete an in-use object - this is something that has led to real bugs in prominent software, including the Linux kernel).

I recommend std::size_t as a better choice for counting references.

It seems wasteful (of developer time) for each ref-counted class to have to implement add_ref() and release() - consider providing a suitable base class that can be used (either as a mix-in base if your coding standards permit multiple inheritance, or as a CRTP wrapper).

operator=() are declared noexcept but call T::add_ref() and/or T::release() and we don't know whether they might throw. Given that the destructor calls release(), we should either insist that T::release() be noexcept, or catch whatever it throws.

\$\begingroup\$ Good point about the counter type, I missed that one. \$\endgroup\$

Deduplicator
– Deduplicator

2025-09-30 07:34:45 +00:00
Commented Sep 30 at 7:34 — Deduplicator
– Deduplicator, Commented Sep 30 at 7:34

Stack Exchange Network

Reference counted smart pointer with concept

2 Answers 2

You must log in to answer this question.

Hot Network Questions

Reference counted smart pointer with concept

2 Answers 2

You must log in to answer this question.

Related

Hot Network Questions