Re: Smart Pointers and Microsoft Foundation Classes

Well I could post my reference counter code, it's a standard approach to a
simple counted pointer template I wrote last night to better illustrate my
thinking. This code works fine in a single threaded application as is. I was
pondering the move to using this kind of abstraction in a multithreaded
situation.

#ifndef counted_pointer_h
#define counted_pointer_h
// class for counted reference semantics
// deletes the object to which it refers when the last CountedPtr that
refers to it is destroyed
template <class T>
class CountedPtr {
public:
     // initialize pointer with existing pointer
     // requires that the pointer p is a return value of new
     explicit CountedPtr (T* p=0): ptr(p), count(new long(1)) {}
     // copy pointer (add another owner)
     CountedPtr (const CountedPtr<T>& p) throw(): ptr(p.ptr),
count(p.count) {
         ++*count;
     }
     // destructor (if this was the last owner)
     ~CountedPtr () throw() {
         dispose();
     }
     // assignment (unshare old and share new value)
     CountedPtr<T>& operator= (const CountedPtr<T>& p) throw() {
         if (this != &p) {
             dispose();
             ptr = p.ptr;
             count = p.count;
             ++*count;
         }
         return *this;
     }
     // access the value to which the pointer refers
     T& operator*() const throw() {
         return *ptr;
     }
    T* operator->() const throw() {
         return ptr;
     }
   private:
     T* ptr; // pointer to the value
     long* count; // shared number of owners
        void dispose() {
         if (--*count == 0) {
              delete count;
              delete ptr;
         }
     }
};
#endif // counted_pointer_h

"Joseph M. Newcomer" <newcomer@flounder.com> wrote in message
news:r59mr3pu9c2sqhuaadps3o1r9ie67nklp8@4ax.com...