[insert.iterators] - C++17 → C++20

Files changed (1) hide show

tmp/tmpb2ermarb/{from.md → to.md} +59 -88

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

@@ -14,16 +14,16 @@ insert corresponding elements into the container. This device allows all
 of the copying algorithms in the library to work in the *insert mode*
 instead of the *regular overwrite* mode.
 An insert iterator is constructed from a container and possibly one of
 its iterators pointing to where insertion takes place if it is neither
-at the beginning nor at the end of the container. Insert iterators
-satisfy the requirements of output iterators. `operator*` returns the
-insert iterator itself. The assignment `operator=(const T& x)` is
-defined on insert iterators to allow writing into them, it inserts `x`
-right before where the insert iterator is pointing. In other words, an
-insert iterator is like a cursor pointing into the container where the
 insertion takes place. `back_insert_iterator` inserts elements at the
 end of a container, `front_insert_iterator` inserts elements at the
 beginning of a container, and `insert_iterator` inserts elements where
 the iterator points to in a container. `back_inserter`,
 `front_inserter`, and `inserter` are three functions making the insert
@@ -34,84 +34,74 @@ iterators out of a container.
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
-    Container* container;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
-    using difference_type   = void;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
- explicit back_insert_iterator(Container& x);
- back_insert_iterator& operator=(const typename Container::value_type& value);
-    back_insert_iterator& operator=(typename Container::value_type&& value);
-    back_insert_iterator& operator*();
-    back_insert_iterator& operator++();
-    back_insert_iterator  operator++(int);
   };
-  template <class Container>
-    back_insert_iterator<Container> back_inserter(Container& x);
 }
 ```
-#### `back_insert_iterator` operations <a id="back.insert.iter.ops">[[back.insert.iter.ops]]</a>
-##### `back_insert_iterator` constructor <a id="back.insert.iter.cons">[[back.insert.iter.cons]]</a>
 ``` cpp
-explicit back_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
-##### `back_insert_iterator::operator=` <a id="back.insert.iter.op=">[[back.insert.iter.op=]]</a>
 ``` cpp
-back_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_back(value);`
 *Returns:* `*this`.
 ``` cpp
-back_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_back(std::move(value));`
 *Returns:* `*this`.
-##### `back_insert_iterator::operator*` <a id="back.insert.iter.op*">[[back.insert.iter.op*]]</a>
 ``` cpp
-back_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
-##### `back_insert_iterator::operator++` <a id="back.insert.iter.op++">[[back.insert.iter.op++]]</a>
 ``` cpp
-back_insert_iterator& operator++();
-back_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 #####  `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
 ``` cpp
 template<class Container>
-  back_insert_iterator<Container> back_inserter(Container& x);
 ```
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
@@ -119,84 +109,74 @@ template <class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
-    Container* container;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
-    using difference_type   = void;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
- explicit front_insert_iterator(Container& x);
- front_insert_iterator& operator=(const typename Container::value_type& value);
-    front_insert_iterator& operator=(typename Container::value_type&& value);
-    front_insert_iterator& operator*();
-    front_insert_iterator& operator++();
-    front_insert_iterator  operator++(int);
   };
-  template <class Container>
-    front_insert_iterator<Container> front_inserter(Container& x);
 }
 ```
-#### `front_insert_iterator` operations <a id="front.insert.iter.ops">[[front.insert.iter.ops]]</a>
-##### `front_insert_iterator` constructor <a id="front.insert.iter.cons">[[front.insert.iter.cons]]</a>
 ``` cpp
-explicit front_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
-##### `front_insert_iterator::operator=` <a id="front.insert.iter.op=">[[front.insert.iter.op=]]</a>
 ``` cpp
-front_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_front(value);`
 *Returns:* `*this`.
 ``` cpp
-front_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_front(std::move(value));`
 *Returns:* `*this`.
