Re: Iterators in Java and C++
On 2008-04-05 14:45, Sam wrote:
Mirek Fidler writes:
What the Java fan club fails to comprehend is that each iteration, in Java,
involves two virtual function calls: hasNext() and next(), while equivalent
C++ code is likely to involve more than a pair of CPU instructions:
increment and comparison, since the C++ generated code is likely to inline
What makes you think that "hasNext" and "next", if implemented in C++,
would not be expressed by "a pair of CPU instructions" - compare and
increment?
and keep both iterators in registers (most C++ STL iterators usually get
optimized into nothing more than glorified pointers).
As could be Java style iterators implemented in C++. Just consider
template <class T>
struct Iter {
T::iterator ptr;
T::iterator end;
bool hasNext() const { return ptr != end; }
void next() { ptr++; }
};
Your arguments are completely moot.
For starters, your implementation of next() is wrong. See
http://java.sun.com/javase/6/docs/api/java/util/Iterator.html. The correct,
equivalent, implementation would be:
Iter<T> next() const { Iter<T> n; n.ptr=ptr+1; n.end=end; return n }
That's your "Java style iterator" for you. That's what you have to do, on
each iteration of the loop. Good luck optimizing that. Now, why don't you go
and benchmark this abomination against the STL iterator, see what happens,
then get back to me.
Gosh, what the heck are they teaching in college, these days?
Don't know if you posted the correct link or if they just teaches us to
read better in college these days. :-) I think the correct
implementation, given the link you posted, should be
T& next() { ptr++; return *ptr; }
Which also shows the problem that James Kanze pointed out, namely that
you can not dereference the iterator more than once without changing
what it refers to.
Ideally you would have two methods, one to increment and one to
dereference, like so:
typename T::value_type& getValue() const { return *ptr; }
void moveNext{ ptr++; }
Rewriting it all in a bit my C++ stylish way we get:
#include <vector>
#include <iostream>
template <class T>
struct Iter {
typedef typename T::iterator STLIter;
typedef typename T::value_type Val;
STLIter ptr, end;
Iter(STLIter begin, STLIter end) : ptr(begin), end(end) {}
operator bool() const { return ptr != end; }
Val& operator*() const { return *ptr; }
void operator++() { ptr++; }
};
int main()
{
std::vector<int> v;
for (int i = 0; i < 10; ++i)
v.push_back(i);
Iter<std::vector<int> > it(v.begin(), v.end());
while (it)
{
std::cout << *it;
++it;
}
}
Not too sure about the operator bool() thing though...
--
Erik Wikstr??m