Re: Iterators in Java and C++
On 2008-04-05 16:57, Sam wrote:
Erik Wikstr??m writes:
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; }
No, that's not correct. In java.util.Iterator, the next() method does not
modify the Iterator, it returns a new Iterator.
No, it return a reference to an object of type E, in other words it
returns a reference to the next element.
The existing iterator remains valid and continues to refer to the
same element.
The link you sent is silent on what happened to the iterator, but if a
new one is created the user will not have a reference to it since the
return-type of next() is E, and not Iterator<E>. Which means that the
user can not make the iterator go forward unless the first iterator is
modified.
Note the description of the next() method in the API:
Returns the next element in the iteration.
Notice that nowhere does it say that a new Iterator object should be
created or returned, rather it says that the next *element* should be
returned.
And *not*:
Updates the Iterator to refer to the next element in the iteration,
and returns self.
Well, my next() does not return the iterator but the next element (just
as the Java Iterator).
--
Erik Wikstr??m