Re: pointer iterator interaction
"silversurfer" <kietzi@web.de> wrote:
One more thing: What was meant by "For iterating through the elements
of a Vector, use real iterators. You can use iterators for (almost)
anything you could use pointers for."? Should I give back an
iterator-object instead of the object the iterator is pointing to?
That depends much on what you're doing, and on whether this vector
is going to stay the same size always, or grow.
If the vector never changes size, it should occupy the same contiguous
block of memory always, and iterators to elements will always be valid.
But if the vector increases size, it may re-allocate itself, moving to
a new location in order to get a contiguous memory block of the required
size. According to the C++ standard, section 23.2.4.2, when a std::vector
reallocates itself, all references, pointers, and iterators referring to
the elements become invalid.
Also, if you insert or delete elements in the middle of a vector,
it will invalidate all pointers, iterators, and references to elements
after the point of insertion or deletion.
Therefore, it's best not to store copies of iterators to vector elements.
If you're going to pass a copy of an iterator from one function to another,
make sure you use it quickly before changes are made to the vector.
The usual way of iterating through a vector is like this:
std::vector<int> Splat;
// ... put a bunch of ints in Splat ...
std::vector<int>::iterator Iter;
for (Iter = Splat.begin(); Iter != Splat.end(); ++Iter)
{
(*Iter) += 17; // add 17 to each element of Splat
}
That way, Iter is always "fresh", unless you do something inside
the for loop which changes the size of Splat. So don't do that.
Instead, perform such operations outside of such "iterating" for
loops.
A simpler way of working with vectors, especially vectors with
fixed, known sizes, is by integer subscripting, like so:
std::vector<int> Splat (800); // make a vector of 800 ints
// ... put a bunch of ints in Splat ...
for (int i = 0; i < 800; ++i)
{
Splat[i] += 17; // Add 17 to each element of Splat.
}
If you find yourself changing the size of a vector a lot, or sorting
it, or inserting elements in the middle, then consider using a
std::list instead. Lists can't be subscripted like vectors, but
they are much more efficient for insertions and deletions, and
iterators (or pointers) to elements never become invalid unless
the element they point to is deleted.
Or, if you're adding/removing elements mostly at the ends, try a
std::deque instead.
--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net (put "[ciao]" in subject to bypass spam filter)
http://home.pacbell.net/earnur/