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! ]

Nitesh ha scritto:
> 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.
>
> <snip>
>
> Please comment on which of the above alternative is better?
>

None of them suits my programming style. Instead of using multiple
classes, I would go for one iterator class and multiple "factory" free
functions, for example:

class XHandleIterator {
public:
XHandleIterator(XHandle h, int c) : mHandle(h), mCount(c) {}
/* ... */
private:
XHandle mHandle;
int mCount;
};

XHandleIterator MakeIterator1(SomeType obj)
{
return XHandleIterator(/* compute mHandle and mCount here */);
}

XHandleIterator MakeIterator2(SomeType obj)
{
return XHandleIterator(/* compute mHandle and mCount here */);
}

Just my opinion,

Ganesh

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

niteshchordiya@gmail.com (Nitesh) wrote (abridged):
> 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.

I don't see why you can't have a single iterator class with a suitable
constructor:

XHandleIterator::XHandleIterator( XHandle handle, int count );

and then various functions that return such iterators:

XHandleIterator makeIterator( SomeType obj );

Your first design introduces this function via a derived class, and your
second design makes it a policy, but why can't it just be a plain simple
function?

-- Dave Harris, Nottingham, UK.

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