Merge 2021-10 LWG Motion 9

P1072R10 basic_string::resize_and_overwrite

Author: tkoeppe

source/containers.tex

@@ -54,10 +54,10 @@
 \end{example}
 
 \pnum
-For the components affected by this subclause that declare an \tcode{allocator_type},
-objects stored in these components shall be constructed using the function
+Allocator-aware containers (\tref{container.alloc.req})
+other than \tcode{basic_string} construct elements using the function
 \tcode{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}construct}
-and destroyed using the function
+and destroy elements using the function
 \tcode{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}destroy}\iref{allocator.traits.members},
 where \tcode{U} is either \tcode{allocator_type::value_type} or
 an internal type used by the container.
@@ -541,7 +541,8 @@
 an expression \tcode{v} of type (possibly \keyword{const}) \tcode{T},
 and an rvalue \tcode{rv} of type \tcode{T},
 the following terms are defined. If \tcode{X}
-is not allocator-aware, the terms below are defined as if \tcode{A} were
+is not allocator-aware or is a specialization of \tcode{basic_string},
+the terms below are defined as if \tcode{A} were
 \tcode{allocator<T>} --- no allocator object needs to be created
 and user specializations of \tcode{allocator<T>} are not instantiated:
 

source/strings.tex

@@ -868,6 +868,7 @@
     constexpr size_type max_size() const noexcept;
     constexpr void resize(size_type n, charT c);
     constexpr void resize(size_type n);
+    template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
     constexpr size_type capacity() const noexcept;
     constexpr void reserve(size_type res_arg);
     constexpr void shrink_to_fit();
@@ -1109,6 +1110,12 @@
 the type \tcode{traits} shall meet
 the character traits requirements\iref{char.traits}.
 \begin{note}
+Every specialization \tcode{basic_string<charT, traits, Allocator>} is
+an allocator-aware container,
+but does not use the allocator's \tcode{construct} and \tcode{destroy}
+member functions\iref{container.requirements.general}.
+\end{note}
+\begin{note}
 The program is ill-formed if \tcode{traits::char_type}
 is not the same type as \tcode{charT}.
 \end{note}
@@ -1609,6 +1616,61 @@
 Equivalent to \tcode{resize(n, charT())}.
 \end{itemdescr}
 
+\indexlibrarymember{resize_and_overwrite}{basic_string}%
+\begin{itemdecl}
+template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+Let
+\begin{itemize}
+\item
+\tcode{o = size()} before the call to \tcode{resize_and_overwrite}.
+\item
+\tcode{k} be \tcode{min(o, n)}.
+\item
+\tcode{p} be a \tcode{charT*},
+such that the range \crange{p}{p + n} is valid and
+\tcode{this->compare(0, k, p, k) == 0} is \tcode{true} before the call.
+The values in the range \crange{p + k}{p + n} may be indeterminate\iref{basic.indet}.
+\item
+$OP$ be the expression \tcode{std::move(op)(p, n)}.
+\item
+\tcode{r} = $OP$.
+\end{itemize}
+
+\pnum
+\mandates
+$OP$ has an integer-like type\iref{iterator.concept.winc}.
+
+\pnum
+\expects
+\begin{itemize}
+\item
+$OP$ does not throw an exception or modify \tcode{p} or \tcode{n}.
+\item
+$\tcode{r} \geq 0$.
+\item
+$\tcode{r} \leq \tcode{n}$.
+\item
+After evaluating $OP$
+there are no indeterminate values in the range \range{p}{p + r}.
+\end{itemize}
+
+\pnum
+\effects
+Evaluates $OP$,
+replaces the contents of \tcode{*this} with \range{p}{p + r}, and
+invalidates all pointers and references to the range \crange{p}{p + n}.
+
+\pnum
+\recommended
+Implementations should avoid unnecessary copies and allocations
+by, for example, making \tcode{p} a pointer into internal storage and
+by restoring \tcode{*(p + r)} to \tcode{charT()} after evaluating $OP$.
+\end{itemdescr}
+
 \indexlibrarymember{capacity}{basic_string}%
 \begin{itemdecl}
 constexpr size_type capacity() const noexcept;

source/support.tex

@@ -686,6 +686,7 @@
 #define @\defnlibxname{cpp_lib_starts_ends_with}@                  201711L // also in \libheader{string}, \libheader{string_view}
 #define @\defnlibxname{cpp_lib_stdatomic_h}@                       202011L // also in \libheader{stdatomic.h}
 #define @\defnlibxname{cpp_lib_string_contains}@                   202011L // also in \libheader{string}, \libheader{string_view}
+#define @\defnlibxname{cpp_lib_string_resize_and_overwrite}@       202110L // also in \libheader{string}
 #define @\defnlibxname{cpp_lib_string_udls}@                       201304L // also in \libheader{string}
 #define @\defnlibxname{cpp_lib_string_view}@                       201803L // also in \libheader{string}, \libheader{string_view}
 #define @\defnlibxname{cpp_lib_syncbuf}@                           201803L // also in \libheader{syncstream}