4

In item 17 of exceptional c++, I find this:

First, for all containers, multi-element inserts ("iterator range" inserts) are never strongly exception-safe.

but in item 1 of effective STL, I find this:

If you need transactional semantics for multiple-element insertions (e.g., the range form — see Item 5), you'll want to choose list, because list is the only standard container that offers transactional semantics for multiple-element insertions.

and in page 249 of the c++ standard library 2th, I find this:

For lists, even multiple-element insert operations are transaction safe.

So my question is which one is right? Is strongly exceptional-safe means the same with transaction safe?

songyuanyao
  • 169,198
  • 16
  • 310
  • 405
guorongfei
  • 309
  • 2
  • 10

2 Answers2

3
  1. which one is right?

For all the overloads of std::list::insert, strongly exception-safety is guaranteed.

Exceptions

If an exception is thrown, there are no effects (strong exception guarantee).

and from the standard, $23.3.5.4/2 list modifiers [list.modifiers]:

If an exception is thrown there are no effects.

then

  1. is strongly exceptional-safe means the same with transaction safe?

Yes. Here's an explanation from Herb Sutter:

Strong Guarantee: If an exception is thrown, program state remains unchanged. This level always implies global commit-or-rollback semantics, including that no references or iterators into a container be invalidated if an operation fails.

Community
  • 1
  • 1
songyuanyao
  • 169,198
  • 16
  • 310
  • 405
  • @songyuanyao Sorry, I'm confused. Do you mean that Herb Sutter is wrong about the *range insertion* being not *exception-safe* (i.e., *transaction safe*) for *all containers*? Is this because that statement does not apply to `std::list` ? – JFMR Jun 05 '18 at 06:30
  • 1
    @ネロク Yes, it's wrong to say *for all containers*. For example `std::vector` might not support strong exception guarantee, but `std::list` supports. – songyuanyao Jun 05 '18 at 06:41
  • @songyuanyao Thanks for clarifying. It really helps. – JFMR Jun 05 '18 at 06:42
1

It is already answered that std::list provides this guarantees as per standard. I'd like to mention why it is possible to do this in the list.

You can provide this guarantee because list has a constant complexity merge operation, which is a non-throwing operation. All you need to do is to first create a temporary list, fill the temporary list with values and than merge temporary list into original list.

If exception happens while populating temporary list, nothing is merged, and temporary list is simply disposed when the insert exits.

Since no other container provides constant complexity no-throwing merge, it is not possible with any other container.

SergeyA
  • 61,605
  • 5
  • 78
  • 137