Which design in better?

Objects of type X are basic building blocks of my application and
there are a few functions which return XHandle (typedef X** XHandle).
The task at hand needs to use a couple of these functions and then
iterate over X objects.
Because its done frequently and it separates iteration from task-at-
hand'logic we decided to create iterator.

Assuming the availability of functions GetXHandleSize(XHandle) and
DisposeXHandle(XHandle) there are two alternatives.

<b>Option1:</b> Using simple inheritance
class XHandleIterator {
public:
 XHandleIterator(void) : mHandle(0L), mCount(0) {}
 ~XHandleIterator() { if (mHandle != 0L) DisposeXHandle(mHandle); }

 bool Done(void) { return mCount > 0; }
 // Pre-increment operator
 XHandleIterator& operator++(void) { --mCount; return *this; } // Am
iterating over backwards
 // Post-increment operator..
 // De-referencing operator
 X& operator *(void) { return (*mHandle)[mCount-1]; }
protected:
 XHandle mHandle;
 int mCount;
};

class XHandleIteratorOne : public XHandleIterator {
public:
 XHandleIteratorOne(SomeType obj) {
 // Creates XHandle someway. Assigns to mHandle and mCount
}
};

class XHandleIteratorTwo : public XHandleIterator {
 XHandleIteratorTwo(SomeType obj) {
 // Creates XHandle in another way. Assigns to mHandle and mCount
 }
};

<b>Option2:</b> Policy based design
template<typename HandleCreator>
class XHandleIterator {
public:
 XHandleIterator (SomeType obj) : mHandle(0L), mCount(0)
 {
  HandleCreator::Create(obj, &mHandle);
  mCount = GetXHandleSize(mHandle)/sizeof(X);
 }
 ~XHandleIterator() { if (mHandle != 0L) DisposeXHandle(mHandle); }
 bool Done(void) { return mCount > 0; }
  // Pre-increment operator
 XHandleIterator& operator++(void) { --mCount; return *this; }
 // Post-increment operator...
 // De-referencing operator
 X& operator *(void) { return (*mHandle)[mCount-1]; }
private:
 XHandle mHandle;
 int mCount;
};

struct XHandleCreator1 {
    static void Create(SomeType obj, XHandle *handle) {
         // Creates XHandle someway. Assigns to handle
    }
};

struct XHandleCreator2 {
    static void Create(SomeType obj, XHandle *handle) {
         // Creates XHandle in another way. Assigns to handle
    }
};

typedef XHandleIterator<XHandleCreator1> XHandleIteratorOne;
typedef XHandleIterator<XHandleCreator2> XHandleIteratorTwo;

I am confused over which is the right way to do in this case with all
stipulations stated at the top. The main thing I like about 2nd one is
that mHandle and mCount are private.
Please comment on which of the above alternative is better?

Thanks
Nitesh