Re: Exception Safety Concerning Range Members
on Mon May 21 2007, "jehugaleahsa-AT-gmail.com"
<jehugaleahsa-AT-gmail.com> wrote:
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.
Which is exactly equivalent to the splice technique. It gives the
strong guarantee.
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 don't think that code is relevant to what we're looking at.
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.
I don't understand the relevance of that statement.
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.
No, there's no way it can be. The GCC code is clearly buggy.
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=32017
In either case, I don't see splice being used, even though it would
seem to be more exception safe.
It's not more exception safe than the Dinkum approach, though it is
simpler. The Dinkum approach has the advantage of working with
unequal allocators (for some definition of "working" that I'm sure
Dinkumware supplies somewhere).
That is why I was curious in the first place. Perhaps I missed
something.
Perhaps; perhaps not ;-).
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]