-##### `front_insert_iterator::operator*` <a id="front.insert.iter.op*">[[front.insert.iter.op*]]</a>
 ``` cpp
-front_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
-##### `front_insert_iterator::operator++` <a id="front.insert.iter.op++">[[front.insert.iter.op++]]</a>
 ``` cpp
-front_insert_iterator& operator++();
-front_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
 ``` cpp
 template<class Container>
-  front_insert_iterator<Container> front_inserter(Container& x);
 ```
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
@@ -204,50 +184,44 @@ template <class Container>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
-    Container* container;
- typename Container::iterator iter;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
-    using difference_type   = void;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
-    insert_iterator(Container& x, typename Container::iterator i);
-    insert_iterator& operator=(const typename Container::value_type& value);
-    insert_iterator& operator=(typename Container::value_type&& value);
-    insert_iterator& operator*();
-    insert_iterator& operator++();
-    insert_iterator& operator++(int);
   };
-  template <class Container>
-    insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
 }
 ```
-#### `insert_iterator` operations <a id="insert.iter.ops">[[insert.iter.ops]]</a>
-##### `insert_iterator` constructor <a id="insert.iter.cons">[[insert.iter.cons]]</a>
 ``` cpp
-insert_iterator(Container& x, typename Container::iterator i);
 ```
 *Effects:* Initializes `container` with `addressof(x)` and `iter` with
 `i`.
-##### `insert_iterator::operator=` <a id="insert.iter.op=">[[insert.iter.op=]]</a>
 ``` cpp
-insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by:
 ``` cpp
@@ -256,11 +230,11 @@ iter = container->insert(iter, value);
 ```
 *Returns:* `*this`.
 ``` cpp
-insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by:
 ``` cpp
@@ -268,31 +242,28 @@ iter = container->insert(iter, std::move(value));
 ++iter;
 ```
 *Returns:* `*this`.
-##### `insert_iterator::operator*` <a id="insert.iter.op*">[[insert.iter.op*]]</a>
 ``` cpp
-insert_iterator& operator*();
 ```
 *Returns:* `*this`.
-##### `insert_iterator::operator++` <a id="insert.iter.op++">[[insert.iter.op++]]</a>
 ``` cpp
-insert_iterator& operator++();
-insert_iterator& operator++(int);
 ```
 *Returns:* `*this`.
 ##### `inserter` <a id="inserter">[[inserter]]</a>
 ``` cpp
 template<class Container>
-  insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.

 of the copying algorithms in the library to work in the *insert mode*
 instead of the *regular overwrite* mode.
 An insert iterator is constructed from a container and possibly one of
 its iterators pointing to where insertion takes place if it is neither
+at the beginning nor at the end of the container. Insert iterators meet
+the requirements of output iterators. `operator*` returns the insert
+iterator itself. The assignment `operator=(const T& x)` is defined on
+insert iterators to allow writing into them, it inserts `x` right before
+where the insert iterator is pointing. In other words, an insert
+iterator is like a cursor pointing into the container where the
 insertion takes place. `back_insert_iterator` inserts elements at the
 end of a container, `front_insert_iterator` inserts elements at the
 beginning of a container, and `insert_iterator` inserts elements where
 the iterator points to in a container. `back_inserter`,
 `front_inserter`, and `inserter` are three functions making the insert
 ``` cpp
 namespace std {
   template<class Container>
   class back_insert_iterator {
   protected:
+    Container* container = nullptr;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
+    using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
+ constexpr back_insert_iterator() noexcept = default;
+ constexpr explicit back_insert_iterator(Container& x);
+ constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
+    constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
+ constexpr back_insert_iterator& operator*();
+ constexpr back_insert_iterator& operator++();
+ constexpr back_insert_iterator  operator++(int);
   };
 }
 ```
+##### Operations <a id="back.insert.iter.ops">[[back.insert.iter.ops]]</a>
 ``` cpp
+constexpr explicit back_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
 ``` cpp
+constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_back(value);`
 *Returns:* `*this`.
 ``` cpp
+constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_back(std::move(value));`
 *Returns:* `*this`.
 ``` cpp
+constexpr back_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr back_insert_iterator& operator++();
+constexpr back_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 #####  `back_inserter` <a id="back.inserter">[[back.inserter]]</a>
 ``` cpp
 template<class Container>
+ constexpr back_insert_iterator<Container> back_inserter(Container& x);
 ```
 *Returns:* `back_insert_iterator<Container>(x)`.
 #### Class template `front_insert_iterator` <a id="front.insert.iterator">[[front.insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class front_insert_iterator {
   protected:
+    Container* container = nullptr;
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
+    using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
+ constexpr front_insert_iterator() noexcept = default;
+ constexpr explicit front_insert_iterator(Container& x);
+ constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
+    constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
+ constexpr front_insert_iterator& operator*();
+ constexpr front_insert_iterator& operator++();
+ constexpr front_insert_iterator  operator++(int);
   };
 }
 ```
+##### Operations <a id="front.insert.iter.ops">[[front.insert.iter.ops]]</a>
 ``` cpp
+constexpr explicit front_insert_iterator(Container& x);
 ```
 *Effects:* Initializes `container` with `addressof(x)`.
 ``` cpp
+constexpr front_insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by: `container->push_front(value);`
 *Returns:* `*this`.
 ``` cpp
+constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by: `container->push_front(std::move(value));`
 *Returns:* `*this`.
 ``` cpp
+constexpr front_insert_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr front_insert_iterator& operator++();
+constexpr front_insert_iterator  operator++(int);
 ```
 *Returns:* `*this`.
 ##### `front_inserter` <a id="front.inserter">[[front.inserter]]</a>
 ``` cpp
 template<class Container>
+ constexpr front_insert_iterator<Container> front_inserter(Container& x);
 ```
 *Returns:* `front_insert_iterator<Container>(x)`.
 #### Class template `insert_iterator` <a id="insert.iterator">[[insert.iterator]]</a>
 ``` cpp
 namespace std {
   template<class Container>
   class insert_iterator {
   protected:
+    Container* container = nullptr;
+ ranges::iterator_t<Container> iter = ranges::iterator_t<Container>();
   public:
     using iterator_category = output_iterator_tag;
     using value_type        = void;
+    using difference_type   = ptrdiff_t;
     using pointer           = void;
     using reference         = void;
     using container_type    = Container;
+    insert_iterator() = default;
+ constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
+ constexpr insert_iterator& operator=(const typename Container::value_type& value);
+    constexpr insert_iterator& operator=(typename Container::value_type&& value);
+ constexpr insert_iterator& operator*();
+ constexpr insert_iterator& operator++();
+ constexpr insert_iterator& operator++(int);
   };
 }
 ```
+##### Operations <a id="insert.iter.ops">[[insert.iter.ops]]</a>
 ``` cpp
+constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
 ```
 *Effects:* Initializes `container` with `addressof(x)` and `iter` with
 `i`.
 ``` cpp
+constexpr insert_iterator& operator=(const typename Container::value_type& value);
 ```
 *Effects:* As if by:
 ``` cpp
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr insert_iterator& operator=(typename Container::value_type&& value);
 ```
 *Effects:* As if by:
 ``` cpp
 ++iter;
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr insert_iterator& operator*();
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr insert_iterator& operator++();
+constexpr insert_iterator& operator++(int);
 ```
 *Returns:* `*this`.
 ##### `inserter` <a id="inserter">[[inserter]]</a>
 ``` cpp
 template<class Container>
+ constexpr insert_iterator<Container>
+    inserter(Container& x, ranges::iterator_t<Container> i);
 ```
 *Returns:* `insert_iterator<Container>(x, i)`.

Diff to HTML by rtfpessoa