question about erase() function on a container

[subramanian100in]

Suppose I have

vector<intcontainer;

Suppose I store some values into "container".

Suppose that "left" and "right" are valid iterators into "container"
and that "right" is NOT container.end() and "right" comes after
"left".

Given this, suppose

vector<int>::iterator iter = container.erase(left, right);

then "iter" will always be a copy of "right" iterator.
ie
if (iter == right) will always be true. Am I correct ? The same is
true for deque and list also. Is this correct ?

Given a standard library container, can we call clear() function on
empty container ? Or will it invoke undefined behaviour ?

Kindly clarify.

Thanks
V.Subramanian

[Martin York]

Suppose that "left" and "right" are valid iterators into "container"
and that "right" is NOT container.end() and "right" comes after
"left".

vector<int>::iterator iter = container.erase(left, right);

then "iter" will always be a copy of "right" iterator.

No. iter will be an iterator to the element after right:
see: http://www.cplusplus.com/reference/s...tor/erase.html

Given a standard library container, can we call clear() function on
empty container ? Or will it invoke undefined behaviour ?

Yes. clear() will do what is expected on an empty container.

[Martin Vuille]

Martin York <Ma***************@gmail.comwrote in
news:14**********************************@j78g2000 hsd.googlegrou
ps.com:

>

>Suppose that "left" and "right" are valid iterators into
"container" and that "right" is NOT container.end() and
"right" comes after "left".

vector<int>::iterator iter = container.erase(left, right);

then "iter" will always be a copy of "right" iterator.

No. iter will be an iterator to the element after right:
see: http://www.cplusplus.com/reference/s...tor/erase.html

Which says: "the range includes all the elements between first and
last, including the element pointed by first but *not* the one
pointed by last." (emphasis mine)

iter will point to the same element as right. But the two
iterators will not be "equal" or "copies" because erase()
invalidates all iterators to elements after position first.
Thus right is no longer valid after erase() returns.

MV

--
I do not want replies; please follow-up to the group.

[James Kanze]

su**************@yahoo.com, India wrote:

Suppose I have

vector<intcontainer;

Suppose I store some values into "container".

Suppose that "left" and "right" are valid iterators into
"container" and that "right" is NOT container.end() and
"right" comes after "left".

Given this, suppose

vector<int>::iterator iter = container.erase(left, right);

then "iter" will always be a copy of "right" iterator.
ie
if (iter == right) will always be true. Am I correct ? The same is
true for deque and list also. Is this correct ?

No.

After the erase, right is invalid, and any attempt to use it
(including comparing it with iter) is undefined behavior. With
g++, in debug mode, it crashes---I would expect this to be the
case with any quality implementation.

Given a standard library container, can we call clear() function on
empty container ? Or will it invoke undefined behaviour ?

You can always call clear(), on any container.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Bo Persson]

Martin Vuille wrote:

Martin York <Ma***************@gmail.comwrote in
news:14**********************************@j78g2000 hsd.googlegrou
ps.com:

>>

>>Suppose that "left" and "right" are valid iterators into
"container" and that "right" is NOT container.end() and
"right" comes after "left".

vector<int>::iterator iter = container.erase(left, right);

then "iter" will always be a copy of "right" iterator.

No. iter will be an iterator to the element after right:
see: http://www.cplusplus.com/reference/s...tor/erase.html

Which says: "the range includes all the elements between first and
last, including the element pointed by first but *not* the one
pointed by last." (emphasis mine)

iter will point to the same element as right. But the two
iterators will not be "equal" or "copies" because erase()
invalidates all iterators to elements after position first.
Thus right is no longer valid after erase() returns.

And that is a very strong reason for erase() to return a new, valid
iterator!
Bo Persson

[Andrew Koenig]

"Bo Persson" <bo*@gmb.dkwrote in message
news:60*************@mid.individual.net...

>iter will point to the same element as right. But the two
iterators will not be "equal" or "copies" because erase()
invalidates all iterators to elements after position first.
Thus right is no longer valid after erase() returns.

And that is a very strong reason for erase() to return a new, valid
iterator!

If you need such an iterator, you can call begin() or end().