[container.requirements.general]

Files changed (1) hide show

tmp/tmpjhgut_ij/{from.md → to.md} +77 -32

tmp/tmpjhgut_ij/{from.md → to.md} RENAMED Viewed

@@ -19,15 +19,16 @@ function and destroyed using the
 container’s element type, not for internal types used by the container.
 This means, for example, that a node-based container might need to
 construct nodes containing aligned buffers and call `construct` to place
 the element into the buffer.
-In Tables  [[tab:containers.container.requirements]] and
-[[tab:containers.reversible.requirements]], `X` denotes a container
-class containing objects of type `T`, `a` and `b` denote values of type
-`X`, `u` denotes an identifier, `r` denotes a non-const value of type
-`X`, and `rv` denotes a non-const rvalue of type `X`.
 Notes: the algorithm `equal()` is defined in Clause  [[algorithms]].
 Those entries marked “(Note A)” or “(Note B)” have linear complexity for
 `array` and have constant complexity for all other standard containers.
@@ -39,28 +40,44 @@ constructors, inserts, and erases.
 returns an iterator referring to the first element in the container.
 `end()` returns an iterator which is the past-the-end value for the
 container. If the container is empty, then `begin() == end()`;
 Unless otherwise specified, all containers defined in this clause obtain
 memory using an allocator (see  [[allocator.requirements]]). Copy
 constructors for these container types obtain an allocator by calling
 `allocator_traits<allocator_type>::select_on_container_copy_construction`
