Which design is 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 to do something with each one.
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