Re: pointer iterator interaction

From:

"silversurfer" <kietzi@web.de>

Newsgroups:

comp.lang.c++

Date:

30 Jun 2006 05:14:53 -0700

Message-ID:

<1151669693.339029.95460@d56g2000cwd.googlegroups.com>

oh,.. I forgot:

Don't use pointers to elements in Vectors.
Pointers to elements in vectors tend to get "stale", because
vectors reallocate themselves if they grow, so you'd eventually
end up dereferencing wild pointers and crashing your program.

The vector from which I am getting my elements shuffeled later on,.. is
it then even unsafer to use pointers to the elements in the vector or
should this not matter?

Thanks once more..
Tim

silversurfer schrieb:

Thank you so much you guys,.. it seems that my understanding was a
little misleading (ok, I admit: it was simply wrong!)

Thanks Robbie for pointing out the fact about the re-structuring of
vectors, I did not think of this, before! Did I understand it right,
that using vector[] is safe in this respect? Why then bother and use
iterators at all? One could also run through the vector until size()
and return and access values by integer subscripting... (again, if I
understood this right).

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?

Thanks once more,
Tim

Robbie Hatley schrieb:

"silversurfer" <kietzi@web.de> wrote:

Ok, this should be fairly easy for most of you (at least I hope so),
but not for me:

Let us say we have got the following elements:
std::vector<Entry> models; //Entry is a struct
std::vector<Entry>::iterator modelIterator;

In a method, I am currently writing, I need to get a pointer to an
entry in the vector.

No you don't. Don't use pointers to elements in Vectors.
Pointers to elements in vectors tend to get "stale", because
vectors reallocate themselves if they grow, so you'd eventually
end up dereferencing wild pointers and crashing your program.

I thought of the following:

Entry* MyObject::getNextEntry() {
    Entry* tmpEntry;

    if (modelIterator == models.end()) {
        return NULL;
    } else {
        tmpEntry = modelIterator;
        modelIterator++;
        return tmpEntry;
    }
}

Unfortunately, this does not work

Of course it doesn't work. The return type of your function is:

Entry*

but the type of tmpEntry is:

std::vector<Entry>::iterator

The two types are not even remotely similar.

I get the error message:
   error: cannot convert `
       __gnu_cxx::__normal_iterator<Entry*, std::vector<Entry,
       std::allocator<Entry> > >' to `Entry*' in assignment

Yes, as I said, "not even remotely similar". You're asking the
compiler to convert apples to pipedreams. The compiler is
doubting your sanity, and rightly so.

I do not really understand this: As far as I understood it,
an iterator should be a pointer to the elements of the vector,

An iterator is not a pointer. It might (or might not) be
IMPLIMENTED in terms of a pointer, but unless you're writing
a compiler, that's none of your business.

An iterator can (and should) be USED LIKE a pointer, yes.
But it's not a pointer. It's an iterator. Think of it as
"one level higher of abstraction" compared to a pointer.

How can I get a pointer to the element to which the iterator
is currently pointing?

If you absolutely MUST do that, then you can, easily, like so:

Entry* DangerousPointer = &(*modelIterator);

But that is very dangerous. For iterating through the elements
of a Vector, use real iterators. You can use iterators for (almost)
anything you could use pointers for.

Or use integer subscripting. With vectors, that's often easier than
using iterators, and you don't need to worry about whether an old
iterator still points to something valid.

--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net (put "[ciao]" in subject to bypass spam filter)
http://home.pacbell.net/earnur/