-- myList.begin()

Is that operation legal does anyone know?

Can I legally compare an iterator to the thing just before begin to see
if decrementing my iterator has taken it past the workable range of the
list?

If not, what should I be doing instead to terminate this loop ...

while(-- it != /* hmm */)
{
// play with it->
}

re: -- myList.begin()

earthwormgaz wrote:No. That would be undefined behaviour.
If you are using a container with bidirectional or random access
iterators (you mention the word list above and std::list has
bidirectional iterators) then look up the reverse iterators rbegin()
and rend(). They allow you to iterate backwards through the container.
It's not absolutely clear from your question, but it sounds like they
might be what you need.

Gavin Deane

re: -- myList.begin()

Gavin Deane wrote:Right, I'll stop doing that then. It actually has worked for me, but is
clearly an unsafe thing to do, so that is the end of it.
I am using a list, so yes, random access iterator. It would seem that
all I can do is ...

-- it != myList.begin()

I'll have to rework a couple of algorithms for that I suppose.

Gaz

re: -- myList.begin()

earthwormgaz wrote:
list iterators are not random access. They are only bidirectional iterators.
What's wrong with reverse iterators? Use rbegin()/rend() to go through the
container backwards.

re: -- myList.begin()

earthwormgaz wrote:No, it's not. List does not have random access iterators.
Did you read Gavin Deane's post? Use reverse iterators.


--
Clark S. Cox III
clarkcox3@gmail.com

re: -- myList.begin()

Rolf Magnus wrote:Nowt, but I am writing a bi-directional iterator for what amounts to
this ...

class Tree
{
std::list<Treem_lsChildren;
};

So, my iterator type contains:

class TreeIterator
{
Tree * m_pTree;
std::list<Tree>::iterator m_pIt;
};

That means in dealing with the -- operator I have to deal with m_pIt
going past begin(). I appear to have a working algorithm now anyway.

/me waits for somebody to tell him Boost or something already does all
this :)

Cheers folks,

Gaz

re: -- myList.begin()

earthwormgaz wrote:A container with bidirerctional iterators has 2 ends, one end gowing
forward indicating one past the last element and a rend gowing backward
indicating one past the first element.

#include <iostream>
#include <list>

int main()
{
std::list<intnlist;
for(int i = 0; i < 5; ++i)
{
nlist.push_back(i); // 0,1,2,3,4
}

typedef std::list<int>::reverse_iterator RIter;
for(RIter riter = nlist.rbegin(); riter != nlist.rend(); ++riter)
{
std::cout << *riter << std::endl;
}

return 0;
}

/*
4
3
2
1
0
*/

Note how incrementing (op++) a reverse iterator is used to displace it.