Is there a simple way to get iterators to the elements on either side of that pointed to (?) by a std::list iterator ?
I recently did this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// populate the list
// one data member of T depends on the values of data members of the elements on either side in the list.
std::list<T>::iterator it = LT.begin();
while( it != LT.end() )
int x1=0, x2=0;// default values for the "values from either side"
if( it != LT.begin() )
std::list<T>::iterator itPrev = it;
x1 = itPrev->x;// finally!
// similar code for obtaining x2 from an itNext
it->F = f(it->x, x1, x2);// the end need
Another C++11 only feature, eh?
I guess the language did need an overhaul.
You could accomplish the same thing prior to C++11 using std::advance. The next/prev notation is really a matter of convenience.
How does one test that the returned iterator is valid?
In both cases, one should know the iterator will be valid before using the functions. There is no way to test the returned iterator in general. Of course, if you're using next to advance one element at a time, you may compare it to the end iterator of the container. There isn't a convenient value to test against if you're using prev analogously. (One would need to ensure it didn't compare equal to the begin iterator of the container before invoking prev.)
[edit: std::distance is useful in the case of advancing in either direction more than one element.]
std::list<T>::iterator itPrev, itCurr, itNext;
itCurr = L.begin();
while( itCurr != L.end() )// itCurr is always valid within this while loop
// check against begin() 1st
if( itCurr != L.begin() )// there is a valid previous element
itPrev = itCurr; --itPrev;// copy, then decrement
// use itPrev
itNext = itCurr;// we know itCurr != L.end()
if( ++itNext != L.end() )// so it's OK to increment then compare here
// use itNext