Re: invalidation of iterators on deque<T>:insert()
On Sep 30, 2:19 pm, "subramanian10...@yahoo.com, India"
<subramanian10...@yahoo.com> wrote:
In ISO/IEC 14882:2003 document, in the section '23.2.1.3 deque
modifiers', the following is mentioned:
iterator insert(iterator position, const T& x);
void insert(iterator position, size_type n, const T& x);
template <class InputIterator>
void insert(iterator positOn Sep 30, 2:19 pm, "subramanian10...@yahoo.com=
, India" <subramanian10...@yahoo.com> wrote:
In ISO/IEC 14882:2003 document, in the section '23.2.1.3 deque
modifiers', the following is mentioned:
iterator insert(iterator position, const T& x);
void insert(iterator position, size_type n, const T& x);
template <class InputIterator>
void insert(iterator position, InputIterator first, InputIterator
last);
1 Effects: An insert in the middle of the deque invalidates all the
iterators and references to elements of the deque. An insert at either
end of the deque invalidates all the iterators to the deque, but has
no effect on the validity of references to elements of the deque.
My questions:
--------------------
what is meant by invalidation of iterators to elements of the deque
and what is meant by invalidation of references to elements of deque ?
(Are they different ?) Kindly give an example so that I can
understand. The second statement in the above, says that 'but has no
effect on the validity of references to elements of the deque'. Here
what is meant by 'but has no effect on the validity of references to
elements' ?.
Though the standard does not restrict the data structure for
implementing
the containers in the STL.
But taking the usual implemtions of the deque in to account for
answering these question
makes is easier.
The usual data structure of std::deque<T> can be simplified as
array of pointer to array of T, that is
[ ][ ][ ][ ]
| |
| |
* *
* *
* *
[] is a slot, aka pointer to array of T
* is a T
obviously insertion in the middle invalidates both iterators and
reference
while insertion on both ends, array of T maybe allocated if the first/
last array of T
is full, so references are not invalidate. remind that increment/
decrement is invalid for the original interators which is part of
invildation of iterator, while validation of reference only requires
the reference refer to the right original element.
2 Notes: If an exception is thrown other than by the copy constructor
or assignment operator of T there are no effects.
My questions:
--------------------
Here what exceptions are thrown by copy ctor and assignment operator?
(Is it bad_alloc exception ?).
All exceptions that may occur, I think.
What operations other than copy ctor
and assignment of T can throw exception ? What are those exceptions ?
What is meant by saying 'there are no effects' ?
It means that the original data remainds.
Check out http://www.boost.org/community/exception_safety.html
Kindly explain.
--
Best Regards
Barry