static members of templates

Hi,
I am trying to make a safety pointer class however i am having trouble
in keeping the instances from deleting the data member when the value
is changed. I could fix the problem by using a static vector but the
class will no longer link correctly with vague errors to the affect of
"the static data member is undefined" I could also use a global
variable to the same affect but this leads to a link-time error because
the vector is somehow defined multiple times. Am I doing something
wrong or is there another way to fix this? Here is the code for the
safety pointer. I want it to delete the value pointed to by ptr only
if no other instances of the class point to it. If you have any other
improvements or optimizations please tell me.
#ifndef POINTER_CPP
#define POINTER_CPP
#include <ostream>
#include <vector>
#include "pointer.h"

using namespace std;

class helper{
        public:
            vector<void*> copies;
};

helper h;

template<typename type>
    class pointer{
    public:
        explicit pointer(type* p = 0):ptr(p){h.copies.push_back((void*)p);}
        pointer(pointer const & p){
            reset();
            ptr = p.ptr;
            h.copies.push_back((void*)p.ptr);
        }
        ~pointer(){
            reset();
        }
        operator bool(){
            return ptr;
        }
        operator type*(){
            return ptr;
        }
        pointer & operator=(pointer const & p){
            if(ptr != p.ptr){
                reset();
                ptr = p.ptr;
                h.copies.push_back((void*)p.ptr);
            }
            return *this;
        }
        pointer & operator=(type* p){
            if(ptr != p){
                reset();
                ptr = p;
                h.copies.push_back((void*)p);
            }
            return *this;
        }
        type & operator*(){
            return *(ptr);
        }
        type * operator->()const{
            return ptr;
        }
        //comparison operators:
        bool operator==(pointer p)const{
            return ptr == p.ptr;
        }
        bool operator<(pointer p)const{
            return ptr < p.ptr;
        }
        bool operator>(pointer p)const{
            return ptr > p.ptr;
        }
        bool operator<=(pointer p)const{
            return ptr <= p.ptr;
        }
        bool operator>=(pointer p)const{
            return ptr >= p.ptr;
        }
        //out stream operator
        friend std::ostream & operator<<(std::ostream & out, pointer const &
p){
            if(not p.ptr){
                out << "null";
                return out;
            }
            out << p.ptr;
            return out;
        }
        //incrementors decrementers
        pointer & operator++(){
            ++ptr;
            return *this;
        }
        pointer operator++(int i){
            pointer<type> temp(*this);
            ++(*this);
            return temp;
        }
        pointer & operator--(){
            --ptr;
            return *this;
        }
        pointer operator--(int i){
            pointer<type> temp(*this);
            --(*this);
            return temp;
        }
        pointer & operator+=(int i){
            ptr += i;
            return *this;
        }
        pointer & operator-=(int i){
            ptr -=i;
            return *this;
        }
        pointer operator+(int i){
            return pointer(ptr + i);
        }
        pointer operator-(int i){
            return pointer(ptr - i);
        }
    private:
        type* ptr;
        void reset(){
            int count(0);
            for(int i = 0; i != (int)h.copies.size(); ++i){
                if(h.copies[i] == ptr) ++count;
            }
            if(count <= 1) delete ptr;
        }
    };
#endif

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]