Can't understand this problem with ref counting class?

Here is my code

///reference counting
struct ref_type
{
  ref_type() : cnt(0) {}

  int ref_add()
  {
        return ++cnt;
  }
  int ref_remove()
  {
   return --cnt;
  }

  unsigned ref_cnt() const { return cnt; }

private:
  unsigned cnt;
};

template <class T>
// T must derive from ref_type
// or supply methods ref_add and ref_remove
  struct ref_ptr
  {
    ref_ptr() : ptr(0) {}
    ref_ptr(T* p) : ptr(p) { if(p) p->ref_add(); }
    ref_ptr(const ref_ptr& that) : ptr(that.ptr) { if(ptr) ptr->ref_add
(); }

    ~ref_ptr() { dereference(); }

    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
    operator T*() const { return ptr; }

    void reset() { dereference(); ptr = 0; }

    void swap(ref_ptr& that) { std::swap(ptr, that.ptr); }

    T* release() //dereference without deleting
    {
      T* p = ptr;
      if(p) {
        p->ref_remove();
        ptr = 0;
      }
      return p;
    }

    ref_ptr& operator=(const ref_ptr& that)
    {
      if(&that!=this && that.ptr!=ptr) {
        dereference();
        if((ptr = that.ptr)!=0)
          ptr->ref_add();
      }
      return *this;
    }

    bool operator==(const ref_ptr& that) const { return ptr ==
that.ptr; }
    bool operator==(T* that) const { return ptr == that; }

    bool operator!=(const ref_ptr& that) const { return ptr !=
that.ptr; }
    bool operator!=(T* that) const { return ptr != that; }

    bool operator<(const ref_ptr& that) const { return ptr <
that.ptr; }
    bool operator<(T* that) const { return ptr < that; }

  private:
    T* ptr;

    void dereference()
    {
        if (ptr!=0 && ptr->ref_remove()==0)
            delete ptr;
    }
  };
//template <class T> END

template<class T>
void swap(ref_ptr<T>& a, ref_ptr<T>& b) { a.swap(b); }

class test : public ref_type
{
public:
    void set(int val){ m_value = val; }
    int get() const { return m_value; }

  typedef ref_ptr<test> ptr_type;
private:
    int m_value;
};

int main(){
    test::ptr_type pmytest = new test;
    pmytest->set(4);
    test::ptr_type pTest1(pmytest); //increments ref count

    //in above code line test::ptr_type pTest1(pmytest); correctly
increments ref counter to 2

    //however, if I use like this: test* pmytest = new test; then ref
counter is not incremented to 2. Why?

    return 0;
}

For convenience I want to be able to use more convenient test* pTest =
new test; - and for ref counter to be incremented. It works if use
test::ptr_type. But test inherits from ref_type so why does it not
work?

Angus