---

smartptr.h

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// (Coded@ReallySoft.de)
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#ifndef SMARTPTR_H
#define SMARTPTR_H

#ifndef RS_ASSERT_H
#include "rs_assert.h"
#endif

namespace rs {

    // --------------------------------------------------------------------------------
    //     SmartPointers
    // --------------------------------------------------------------------------------

    template <class T> class SmartPtr;

    // --------------------------------------------------------------------------------
    //     class Counted
    // --------------------------------------------------------------------------------
    template <class T>
    class Counted {
    private:
        unsigned counter;
        T *const pointer;

        Counted(T *p) : counter(0), pointer(p) { assert(p); }
        ~Counted() { assert(counter==0); delete pointer; }

        unsigned new_reference() {
            //cout << "new reference to pointer" << int(pointer) << " (now there are " << counter+1 << " references)" << "\n";
            return ++counter;
        }
        unsigned free_reference() {
            //cout << "removing reference to pointer " << int(pointer) << " (now there are " << counter-1 << " references)\n";
            assert(counter!=0);
            return --counter;
        }

        friend class SmartPtr<T>;
    };

    template <class T>
    // --------------------------------------------------------------------------------
    //     class SmartPtr
    // --------------------------------------------------------------------------------
    class SmartPtr {
    private:
        Counted<T> *object;

        void Unbind() {
            if (object && object->free_reference()==0) delete object;
            object = 0;
        }
    public:
        SmartPtr() : object(0) {}

        SmartPtr(T *p) {
            object = new Counted<T>(p);
            object->new_reference();
        }

        ~SmartPtr() {Unbind(); }

        SmartPtr(const SmartPtr<T>& other) {
            object = other.object;
            if (object) object->new_reference();
        }
        SmartPtr<T>& operator = (const SmartPtr<T>& other) {
            if (other.object) other.object->new_reference();
            Unbind();
            object = other.object;
            return *this;
        }

        T *operator->() { assert(object); return object->pointer; }
        const T *operator->() const { assert(object); return object->pointer; }

        T& operator*() { assert(object); return *(object->pointer); }
        const T& operator*() const { assert(object); return *(object->pointer); }

        bool Null() const { return object==0; }

        void SetNull() { Unbind(); }

        SmartPtr<T> deep_copy() const { return SmartPtr<T>(new T(**this)); }

        bool sameObject(const SmartPtr<T>& other) const {
            assert(object);
            assert(other.object);
            return object==other.object;
        }
    };

    template <class T> bool operator==(const SmartPtr<T>& s1, const SmartPtr<T>& s2) {
        return s1.sameObject(s2);
    }

    template <class T> bool operator!=(const SmartPtr<T>& s1, const SmartPtr<T>& s2) {
        return !s1.sameObject(s2);
    }

};

#else
#error smartptr.h included twice
#endif // SMARTPTR_H

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002