-on their first parameters. Move constructors obtain an allocator by move
-construction from the allocator belonging to the container being moved.
-Such move construction of the allocator shall not exit via an exception.
-All other constructors for these container types take an `Allocator&`
-argument ([[allocator.requirements]]), an allocator whose value type is
-the same as the container’s value type. If an invocation of a
-constructor uses the default value of an optional allocator argument,
-then the `Allocator` type must support value initialization. A copy of
-this allocator is used for any memory allocation performed, by these
-constructors and by all member functions, during the lifetime of each
-container object or until the allocator is replaced. The allocator may
-be replaced only via assignment or `swap()`. Allocator replacement is
-performed by copy assignment, move assignment, or swapping of the
-allocator only if
 `allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value`,
 `allocator_traits<allocator_type>::propagate_on_container_move_assignment::value`,
 or
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is true within the implementation of the corresponding container
@@ -99,12 +116,13 @@ Unless otherwise specified (see  [[associative.reqmts.except]],
 container types defined in this Clause meet the following additional
 requirements:
 - if an exception is thrown by an `insert()` or `emplace()` function
   while inserting a single element, that function has no effects.
-- if an exception is thrown by a `push_back()` or `push_front()`
-  function, that function has no effects.
 - no `erase()`, `clear()`, `pop_back()` or `pop_front()` function throws
   an exception.
 - no copy constructor or assignment operator of a returned iterator
   throws an exception.
 - no `swap()` function throws an exception.
@@ -132,29 +150,56 @@ All of the containers defined in this Clause and in ([[basic.string]])
 except `array` meet the additional requirements of an allocator-aware
 container, as described in Table  [[tab:containers.allocatoraware]].
 Given a container type `X` having an `allocator_type` identical to `A`
 and a `value_type` identical to `T` and given an lvalue `m` of type `A`,
-a pointer `p` of type `T*`, an expression `v` of type `T`, and an rvalue
-`rv` of type `T`, the following terms are defined. (If `X` is not
-allocator-aware, the terms below are defined as if `A` were
-`std::allocator<T>`.)
-- `T` is *`CopyInsertable` into `X`* means that the following expression
-  is well-formed:
   ``` cpp
-  allocator_traits<A>::construct(m, p, v);
   ```
 - `T` is *`MoveInsertable` into `X`* means that the following expression
   is well-formed:
   ``` cpp
-  allocator_traits<A>::construct(m, p, rv);
   ```
 - `T` is *`EmplaceConstructible` into `X` from `args`*, for zero or more
   arguments `args`, means that the following expression is well-formed:
   ``` cpp
-  allocator_traits<A>::construct(m, p, args);
   ```
 A container calls `allocator_traits<A>::construct(m, p, args)` to
 construct an element at `p` using `args`. The default `construct` in
 `std::allocator` will call `::new((void*)p) T(args)`, but specialized
@@ -162,8 +207,8 @@ allocators may choose a different definition.
 In Table  [[tab:containers.allocatoraware]], `X` denotes an
 allocator-aware container class with a `value_type` of `T` using
 allocator of type `A`, `u` denotes a variable, `a` and `b` denote
 non-const lvalues of type `X`, `t` denotes an lvalue or a const rvalue
-of type X``, `rv` denotes a non-const rvalue of type `X`, `m` is a value
-of type `A`, and `Q` is an allocator type.

 container’s element type, not for internal types used by the container.
 This means, for example, that a node-based container might need to
 construct nodes containing aligned buffers and call `construct` to place
 the element into the buffer.
+In Tables  [[tab:containers.container.requirements]],
+[[tab:containers.reversible.requirements]], and
+[[tab:containers.optional.operations]] `X` denotes a container class
+containing objects of type `T`, `a` and `b` denote values of type `X`,
+`u` denotes an identifier, `r` denotes a non-const value of type `X`,
+and `rv` denotes a non-const rvalue of type `X`.
 Notes: the algorithm `equal()` is defined in Clause  [[algorithms]].
 Those entries marked “(Note A)” or “(Note B)” have linear complexity for
 `array` and have constant complexity for all other standard containers.
 returns an iterator referring to the first element in the container.
 `end()` returns an iterator which is the past-the-end value for the
 container. If the container is empty, then `begin() == end()`;
+In the expressions
+``` cpp
+i == j
+i != j
+i < j
+i <= j
+i >= j
+i > j
+i - j
+```
+where `i` and `j` denote objects of a container’s `iterator` type,
+either or both may be replaced by an object of the container’s
+`const_iterator` type referring to the same element with no change in
+semantics.
 Unless otherwise specified, all containers defined in this clause obtain
 memory using an allocator (see  [[allocator.requirements]]). Copy
 constructors for these container types obtain an allocator by calling
 `allocator_traits<allocator_type>::select_on_container_copy_construction`
+on the allocator belonging to the container being copied. Move
+constructors obtain an allocator by move construction from the allocator
+belonging to the container being moved. Such move construction of the
+allocator shall not exit via an exception. All other constructors for
+these container types take a `const allocator_type&` argument. If an
+invocation of a constructor uses the default value of an optional
+allocator argument, then the `Allocator` type must support value
+initialization. A copy of this allocator is used for any memory
+allocation performed, by these constructors and by all member functions,
+during the lifetime of each container object or until the allocator is
+replaced. The allocator may be replaced only via assignment or `swap()`.
+Allocator replacement is performed by copy assignment, move assignment,
+or swapping of the allocator only if
 `allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value`,
 `allocator_traits<allocator_type>::propagate_on_container_move_assignment::value`,
 or
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is true within the implementation of the corresponding container
 container types defined in this Clause meet the following additional
 requirements:
 - if an exception is thrown by an `insert()` or `emplace()` function
   while inserting a single element, that function has no effects.
+- if an exception is thrown by a `push_back()`, `push_front()`,
+ `emplace_back()`, or `emplace_front()` function, that function has no
+  effects.
 - no `erase()`, `clear()`, `pop_back()` or `pop_front()` function throws
   an exception.
 - no copy constructor or assignment operator of a returned iterator
   throws an exception.
 - no `swap()` function throws an exception.
 except `array` meet the additional requirements of an allocator-aware
 container, as described in Table  [[tab:containers.allocatoraware]].
 Given a container type `X` having an `allocator_type` identical to `A`
 and a `value_type` identical to `T` and given an lvalue `m` of type `A`,
+a pointer `p` of type `T*`, an expression `v` of type (possibly const)
+`T`, and an rvalue `rv` of type `T`, the following terms are defined. If
+`X` is not allocator-aware, the terms below are defined as if `A` were
+`std::allocator<T>` — no allocator object needs to be created and user
+specializations of `std::allocator<T>` are not instantiated:
+- `T` is *`DefaultInsertable` into `X`* means that the following
+ expression is well-formed:
   ``` cpp
+  allocator_traits<A>::construct(m, p)
   ```
+- An element of `X` is *default-inserted* if it is initialized by
+  evaluation of the expression
+  ``` cpp
+  allocator_traits<A>::construct(m, p)
+  ```
+  where `p` is the address of the uninitialized storage for the element
+  allocated within `X`.
 - `T` is *`MoveInsertable` into `X`* means that the following expression
   is well-formed:
   ``` cpp
+  allocator_traits<A>::construct(m, p, rv)
   ```
+  and its evaluation causes the following postcondition to hold: The
+  value of `*p` is equivalent to the value of `rv` before the
+  evaluation. rv remains a valid object. Its state is unspecified
+- `T` is *`CopyInsertable` into `X`* means that, in addition to `T`
+  being `MoveInsertable` into `X`, the following expression is
+  well-formed:
+  ``` cpp
+  allocator_traits<A>::construct(m, p, v)
+  ```
+  and its evaluation causes the following postcondition to hold: The
+  value of `v` is unchanged and is equivalent to `*p`.
 - `T` is *`EmplaceConstructible` into `X` from `args`*, for zero or more
   arguments `args`, means that the following expression is well-formed:
   ``` cpp
+  allocator_traits<A>::construct(m, p, args)
+  ```
+- `T` is *`Erasable` from `X`* means that the following expression is
+  well-formed:
+  ``` cpp
+  allocator_traits<A>::destroy(m, p)
   ```
 A container calls `allocator_traits<A>::construct(m, p, args)` to
 construct an element at `p` using `args`. The default `construct` in
 `std::allocator` will call `::new((void*)p) T(args)`, but specialized
 In Table  [[tab:containers.allocatoraware]], `X` denotes an
 allocator-aware container class with a `value_type` of `T` using
 allocator of type `A`, `u` denotes a variable, `a` and `b` denote
 non-const lvalues of type `X`, `t` denotes an lvalue or a const rvalue
+of type `X`, `rv` denotes a non-const rvalue of type `X`, and `m` is a
+value of type `A`.

Diff to HTML by rtfpessoa