Thread: from iterator to data structure?

Hi,

Is there a way to go from the iterator to the data structure? I.e. if

Code:

std::vector<int> v;
std::vector<int>::iterator i;

i = v.begin();

Is there a way for going back from i to v somehow?

Why would I want to do this?

I have a method which accepts an iterator and does something with the object inside the collection (i.e. the object the iterator is pointing to). However, the iterator can also be v.end().
I don't want to check for v.end() everytime but prefer letting the method check it. This method, as mentioned already, only gets the iterator delivered.

So is this possible?

Rephrased: Can you detect if an iterator equals vector.end() without having access to vector or getting vector.end() delivered additionally?

Sebastian

You could take a pointer, and pass either &*i (?), or NULL. That's probably the easiest way to pass a parameter that could be invalid.

Alternatively . . . you could pass a reference to the vector and a size_type index instead of an iterator.

I think this is the situation.

Code:

std::vector<int> v;
std::vector<int>::iterator i = v.begin();

// ...
function(i);

void function(std::vector<int>::iterator i) {
    if(i == ***.end()) {
        // it's invalid . . .
    }
}

Ok, for clarification.

Code:

void do_sth(vector<int>::iterator i) {
    if (i != i.vector_it_belongs_to.end())
        std::cout << *i;
}

This is just an example method. It should basically check if the iterator is valid and doesn't point to the end of the vector. I just want to be able to call do_sth() with an iterator without having to check if the iterator is valid where I call it. I'd prefer checking it inside.


dwks: Yes, this is what I mean. But with &*i (?), or NULL I'd have to check it from where I call it, because you cannot dereference v.end()

Sebastian

Right. Here are two ways I might do this.

The easiest way is to pass a pointer to the function, instead of an iterator.

Code:

void func(int *i) {
    if(i == NULL) // invalid
}

std::vector<int>::iterator i = v.begin();
func(&(*i));
func(NULL);

Or you can pass a size_type, an index into the vector. (You know, like the way you address arrays.) You can turn an iterator into an index, if you want to, by using subtraction.

Code:

std::vector<int> v(10);
std::vector<int>::iterator i = v.begin();
i ++;
i ++;

std::cout << i - v.begin() << '\n';

And I think you can use (size_t)-1 or something like that to indicate an invalid index . . .

As far as I know, given an iterator you can't find out which container it belongs to. The iterator itself doesn't know that. A vector::iterator is little more than a pointer to the value type. Basically what you want: given an arbitrary pointer you want to be able to find out where the range ends that the pointer points into.

That's why algorithms normally take a start and an end iterator.

Of course, you could create your own iterator that does store a reference to the container, but what's the point?

Well, I can call ++ on the iterator as long as it's valid. As soon as the iterator is container.end() I cannot call iterator++ without getting an error. So it should know where the end is.

It is the same with plain pointer into array. As long as your pointer stays within bounds, everything is OK. If you increment the pointer (more than one) past the end of the array you get undefined behaviour. This doesn't mean that the pointer knows where the end of the array is.

It is also possible that you are using VC++ which indeed seems to store some additional information in the iterator if range-checks for iterators are not turned off. However, this is not required by the standard and this compiler-specific knowledge is not something you should try to use for your purposes.

There are also Boost libraries, which through some template magic seem to manage to detect whether something is a STL-compliant container, an array or a null-terminated C-style string (given a container, array or C style string).

But the simplest and most idiomatic thing to do: pass two iterators to delimit the range.