Re: static members of templates

As far as I understand you question you want to have static member in
template class, but you get linker error.

Try this (see the part just before main function):

#include <ostream>
#include <vector>
//#include "pointer.h"

using namespace std;

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

};

template<typename type>
class pointer
{
private:
     static helper h;

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;
     }
};

template<typename type>
     helper pointer<type>::h;

int main()
{
     pointer<int> pint;
     pointer<double> pdouble;
}

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