Re: Iterators
On 1 Aug, 21:27, Xavier Pegenaute <xpegena...@gmail.com> wrote:
Having class A and I have a list of objects from class B. If I want to
give the service to iterate the list of objects B, what is better:
- Use the inheritance from STL Iterator.
- Return the value directly from listofBs.begin().
When is better to use inheritance instead to have a list attribute and
delegate this kind of methods to the list instance?
It depends of what you are trying to achieve.
If you'd like to encapsulate the internals of class A better, so that
the users of this class do not assume how instances of B are stored in
A, it may be a good idea to provide an algorithm (member) function
instead of returning iterators. Returning iterators couples class A
and the calling code, so that changing the container in A would
require changing the type of the returned iterator, which might break
the calling code. The algorithm function, on the other hand, hides how
B's are stored in A, changing the implementation of A (in particular,
the way how B's are stored in A) will not break the callers of the
algorithm. The algorithm function would accept a functor and call that
functor once for each B.
Something like this:
#include <iostream>
#include <list>
#include <algorithm>
struct B
{
char name_;
B(char name) : name_(name) {}
};
inline std::ostream& operator<<(std::ostream& s, B b)
{
return s << b.name_ << '\n';
}
struct A
{
typedef std::list<B> list;
list l_;
A& add(B b) { l_.push_back(b); return *this; }
template<class Functor>
Functor for_each_element(Functor f)
{
return std::for_each(l_.begin(), l_.end(), f);
}
};
struct printer
{
std::ostream* const s_;
printer(std::ostream& s) : s_(&s) {}
template<class T>
void operator()(T const& t) { *s_ << t; }
};
int main()
{
A a;
a.add('a').add('b').add('c');
a.for_each_element(printer(std::cout));
};
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]