Re: Exception Safety Concerning Range Members
In the case where the copy ctor and/or assignment operator of T can
throw an exception, **giving the strong guarantee** for
vector<T>::insert(pos,it0,it1) and deque<T>::insert(pos,it0,it1) would
impose an efficiency cost (you'd essentially have to allocate and copy
an entirely new container).
Yes, I first tried to implement the range insert for vector and
realized multiple reasons why it cannot provide the strong guarantee
without performance cost. The first being that you have to know
whether or not you need to reallocate. The std::distance of the range
*could* be constant time, but is not guaranteed.
Which means it unconditionally gives the strong guarantee. I suggest
you go to the standard for the official guarantees. The secondary
sources are often wrong or misleading.
Even though I am a little die-hard about C++, I find it difficult to
read the standard. I am not a compiler implementer, I am a programmer.
I will read the standard when 0x comes out, since I will need to do
some major catch up. :- )
Could you create a temporary list and then
splice it into *this?
Yes, you can.
Well, that is good. I am glad my noodle is working.
Does it require considerable, additional processing? Why don't any
implementations seem to use it?
Did you look at the actual code? If it's not ultimately doing
something equivalent to the above, in the case where the allocators
are equal, it's nonconforming. If you have found such a nonconforming
implementation, could you please let us know which one it is?
At the two implementations I looked at, specifically MSVC8, the code
looked something like this:
template<class _Iter>
void _Insert(iterator _Where,
_Iter _First, _Iter _Last, input_iterator_tag)
{
size_type _Num = 0;
try {
for (; _First != _Last; ++_First, ++_Num)
_Insert(_Where, *_First);
} catch (...) {
for (; 0 < _Num; --_Num)
{ // undo inserts
iterator _Before = _Where;
erase(--_Before);
}
}
}
This looks like it is adding the elements one at a time, and then
backing up if something goes wrong. This is what I see in GCC 3.4.4:
// Called by the range insert to implement [23.1.1]/9
template<typename _InputIterator>
void
_M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type)
{
for ( ; __first != __last; ++__first)
_M_insert(__pos, *__first);
}
followed by this:
// Called by insert(p,n,x), and the range insert when it turns out
// to be the same thing.
void
_M_fill_insert(iterator __pos, size_type __n, const value_type&
__x)
{
for ( ; __n > 0; --__n)
_M_insert(__pos, __x);
}
I had to track this one down. But in both cases, you see the elements
getting put in in a linear fashion. That is what surprised me. It is
hard to get an allocator from a generic range. The GCC version doesn't
even look like it tries to be exception-safe. Of course, perhaps it is
dealt with in the _M_ methods.
In either case, I don't see splice being used, even though it would
seem to be more exception safe.
That is why I was curious in the first place. Perhaps I missed
something.
Thanks!
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]