[container.requirements.general]

Files changed (1) hide show

tmp/tmpmun_5iyx/{from.md → to.md} +16 -249

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

@@ -1,256 +1,23 @@
-### General container requirements <a id="container.requirements.general">[[container.requirements.general]]</a>
-Containers are objects that store other objects. They control allocation
-and deallocation of these objects through constructors, destructors,
-insert and erase operations.
-All of the complexity requirements in this Clause are stated solely in
-terms of the number of operations on the contained objects.
-[*Example 1*: The copy constructor of type `vector<vector<int>>` has
-linear complexity, even though the complexity of copying each contained
-`vector<int>` is itself linear. — *end example*]
-For the components affected by this subclause that declare an
-`allocator_type`, objects stored in these components shall be
-constructed using the function
-`allocator_traits<allocator_type>::rebind_traits<U>::{}construct` and
-destroyed using the function
-`allocator_traits<allocator_type>::rebind_traits<U>::{}destroy`
-[[allocator.traits.members]], where `U` is either
-`allocator_type::value_type` or an internal type used by the container.
-These functions are called only for the container’s element type, not
-for internal types used by the container.
-[*Note 1*: 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. — *end note*]
-In Tables  [[tab:container.req]], [[tab:container.rev.req]], and
-[[tab:container.opt]] `X` denotes a container class containing objects
-of type `T`, `a` and `b` denote values of type `X`, `i` and `j` denote
-values of type (possibly const) `X::iterator`, `u` denotes an
-identifier, `r` denotes a non-const value of type `X`, and `rv` denotes
-a non-const rvalue of type `X`.
-Those entries marked “(Note A)” or “(Note B)” have linear complexity for
-`array` and have constant complexity for all other standard containers.
-[*Note 2*: The algorithm `equal()` is defined in
-[[algorithms]]. — *end note*]
-The member function `size()` returns the number of elements in the
-container. The number of elements is defined by the rules of
-constructors, inserts, and erases.
-`begin()`
-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
-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]]).
-[*Note 3*: In particular, containers and iterators do not store
-references to allocated elements other than through the allocator’s
-pointer type, i.e., as objects of type `P` or
-`pointer_traits<P>::template rebind<unspecified>`, where `P` is
-`allocator_traits<allocator_type>::pointer`. — *end note*]
-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.
-[*Note 4*: If an invocation of a constructor uses the default value of
-an optional allocator argument, then the allocator type must support
-value-initialization. — *end note*]
-A copy of this allocator is used for any memory allocation and element
-construction 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
-operation. In all container types defined in this Clause, the member
-`get_allocator()` returns a copy of the allocator used to construct the
-container or, if that allocator has been replaced, a copy of the most
-recent replacement.
-The expression `a.swap(b)`, for containers `a` and `b` of a standard
-container type other than `array`, shall exchange the values of `a` and
-`b` without invoking any move, copy, or swap operations on the
-individual container elements. Lvalues of any `Compare`, `Pred`, or
-`Hash` types belonging to `a` and `b` shall be swappable and shall be
-exchanged by calling `swap` as described in  [[swappable.requirements]].
-If
-`allocator_traits<allocator_type>::propagate_on_container_swap::value`
-is `true`, then lvalues of type `allocator_type` shall be swappable and
-the allocators of `a` and `b` shall also be exchanged by calling `swap`
-as described in  [[swappable.requirements]]. Otherwise, the allocators
-shall not be swapped, and the behavior is undefined unless
-`a.get_allocator() == b.get_allocator()`. Every iterator referring to an
-element in one container before the swap shall refer to the same element
-in the other container after the swap. It is unspecified whether an
-iterator with value `a.end()` before the swap will have value `b.end()`
-after the swap.
-If the iterator type of a container belongs to the bidirectional or
-random access iterator categories [[iterator.requirements]], the
-container is called *reversible* and meets the additional requirements
-in [[container.rev.req]].
-Unless otherwise specified (see  [[associative.reqmts.except]],
-[[unord.req.except]], [[deque.modifiers]], and [[vector.modifiers]]) all
-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.
-- no `swap()` function invalidates any references, pointers, or
-  iterators referring to the elements of the containers being swapped.
-  \[*Note 5*: The `end()` iterator does not refer to any element, so it
-  may be invalidated. — *end note*]
-Unless otherwise specified (either explicitly or by defining a function
-in terms of other functions), invoking a container member function or
-passing a container as an argument to a library function shall not
-invalidate iterators to, or change the values of, objects within that
-container.
-A *contiguous container* is a container whose member types `iterator`
-and `const_iterator` meet the *Cpp17RandomAccessIterator* requirements
-[[random.access.iterators]] and model `contiguous_iterator`
-[[iterator.concept.contiguous]].
-[[container.opt]] lists operations that are provided for some types of
-containers but not others. Those containers for which the listed
-operations are provided shall implement the semantics described in
-[[container.opt]] unless otherwise stated. If the iterators passed to
-`lexicographical_compare_three_way` meet the constexpr iterator
-requirements [[iterator.requirements.general]] then the operations
-described in [[container.opt]] are implemented by constexpr functions.
-[*Note 6*: The algorithm `lexicographical_compare_three_way` is defined
-in [[algorithms]]. — *end note*]
-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 [[container.alloc.req]].
-Given an allocator type `A` and given a container type `X` having a
-`value_type` identical to `T` and an `allocator_type` identical to
-`allocator_traits<A>::rebind_alloc<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 `allocator<T>` — no allocator object needs to be created and
-user specializations of `allocator<T>` are not instantiated:
-- `T` is **Cpp17DefaultInsertable* 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 **Cpp17MoveInsertable* 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.
-  \[*Note 7*: `rv` remains a valid object. Its state is
-  unspecified — *end note*]
-- `T` is **Cpp17CopyInsertable* into `X`* means that, in addition to `T`
-  being *Cpp17MoveInsertable* 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 **Cpp17EmplaceConstructible* 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 **Cpp17Erasable* from `X`* means that the following expression
-  is well-formed:
-  ``` cpp
-  allocator_traits<A>::destroy(m, p)
-  ```
-[*Note 8*: A container calls
-`allocator_traits<A>::construct(m, p, args)` to construct an element at
-`p` using `args`, with `m == get_allocator()`. The default `construct`
-in `allocator` will call `::new((void*)p) T(args)`, but specialized
-allocators may choose a different definition. — *end note*]
-In [[container.alloc.req]], `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`.
-The behavior of certain container member functions and deduction guides
-depends on whether types qualify as input iterators or allocators. The
-extent to which an implementation determines that a type cannot be an
-input iterator is unspecified, except that as a minimum integral types
-shall not qualify as input iterators. Likewise, the extent to which an
-implementation determines that a type cannot be an allocator is
-unspecified, except that as a minimum a type `A` shall not qualify as an
-allocator unless it meets both of the following conditions:
-- The *qualified-id* `A::value_type` is valid and denotes a type
-  [[temp.deduct]].
-- The expression `declval<A&>().allocate(size_t{})` is well-formed when
-  treated as an unevaluated operand.

+#### General <a id="container.requirements.general">[[container.requirements.general]]</a>
+In subclause [[container.gen.reqmts]],
+- `X` denotes a container class containing objects of type `T`,
+- `a` denotes a value of type `X`,
+- `b` and `c` denote values of type (possibly const) `X`,
+- `i` and `j` denote values of type (possibly const) `X::iterator`,
+- `u` denotes an identifier,
+- `v` denotes an lvalue of type (possibly const) `X` or an rvalue of
+  type `const X`,
+- `s` and `t` denote non-const lvalues of type `X`, and
+- `rv` denotes a non-const rvalue of type `X`.
+The following exposition-only concept is used in the definition of
+containers:
 ``` cpp
+template<class R, class T>
+concept container-compatible-range =    // exposition only
+  ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 ```

Diff to HTML by rtfpessoa