Which design in better? (Also posted in comp.lang.c++)

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

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