shared_ptr.h

Go to the documentation of this file.

#ifndef shared_ptr_h
#define shared_ptr_h

#include <limits.h>
#include <algorithm>
#include <stdexcept>
#include <string>
#include "bdmerror.h"

namespace bdm {

template <typename T>
class shared_ptr {
        template<class U> friend class shared_ptr;

private:
        T *payload;
        unsigned *refCnt;

public:
        shared_ptr() :
                        payload ( 0 ),
                        refCnt ( 0 ) {
        }

        shared_ptr ( T *p ) :
                        payload ( p ),
                        refCnt ( p ? new unsigned ( 1 ) : 0 ) {
        }

        shared_ptr ( const shared_ptr<T> &other ) :
                        payload ( other.payload ),
                        refCnt ( other.refCnt ) {
                add_ref();
        }

        template<typename U>
        shared_ptr ( const shared_ptr<U> &other ) :
                        payload ( other.payload ),
                        refCnt ( other.refCnt ) {
                add_ref();
        }

        ~shared_ptr() {
                del_ref();
        }

        shared_ptr<T> &operator= ( const shared_ptr<T> &other ) {
                other.add_ref();
                del_ref();

                payload = other.payload;
                refCnt = other.refCnt;

                return *this;
        }

        T *get() {
                return payload;
        }

        T *operator->() {
                if ( !payload) {abort();};// "dereferencing NULL" );
                return payload;
        }

        T &operator*() {
                bdm_assert_debug ( payload, "dereferencing NULL" );
                return *payload;
        }

        const T* get() const {
                return payload;
        }

        const T *operator->() const {
                bdm_assert_debug ( payload, "dereferencing NULL" );
                return payload;
        }

        const T &operator*() const {
                bdm_assert_debug ( payload, "dereferencing NULL" );
                return *payload;
        }

        bool unique() const {
                return refCnt && ( *refCnt == 1 );
        }

        long use_count() const {
                return refCnt ? *refCnt : 0;
        }

        operator bool() const {
                return !!payload;
        }

        template<typename U>
        operator shared_ptr<const U>() const {
                shared_ptr<const U> cptr;               
                cptr.refCnt = refCnt;
                cptr.payload = payload;
                add_ref();
                return cptr;
        }

        void swap ( shared_ptr &other ) {
                std::swap ( payload, other.payload );
                std::swap ( refCnt, other.refCnt );
        }

private:
        void add_ref() const {
                if ( refCnt ) {
                        if ( *refCnt == UINT_MAX ) {
                                throw std::overflow_error (
                                    std::string ( "Shared pointer has too many references." ) );
                        }

                        ++*refCnt;
                }
        }

        void del_ref() {
                if ( refCnt ) {
                        if ( ! ( --*refCnt ) ) {
                                delete payload;
                                delete refCnt;
                        }
                }
        }
};

template<typename T, typename U>
bool operator== ( shared_ptr<T> const &a, shared_ptr<U> const &b ) {
        return a.get() == b.get();
}

template<typename T, typename U>
bool operator!= ( shared_ptr<T> const &a, shared_ptr<U> const &b ) {
        return a.get() != b.get();
}

template<typename T, typename U>
bool operator< ( shared_ptr<T> const &a, shared_ptr<U> const &b ) {
        return a.get() < b.get();
}

template <typename T>
class object_ptr : public shared_ptr<T>
{
public:
        object_ptr() : shared_ptr<T> ( new T() ) { }

        object_ptr ( const shared_ptr<T> &b ) : shared_ptr<T> ( b ) {
                bdm_assert_debug ( this->get(), "object_ptr cannot be empty" );
        }

        object_ptr ( T *p ) : shared_ptr<T> ( p ) {
                bdm_assert_debug ( p, "object_ptr cannot be empty" );
        }

        object_ptr<T> &operator= ( const object_ptr<T> &other ) {
                shared_ptr<T>::operator= ( other );
                return *this;
        }
};

#define SHAREDPTR(class_name) typedef bdm::object_ptr< class_name > class_name##_ptr

#define SHAREDPTR2(template_class_name, template_parameter_name) typedef bdm::object_ptr< template_class_name < template_parameter_name > > template_class_name##_##template_parameter_name##_ptr

}

#endif

---