|
|
Boost-Commit : |
From: dgregor_at_[hidden]
Date: 2008-05-15 15:21:14
Author: dgregor
Date: 2008-05-15 15:21:13 EDT (Thu, 15 May 2008)
New Revision: 45402
URL: http://svn.boost.org/trac/boost/changeset/45402
Log:
Suggestions from Daniel Kruegler
Text files modified:
sandbox/committee/concepts/stdlib/clib-algorithms.tex | 50 ++++++++--------
sandbox/committee/concepts/stdlib/clib-concepts.tex | 120 +++++++++++++++++++++++++---------------
2 files changed, 100 insertions(+), 70 deletions(-)
Modified: sandbox/committee/concepts/stdlib/clib-algorithms.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-algorithms.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-algorithms.tex 2008-05-15 15:21:13 EDT (Thu, 15 May 2008)
@@ -197,7 +197,7 @@
OutIter copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
template<BidirectionalIterator InIter, MutableBidirectionalIterator OutIter>
- requires CopyAssignable<OutIter::reference, InIter::reference>
+ requires HasCopyAssign<OutIter::reference, InIter::reference>
OutIter copy_backward(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
@@ -206,7 +206,7 @@
OutIter move(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
- requires MoveAssignable<OutIter::reference, InIter::value_type>
+ requires HasMoveAssign<OutIter::reference, InIter::value_type>
OutIter move_backward(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
@@ -241,34 +241,34 @@
BinaryOp @\farg{binary_op}@);
template<MutableForwardIterator Iter, class T>
- requires HasEqualTo<Iter::reference, T> && CopyAssignable<Iter::reference, T>
+ requires HasEqualTo<Iter::reference, T> && HasCopyAssign<Iter::reference, T>
void replace(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
@\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::reference> Pred, class T>
- requires CopyAssignable<Iter::reference, T>
+ requires HasCopyAssign<Iter::reference, T>
void replace_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter, class T>
- requires CopyAssignable<OutIter::reference, T> && HasEqualTo<InIter::reference, T>
+ requires HasCopyAssign<OutIter::reference, T> && HasEqualTo<InIter::reference, T>
OutIter replace_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
Predicate<auto, InIter::reference> Pred, class T>
- requires CopyAssignable<OutIter::reference, T>
+ requires HasCopyAssign<OutIter::reference, T>
OutIter replace_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
template<MutableForwardIterator Iter, class T>
- requires CopyAssignable<Iter::reference, T>
+ requires HasCopyAssign<Iter::reference, T>
void fill(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
template<class Iter, Integral Size, class T>
requires OutputIterator<Iter, T>
void fill_n(Iter @\farg{first}@, Size @\farg{n}@, const T& @\farg{value}@);
template<MutableForwardIterator Iter, Callable Generator>
- requires CopyAssignable<Iter::reference, Generator::result_type>
+ requires HasCopyAssign<Iter::reference, Generator::result_type>
void generate(Iter @\farg{first}@, Iter @\farg{last}@,
Generator @\farg{gen}@);
template<class Iter, Integral Size, Callable Generator>
@@ -312,7 +312,7 @@
OutIter @\farg{result}@);
template<InputIterator InIter, MutableForwardIterator OutIter>
requires HasEqualTo<OutIter::reference, InIter::value_type> &&
- CopyAssignable<OutIter::reference, InIter::reference> &&
+ HasCopyAssign<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
@@ -328,7 +328,7 @@
OutIter @\farg{result}@);
template<InputIterator InIter, MutableForwardIterator OutIter,
Predicate<auto, OutIter::reference, InIter::reference> Pred>
- requires CopyAssignable<OutIter::reference, InIter::reference> &&
+ requires HasCopyAssign<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
@@ -425,7 +425,7 @@
Iter @\farg{last}@,
Compare @\farg{comp}@);
template<InputIterator InIter, @\removedCC{Mutable}@RandomAccessIterator RAIter>
- requires CopyAssignable<RAIter::reference, InIter::value_type> &&
+ requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
@\removedCC{SameType<RAIter::value_type\&, RAIter::reference> \&\& Swappable<RAIter::value_type> \&\&}@
@\removedCC{MoveConstructible<RAIter::value_type> \&\& MoveAssignable<RAIter::value_type> \&\&}@
@\addedCC{SwappableIterator<RAIter> \&\&}@
@@ -435,7 +435,7 @@
RAIter partial_sort_copy(InIter @\farg{first}@, InIter @\farg{last}@,
RAIter @\farg{result_first}@, RAIter @\farg{result_last}@);
template<InputIterator InIter, @\removedCC{Mutable}@RandomAccessIterator RAIter, class Compare>
- requires CopyAssignable<RAIter::reference, InIter::value_type> &&
+ requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
@\removedCC{SameType<RAIter::value_type\&, RAIter::reference> \&\& Swappable<RAIter::value_type> \&\&}@
@\removedCC{MoveConstructible<RAIter::value_type> \&\& MoveAssignable<RAIter::value_type> \&\&}@
@\addedCC{SwappableIterator<RAIter> \&\&}@
@@ -1407,7 +1407,7 @@
\index{copy_backward@\tcode{copy_backward}}%
\color{addclr}\begin{itemdecl}
template<BidirectionalIterator InIter, MutableBidirectionalIterator OutIter>
- requires CopyAssignable<OutIter::reference, InIter::reference>
+ requires HasCopyAssign<OutIter::reference, InIter::reference>
OutIter copy_backward(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
\end{itemdecl}\color{black}
@@ -1492,7 +1492,7 @@
\color{addclr}
\begin{itemdecl}
template<BidirectionalIterator InIter, BidirectionalIterator OutIter>
- requires MoveAssignable<OutIter::reference, InIter::value_type>
+ requires HasMoveAssign<OutIter::reference, InIter::value_type>
OutIter move_backward(InIter first, InIter last,
OutIter result);
\end{itemdecl}
@@ -1695,12 +1695,12 @@
\index{replace_if@\tcode{replace_if}}%
\color{addclr}\begin{itemdecl}
template<MutableForwardIterator Iter, class T>
- requires HasEqualTo<Iter::reference, T> && CopyAssignable<Iter::reference, T>
+ requires HasEqualTo<Iter::reference, T> && HasCopyAssign<Iter::reference, T>
void replace(Iter @\farg{first}@, Iter @\farg{last}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
@\textcolor{addclr}{template}@<MutableForwardIterator Iter, Predicate<auto, Iter::reference> Pred, class T>
- requires CopyAssignable<Iter::reference, T>
+ requires HasCopyAssign<Iter::reference, T>
void replace_if(Iter @\farg{first}@, Iter @\farg{last}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
\end{itemdecl}\color{black}
@@ -1732,14 +1732,14 @@
\index{replace_copy_if@\tcode{replace_copy_if}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter, class T>
- requires CopyAssignable<OutIter::reference, T> && HasEqualTo<InIter::reference, T>
+ requires HasCopyAssign<OutIter::reference, T> && HasEqualTo<InIter::reference, T>
OutIter replace_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
const T& @\farg{old_value}@, const T& @\farg{new_value}@);
template<InputIterator InIter, OutputIterator<auto, InIter::value_type> OutIter,
Predicate<auto, InIter::reference> Pred, class T>
- requires CopyAssignable<OutIter::reference, T>
+ requires HasCopyAssign<OutIter::reference, T>
OutIter replace_copy_if(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@,
Pred @\farg{pred}@, const T& @\farg{new_value}@);
@@ -1796,7 +1796,7 @@
\index{fill_n@\tcode{fill_n}}%
\color{addclr}\begin{itemdecl}
template<MutableForwardIterator Iter, class T>
- requires CopyAssignable<Iter::reference, T>
+ requires HasCopyAssign<Iter::reference, T>
void fill(Iter @\farg{first}@, Iter @\farg{last}@, const T& @\farg{value}@);
template<class Iter, Integral Size, class T>
@@ -1835,7 +1835,7 @@
\index{generate_n@\tcode{generate_n}}%
\color{addclr}\begin{itemdecl}
template<MutableForwardIterator Iter, Callable Generator>
- requires CopyAssignable<Iter::reference, Generator::result_type>
+ requires HasCopyAssign<Iter::reference, Generator::result_type>
void generate(Iter @\farg{first}@, Iter @\farg{last}@,
Generator @\farg{gen}@);
@@ -2024,7 +2024,7 @@
@\textcolor{addclr}{template}@<InputIterator InIter, MutableForwardIterator OutIter>
requires HasEqualTo<OutIter::reference, InIter::value_type> &&
- CopyAssignable<OutIter::reference, InIter::reference> &&
+ HasCopyAssign<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@);
@@ -2043,7 +2043,7 @@
template<InputIterator InIter, MutableForwardIterator OutIter,
Predicate<auto, OutIter::reference, InIter::reference> Pred>
- requires CopyAssignable<OutIter::reference, InIter::reference> &&
+ requires HasCopyAssign<OutIter::reference, InIter::reference> &&
!ForwardIterator<InIter>
OutIter unique_copy(InIter @\farg{first}@, InIter @\farg{last}@,
OutIter @\farg{result}@, Pred @\farg{pred}@);
@@ -2051,7 +2051,7 @@
\color{black}
\editorial{We assume (and require!) the proposed resolution to DR 538,
- which adds the \tcode{CopyAssignable} requirement.}
+ which adds the \tcode{HasCopyAssign} requirement.}
\editorial{Note that we have split the two signatures of
\tcode{unique_copy} into six signatures, to cover the actual
@@ -2565,7 +2565,7 @@
\index{partial_sort_copy@\tcode{partial_sort_copy}}%
\color{addclr}\begin{itemdecl}
template<InputIterator InIter, MutableRandomAccessIterator RAIter>
- requires CopyAssignable<RAIter::reference, InIter::value_type> &&
+ requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
SameType<RAIter::value_type&, RAIter::reference> && Swappable<RAIter::value_type> &&
MoveConstructible<RAIter::value_type> && MoveAssignable<RAIter::value_type> &&
HasLess<InIter::value_type, RAIter::value_type> &&
@@ -2575,7 +2575,7 @@
RAIter @\farg{result_first}@, RAIter @\farg{result_last}@);
template<InputIterator InIter, MutableRandomAccessIterator RAIter, class Compare>
- requires CopyAssignable<RAIter::reference, InIter::value_type> &&
+ requires HasCopyAssign<RAIter::reference, InIter::value_type> &&
SameType<RAIter::value_type&, RAIter::reference> && Swappable<RAIter::value_type> &&
MoveConstructible<RAIter::value_type> && MoveAssignable<RAIter::value_type> &&
Predicate<Compare, InIter::value_type, RAIter::value_type> &&
Modified: sandbox/committee/concepts/stdlib/clib-concepts.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-concepts.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-concepts.tex 2008-05-15 15:21:13 EDT (Thu, 15 May 2008)
@@ -73,8 +73,20 @@
\begin{itemize}
\item Added the \tcode{Has*Assign} concepts, which are required by
\tcode{valarray} and friends.
+\item Split \tcode{MoveAssignable} into the two-parameter
+ \tcode{HasMoveAssign} and the one-parameter \tcode{MoveAssignable};
+ the same split is also used for \tcode{CopyAssignable} and
+ \tcode{HasCopyAssign}.
\item Added the \tcode{MemberPointeeType} concept, and revised
\tcode{ReferentType} to permit reference types.
+\item Renamed \tcode{HeapAllocatable} to \tcode{FreeStoreAllocatable},
+ which better reflects the terminology of the standard.
+\item Changed the \tcode{IntegralLike} requirement for a \tcode{long
+ long} constructor into a requirement for a \tcode{intmax_t}
+ constructor.
+\item Added the \tcode{EqualityComparable} refinement to the
+ \tcode{Allocator} concept, and made its \tcode{construct} variadic
+ to match the latest \tcode{Allocator} requirements.
\end{itemize}
\end{titlepage}
@@ -156,7 +168,7 @@
// \ref{concept.comparison}, comparisons:
auto concept LessThanComparable<typename T> @\textit{see below}@;
auto concept EqualityComparable<typename T> @\textit{see below}@;
- auto concept TriviallyEqualityComparable<typename T> @\textit{see below}@;
+ @\removedCC{auto}@ concept TriviallyEqualityComparable<typename T> @\textit{see below}@;
// \ref{concept.destruct}, destruction:
auto concept Destructible<typename T> @\textit{see below}@;
@@ -171,13 +183,13 @@
auto concept MoveConstructible<typename T> @\textit{see below}@;
auto concept CopyConstructible<typename T> @\textit{see below}@;
concept TriviallyCopyConstructible<typename T> @\textit{see below}@;
- auto concept MoveAssignable<typename T, typename U = T> @\textit{see below}@;
- auto concept CopyAssignable<typename T, typename U = T> @\textit{see below}@;
+ auto concept MoveAssignable<typename T> @\textit{see below}@;
+ auto concept CopyAssignable<typename T> @\textit{see below}@;
concept TriviallyCopyAssignable<typename T> @\textit{see below}@;
auto concept Swappable<typename T> @\textit{see below}@;
// \ref{concept.memory}, memory allocation:
- auto concept HeapAllocatable<typename T> @\textit{see below}@;
+ auto concept FreeStoreAllocatable<typename T> @\textit{see below}@;
// \ref{concept.regular}, regular types:
auto concept Semiregular<typename T> @\textit{see below}@;
@@ -213,6 +225,8 @@
auto concept Dereferenceable<typename T> @\textit{see below}@;
auto concept Addressable<typename T> @\textit{see below}@;
auto concept Callable<typename F, typename... Args> @\textit{see below}@;
+ auto concept HasMoveAssign<typename T, typename U = T> @\textit{see below}@;
+ auto concept HasCopyAssign<typename T, typename U = T> @\textit{see below}@;
auto concept HasPlusAssign<typename T, typename U = T> @\textit{see below}@;
auto concept HasMinusAssign<typename T, typename U = T> @\textit{see below}@;
auto concept HasMultiplyAssign<typename T, typename U = T> @\textit{see below}@;
@@ -260,7 +274,9 @@
return type of a function.}
\pnum
-\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that is
+\addedConcepts{\mbox{\requires} for every}
+\addedCC{non-array}
+\addedConcepts{type \mbox{\tcode{T}} that is
\mbox{\techterm{cv}} \mbox{\tcode{void}} or that meets the
requirement \mbox{\tcode{MoveConstructible<T>}}
(\mbox{\ref{concept.copymove}}), the concept map
@@ -371,7 +387,7 @@
\end{itemdescr}
\begin{itemdecl}
-concept Class<typename T> : ClassType<Class> { }
+concept Class<typename T> : ClassType<T> { }
\end{itemdecl}
\begin{itemdescr}
@@ -590,8 +606,8 @@
\end{itemdescr}
\begin{itemdecl}
-auto concept EqualityComparable<typename T> : EqualTo<T> {
- bool operator!=(T const& a, U const& b) { return !(a == b); }
+auto concept EqualityComparable<typename T> : HasEqualTo<T> {
+ bool operator!=(T const& a, T const& b) { return !(a == b); }
axiom Consistency(T a, T b) {
(a == b) == !(a != b);
@@ -722,7 +738,6 @@
\begin{itemdecl}
auto concept CopyConstructible<typename T> : MoveConstructible<T>, HasConstructor<T, const T&> {
- @\addedCC{requires EqualityComparable<T>}@
axiom CopyPreservation(T x) {
T(x) == x;
}
@@ -752,10 +767,7 @@
\end{itemdescr}
\begin{itemdecl}
-auto concept MoveAssignable<typename T, typename U = T> {
- typename result_type;
- result_type T::operator=(U&&);
-}
+auto concept MoveAssignable<typename T> : HasMoveAssign<T> { }
\end{itemdecl}
\begin{itemdescr}
@@ -765,7 +777,7 @@
\end{itemdescr}
\begin{itemdecl}
-result_type T::operator=(U&& rv);
+result_type T::operator=(T&& rv); // inherited from HasMoveAssign
\end{itemdecl}
\begin{itemdescr}
@@ -779,12 +791,8 @@
\end{itemdescr}
\begin{itemdecl}
-auto concept CopyAssignable<typename T, typename U = T> : MoveAssignable<T, U> {
- typename result_type;
- result_type T::operator=(const U&);
-
- @\addedCC{requires EqualityComparable<T, U>}@
- axiom CopyPreservation(T& x, U y) {
+auto concept CopyAssignable<typename T> : MoveAssignable<T> {
+ axiom CopyPreservation(T& x, T y) {
(x = y, x) == y;
}
}
@@ -801,7 +809,7 @@
requirement for most of the uses of \tcode{CopyAssignable}, so we have
weakened \tcode{CopyAssignable} to not require anything of its return
type. When we need a \tcode{T\&}, we'll add that as an explicit
- requirement. See, e.g., the \tcode{Integral} concept.}}
+ requirement. See, e.g., the \tcode{IntegralLike} concept.}}
\begin{itemdecl}
concept TriviallyCopyAssignable<typename T> : CopyAssignable<T> { }
@@ -845,7 +853,7 @@
\rSec2[concept.memory]{Memory allocation}
\begin{itemdecl}
-auto concept HeapAllocatable<typename T> {
+auto concept FreeStoreAllocatable<typename T> {
void* T::operator new(size_t size);
void* T::operator new(size_t size, void*);
void* T::operator new[](size_t size);
@@ -857,14 +865,14 @@
\begin{itemdescr}
\pnum
\addedConcepts{\mbox{\reallynote} describes types for which objects and
-arrays of objects can be allocated on or freed from the heap with
+arrays of objects can be allocated on or freed from the free store with
\mbox{\tcode{new}} and \mbox{\tcode{delete}}.}
\end{itemdescr}
\rSec2[concept.regular]{Regular types}
\begin{itemdecl}
-auto concept Semiregular<typename T> : CopyConstructible<T>, CopyAssignable<T>, HeapAllocatable<T> {
+auto concept Semiregular<typename T> : CopyConstructible<T>, CopyAssignable<T>, FreeStoreAllocatable<T> {
requires SameType<CopyAssignable<T>::result_type, T&>;
}
\end{itemdecl}
@@ -883,8 +891,7 @@
\begin{itemdescr}
\pnum
\addedConcepts{\mbox{\reallynote} describes semi-regular types that are default
-constructible, have equality comparison operators, and can be
-allocated on the heap.}
+constructible and have equality comparison operators.}
\end{itemdescr}
\rSec2[concept.convertible]{Convertibility}
@@ -1183,6 +1190,32 @@
\end{itemdescr}
\begin{itemdecl}
+auto concept HasMoveAssign<typename T, typename U = T> {
+ typename result_type;
+ result_type T::operator=(U&&);
+}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\addedCC{\mbox{\reallynote} describes types with the ability
+ to assign to an object from an rvalue (which may have a different
+ type), potentially altering the rvalue.}
+\end{itemdescr}
+
+\begin{itemdecl}
+auto concept HasCopyAssign<typename T, typename U = T> : HasMoveAssign<T, U> {
+ result_type T::operator=(const U&);
+}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\addedCC{\mbox{\reallynote} describes types with the ability to assign to an
+object (which may have a different type).}
+\end{itemdescr}
+
+\begin{itemdecl}
auto concept HasPlusAssign<typename T, typename U = T> {
typename result_type;
result_type operator+=(T&, const U&);
@@ -1308,7 +1341,7 @@
concept ArithmeticLike<typename T>
: Regular<T>, LessThanComparable<T>, HasPlus<T>, HasMinus<T>, HasMultiply<T>, HasDivide<T>,
HasUnaryPlus<T>, HasNegate<T> {
- T::T(long long);
+ T::T(@\changedCC{long long}{intmax_t}@);
@\addedCC{T::T(long double);}@
T& operator++(T&);
@@ -1376,7 +1409,7 @@
\addedConcepts{\mbox{\requires} for every signed integral type
\mbox{\tcode{T}} ([basic.fundamental]), including signed extended
integral types, an empty concept map
- \mbox{\tcode{SignedIntegral<T>}} shall be defined in namespace
+ \mbox{\tcode{SignedIntegralLike<T>}} shall be defined in namespace
\mbox{\tcode{std}}.}
\end{itemdescr}
@@ -1393,7 +1426,7 @@
\addedConcepts{\mbox{\requires} for every unsigned integral type
\mbox{\tcode{T}} ([basic.fundamental]), including unsigned extended
integral types, an empty concept map
- \mbox{\tcode{UnsignedIntegral<T>}} shall be defined in namespace
+ \mbox{\tcode{UnsignedIntegralLike<T>}} shall be defined in namespace
\mbox{\tcode{std}}.}
\end{itemdescr}
@@ -1408,7 +1441,7 @@
\pnum
\addedConcepts{\mbox{\requires}
for every floating point type \mbox{\tcode{T}} ([basic.fundamental]),
-an empty concept map \mbox{\tcode{FloatingPoint<T>}} shall be defined
+an empty concept map \mbox{\tcode{FloatingPointLike<T>}} shall be defined
in namespace \mbox{\tcode{std}}.}
\end{itemdescr}
@@ -1467,7 +1500,7 @@
\color{addclr}
\begin{itemdecl}
-concept Allocator<typename X> : DefaultConstructible<X>, CopyConstructible<X> {
+concept Allocator<typename X> : DefaultConstructible<X>, CopyConstructible<X>, EqualityComparable<X> {
ObjectType value_type = typename X::value_type;
MutableRandomAccessIterator pointer = typename X::pointer;
RandomAccessIterator const_pointer = typename X::const_pointer;
@@ -1499,10 +1532,9 @@
template<ObjectType T>
X::X(const rebind<T>& y);
- @\removedConcepts{void X::construct(pointer p, const value_type\&);}@
- template<typename V>
- requires Convertible<V, value_type>
- @\textcolor{addclr}{void}@ X::construct(pointer p, V&&);
+ template<class... Args>
+ requires HasConstructor<value_type, Args&&...>
+ void construct(pointer p, Args&&... args);
void X::destroy(pointer p);
@@ -1643,22 +1675,16 @@
\color{addclr}
\begin{itemdecl}
-template<typename V>
- requires HasConstructor<value_type, V>
- void X::construct(pointer p, V&&);
+template<class... Args>
+ requires HasConstructor<value_type, Args&&...>
+ void X::construct(pointer p, Args&&... args);
\end{itemdecl}
\color{black}
-\editorial{The non-templated \tcode{X::construct} has been removed
-from the \tcode{Allocator} requirements because it implies that the
-\tcode{value_type} is \tcode{CopyConstructible} (which we do not want
-as a requirement in the \tcode{Allocator} concept). The templated
-version is more general, allowing in-place and move construction.}
-
\begin{itemdescr}
\pnum
\effects\
-\tcode{::new((void*)p) T(forward<V>(v))}
+\tcode{::new((void*)p) T(forward<Args>(args)...)}
\end{itemdescr}
\color{addclr}
@@ -1755,4 +1781,8 @@
semantics of containers and algorithms when allocator instances compare
non-equal, are implementation-defined.
+\section*{Acknowledgments}
+Daniel Kr\"ugler made many valuable suggestions that helper improve
+this document.
+
\end{document}
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk