Re: Test if const_iterator may be dereferenced - with no direct
access to original vector.
On Thursday, 2 May 2013 08:56:10 UTC+1, Andy Champ wrote:
On 01/05/2013 21:57, mathog wrote:
Is there not in C++ something like:
if(icc->dereferencable()){
No, there isn't, and for good reasons.
The good reason is probably because there's no way of
implementing it, given that you need a second iterator to know
whether you're at the end or not. Every iterator I wrote before
STL came along supported something like this (usually
icc.isValid()).
Inside a std::string there's usually a buffer containing the string. (I
don't think there _has_ to be, but that's another matter (1) ). That
string is a load of characters, usually bytes.
Imagine I have an internal vector, which for efficiency the string code
has initially allocated as 16 bytes even though it only contains "ABC".
I'll use ? as a marker for "undefined". The bytes are then
"ABC?????????????"
An iterator to C can be de-referenced, but if you increment it you get
one that cannot be de-referenced. There's nothing about that ? that
marks it as something that can't be accessed. Without
accessing the original collection there's nothing the iterator
can use either - and for reasons I don't know the original STL
design doesn't contain references from iterators into the
collection (2). And if you _do_ de-reference it you'll just
get whatever character happens to be in the first question
mark.
With most modern implementations, you'll get an assertion
failure. (At least, this is the case with VC++ and g++.)
If I then append to the string, so the buffer now contains
"ABCdefghijklmnop"
Without any change whatsoever to the iterator it has now become valid -
it points at d.
What happens in this case is undefined behavior. I suspect,
however, that most implementations would miss that error
(supposing that capacity() had been larger than the new string).
I can then set it to end(). Typically this will be an address one more
than p. Again, without reference to the collection you can't tell if
it's valid. And if you do de-reference it - well, you might get the byte
that follows p. Or that page in the processor's memory space might not
have been allocated, and you get an exception. So once more you are in
the realms of undefined behaviour.
(1) I just checked. In C++98 there's no requirement for there to be an
internal buffer, but for C++11 there is!
(2) But I can guess. Suppose the collection was on the heap, and was
deleted? Suppose the iterator was re-pointed into a different
collection? And if the collection was deleted, and another one of the
same type created in the same heap location, what then?
In most implementations, iterators register with the container,
so that they can be marked as invalid in such cases.
--
James