Fixing a Safety Problem with Rvalue References: Proposed Wording (Revision 1)

Authors: Douglas Gregor, David Abrahams
Contact: doug.gregor@gmail.com, dave@boostpro.com
Organization: Apple, BoostPro Computing
Date: 2009-03-05
Number: N2844=09-0034
Revises: N2831=09-0021

Introduction
Changes from N2831
The Problem
Proposed Changes
Implementation Experience
Proposed Wording

Introduction

N2812=08-0322 describes a safety problem with rvalue references that can cause unintentional modification of lvalues. The problem is summarized below; however, please read N2812 for a comprehensive discussion of the motivation behind this change. This paper provides proposed wording that fixes the safety problem in both the language and in the library.

Changes from N2831

In [expr.static.cast], clarified that it is lvalues that can be cast to an rvalue reference type (rvalues are handled by the paragraph following the inserted paragraph, using the rules in [dcl.init.ref]). State that the result of the expression is an rvalue.
In [dcl.init.ref], explicitly state that an rvalue reference can only bind to an rvalue. Do not allow the creation of a temporary from an lvalue to bind to an rvalue reference. This changes the following code:
```
  int i = 2;
  double &&d = i; // previously well-formed (d bound to a temporary double), now ill-formed
  
```
Modified [except.handle] disallow exception-declarations that denote rvalue reference types. (Addresses UK 131)

The Problem

Rvalue references violate a principle which we refer to as the Principle of Type-Safe Overloading, which we express as:

Principle of Type-safe Overloading

Every function must be type-safe in isolation, without regard to how it has been overloaded.

Specifically, in the common use of rvalue references to provide overloads for both copy and move semantics, rvalue references rely on overloading behavior to provide type safety. For example, consider std::list's push_back operation:

template<typename T>
class list {
public:
   void push_back(const value_type& x); // #1
   void push_back(value_type&& x); // #2
};

Now, when we call push_back with an lvalue of a type that is movable but not copyable (here, std::unique_ptr), we see the use of overloading to ensure type-safety. For example:

void do_push_back(std::list<std::unique_ptr<int>> &l, std::unique_ptr<int> x) {
  l.push_back(x); // error: selects #1, which fails to instantiate
}

Here, overload resolution must select between the two overloads. Overload #1 is viable, since the lvalue reference to const can bind to an lvalue. Overload #2 is also viable, since an rvalue reference can bind to an lvalue. Overload resolution then selects #1 (the copying version of push_back). Later, the instantiation of #1 will fail, because std::unique_ptrs are non-copyable types.

The end result of this process is as desired: the do_push_back operation attempted to pass an lvalue to an operation (push_back) that (conceptually) does not modify its input argument, but since the argument type does not support copying, we receive an error from the compiler. To avoid the error, we would need to explicitly say that the argument should be treated as an rvalue or provide a temporary.

Despite the desirable result, the mechanism used to ensure that we receive a compilation error in this example is brittle. In particular, if for some reason overload #1 is not viable, then call l.push_back(x) will resolve to #2, and silently steal resources from an lvalue. How could overload #1 become non-viable? One possibility is the use of concepts:

   requires CopyConstructible<value_type> void push_back(const value_type& x); // #1
   requires MoveConstructible<value_type> void push_back(value_type&& x); // #2

Here, the fact that value_type is not CopyConstructible means that overload #1 is automatically non-viable (in fact, it doesn't even exist in the class template specialization std::list<std::unique_ptr<int>>), Therefore, with concepts, the call l.push_back(x) type-checks and selects #2, silently moving from lvalues.

The fundamental problem in this example is that overload #2 is violating the principle of type-safe overloading, because overload #2 in isolation is not safe: it silently steals resources from lvalues. The attempted fix for the problem, where we add additional overloads, will fail any time that those overloads can become non-viable in the overload sets. Simple uses of concepts expose this problem with rvalue references, but they aren't the only triggers: the issue can crop up due to any kind of template argument deduction failure.

This proposal eliminates the binding of rvalue references to lvalues, so that rvalue references adhere to the principle of type-safe overloading. For additional motivation and a discussion of alternatives that have been proposed, please refer to N2812=08-0322.

Proposed Changes

The language itself required relatively few changes, specifically:

Rvalue references can no longer bind to lvalues.
One can explicitly static_cast an lvalue to an rvalue without creating a temporary.

The library changes are more extensive. However, most of the changes are specification changes that provide the same user-visible behavior while adhering to the new semantics of rvalue references. To achieve this goal, we:

Modified the signatures and implementations of std::forward and std::move to provide the same user interface under the new reference-binding rules.
Added the concepts LvalueReference and RvalueReference; the former is required for std::forward, the latter for consistency.
Reverted the rvalue-reference changes to swap functions throughout the library, removing rvalue-reference overloads and using lvalue references for the arguments to swap. This addresses library issue 884 and follows the guidance of an informal vote of the LWG to remove these functions.
Added missing Swappable requirements to tuple's swap.
Added an additional operator* associated function to the Iterator and HasDereference concepts to permit dereferencing lvalue iterators.
Changed the input and output streaming operators back to their C++03 versions by using lvalue references for the stream argument rather than rvalue references.
Added new operator<< and operator>> overloads that accept an rvalue stream and forward that stream (as an lvalue) to the appropriate operator, so that the C++0x library still supports the use of rvalue streams throughout.
Split the two getline functions into four functions to support both lvalue and rvalue streams.

Implementation Experience

We have produced an implementation of the proposed solution in the GNU C++ compiler, which is available as a patch against GCC 4.3.2. The actual implementation of the language change is trivial---we merely check whether the binding computed would bind an lvalue to an rvalue reference, and reject the binding in this case. The changes to the standard library are slightly more involved due to the large number of changes. We do not anticipate that this change will have any significant impact on compilers or standard library implementations. The GCC implementation required a day's effort to update both the language and the library, although more effort would certainly be required to update the test cases associated with this feature.

Proposed Wording

5.2.9 Static cast [expr.static.cast]

Add the following new paragraph after paragraph 2

An lvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1" (8.5.3). The result is an rvalue of type "cv2 T2" that refers to the object or the specified base class subobject thereof. If T2 is a base class of T1, a program that necessitates such a cast is ill-formed if T2 is an inaccessible (Clause 11) or ambiguous (10.2) base class of T1.

8.5.3 References [dcl.init.ref]

Modify paragraph 5 as follows:

A reference to type "cv1 T1" is initialized by an expression of type "cv2 T2" as follows:
- If the reference is an lvalue reference and the initializer expression
  - is an lvalue (but is not a bit-field), and "cv1 T1" is reference-compatible with "cv2 T2," or
  - has a class type (i.e., T2 is a class type) and can be implicitly converted to an lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible with "cv3 T3" (this conversion is selected by enumerating the applicable conversion functions (13.3.1.6) and choosing the best one through overload resolution (13.3)), then the reference is bound directly to the initializer expression lvalue in the first case, and the reference is bound to the lvalue result of the conversion in the second case. In these cases the reference is said to bind directly to the initializer expression. [ Note: the usual lvalue-to-rvalue (4.1), array-to-pointer (4.2), and function-to-pointer (4.3) standard conversions are not needed, and therefore are suppressed, when such direct bindings to lvalues are done. -- end note ] [ Example:
```
double d = 2.0; 
double& rd = d; // rd refers to d 
const double& rcd = d; // rcd refers to d 
struct A { }; 
struct B : A { } b; 
A& ra = b; // ra refers to A subobject in b 
const A& rca = b; // rca refers to A subobject in b 
```
    -- end example ]
- Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i.e., cv1 shall be const), or the reference shall be an rvalue reference and the initializer expression shall be an rvalue. [ Example:
```
double& rd2 = 2.0; // error: not an lvalue and reference not const 
int i = 2; 
double& rd3 = i; // error: type mismatch and reference not const 
double&& rd4 = i; // OK: reference bound to temporary doubleerror: rvalue reference cannot bind to lvalue 
```
  -- end example ]
  - If the initializer expression is an rvalue, with T2 a class type, and "cv1 T1" is reference-compatible with "cv2 T2," the reference is bound to the object represented by the rvalue (see 3.10) or to a sub-object within that object. [ Example:
```
struct A { }; 
struct B : A { } b; 
extern B f(); 
const A& rca = f(); // Bound to the A subobject of the B rvalue. 
A&& rcb = f(); // Same as above 
```
    -- end example ]
  - If the initializer expression is an rvalue, with T2 an array type, and "cv1 T1" is reference-compatible with "cv2 T2," the reference is bound to the object represented by the rvalue (see 3.10).
  - Otherwise, a temporary of type "cv1 T1" is created and initialized from the initializer expression using the rules for a non-reference copy initialization (8.5). The reference is then bound to the temporary. If T1 is reference-related to T2, cv1 must be the same cv-qualification as, or greater cv-qualification than, cv2 ; otherwise, the program is ill-formed. [ Example:
```
const double& rcd2 = 2; // rcd2 refers to temporary with value 2.0 
double&& rcd3 = 2; // rcd3 refers to temporary with value 2.0 
const volatile int cvi = 1; 
const int& r = cvi; // error: type qualifiers dropped 
```
    -- end example ]

13.3.3.2 Ranking implicit conversion sequences [over.ics.rank]

Modify paragraph 3 as follows

Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies:
- Standard conversion sequence S1 is a better conversion sequence than standard conversion sequence S2 if
  - S1 is a proper subsequence of S2 (comparing the conversion sequences in the canonical form defined by 13.3.3.1.1, excluding any Lvalue Transformation; the identity conversion sequence is considered to be a subsequence of any non-identity conversion sequence) or, if not that,
  - the rank of S1 is better than the rank of S2, or S1 and S2 have the same rank and are distinguishable by the rules in the paragraph below, or, if not that,
  - S1 and S2 differ only in their qualification conversion and yield similar types T1 and T2 (4.4), respectively, and the cv-qualification signature of type T1 is a proper subset of the cv-qualification signature of type T2, and S1 is not the deprecated string literal array-to-pointer conversion (4.2). [ Example:
```
int f(const int *); 
int f(int *); 
int i; 
int j = f(&i); // calls f(int*) 
```
    -- end example ] or, if not that,
  - S1 and S2 are reference bindings (8.5.3) and neither refers to an implicit object parameter of a non-static member function declared without a ref-qualifier , and ~~either S1 binds an lvalue reference to an lvalue and S2 binds an rvalue reference or~~ S1 binds an rvalue reference to an rvalue and S2 binds an lvalue reference. [ Example:
```
int i; 
int f(); 
int g(const int&); 
int g(const int&&); 
int j = g(i); // calls g(const int&) 
int k = g(f()); // calls g(const int&&)

struct A { 
  A& operator<<(int); 
  void p() &; 
  void p() &&; 
}; 
A& operator<<(A&&, char); 
A() << 1; // calls A::operator<<(int) 
A() << 'c'; // calls operator<<(A&&, char) 
A a; 
a << 1; // calls A::operator<<(int) 
a << 'c'; // calls operator<<(A&&, char)A::operator<<(int)
A().p(); // calls A::p()&& 
a.p(); // calls A::p()& 
```
    -- end example ] or, if not that,
  - ...

15.3 Handling an exception [except.handle]

Modify paragraph 1 as follows:

The exception-declaration in a handler describes the type(s) of exceptions that can cause that handler to be entered. The exception-declaration shall not denote an incomplete type or an rvalue reference type. The exception-declaration shall not denote a pointer or reference to an incomplete type, other than void*, const void*, volatile void*, or const volatile void*.

20.1.1 Type transformations [concept.transform]

Modify the RvalueOf concept as follows:

auto concept RvalueOf<typename T> { 
  typename type = T&&; 
  requires ExplicitlyConvertible<T&, type> && Convertible<T&&, type>; 
}

Add the following new section

20.1.2 Type classifications [concept.classify]

The concepts in 20.1.2 provide simple type classifications that can be used within constrained templates.
A program shall not provide concept maps for any concept in 20.1.2

  concept LvalueReference<typename T> { }
  template<typename T> concept_map LvalueReference<T&> { }

Note: determines whether a given type is an lvalue reference type.

  concept RvalueReference<typename T> { }
  template<typename T> concept_map RvalueReference<T&&> { }

Note: determines whether a given type is an rvalue reference type.

20.1.3 Operator concepts [concept.operator]

Modify the HasDereference concept as follows:

auto concept HasDereference<typename T> { 
  typename result_type; 
  result_type operator*(T&);
  result_type operator*(T&&); 
}

Modify the HasSubscript concept as follows:

auto concept HasSubscript<typename T, typename U> { 
  typename result_type; 
  result_type operator[](T&, const U&);
  result_type operator[](T&&, const U&); 
}

Modify the Callable concept as follows:

auto concept Callable<typename F, typename... Args> { 
  typename result_type; 
  result_type operator()(F&, Args...);
  result_type operator()(F&&, Args...); 
}

20.2.2 forward/move helpers [forward]

Change the definitions of forward and move as follows:

  template <IdentityOf T> requires !LvalueReference<T>
    T&& forward(IdentityOf<T>::type& t); 
  template <IdentityOf T> requires LvalueReference<T>
    T&  forward(IdentityOf<T>::type& t);

[ Note: The use of IdentityOf in forward forces users to explicitly specify the template parameter. This is necessary to get the correct forwarding semantics. -- end note ]
Returns: static_cast<T&&>(t) or t, respectively.

  template <RvalueOf T> RvalueOf<T>::type move(T&& t);

Returns: static_cast<RvalueOf<T>::type>(t)

20.2.3 Pairs [pairs]

Update the declaration of pair's swap as follows:

  requires Swappable<T1> && Swappable<T2> void swap(pair&& p);

Effects: Swaps first with p.first and second with p.second.

  template<class T1, class T2> 
    requires Swappable<T1> && Swappable<T2> 
    void swap(pair<T1, T2>& x, pair<T1, T2>& y); 
  template<class T1, class T2>
    requires Swappable<T1> && Swappable<T2>
    void swap(pair<T1, T2>&& x, pair<T1, T2>& y);
  template<class T1, class T2>
    requires Swappable<T1> && Swappable<T2>
    void swap(pair<T1, T2>& x, pair<T1, T2>&& y);

Effects: x.swap(y)

20.4.2.6 Tuple swap [tuple.swap]

Change the declaration of tuple's swap as follows:

  requires Swappable<Types>... void swap(tuple&& rhs);

Requires: each type in Types shall be Swappable.

20.4.2.7 Tuple specialized algorithms [tuple.special]

Change the declaration of tuple's swap as follows:

template <class... Types>
  requires Swappable<Types>...
  void swap(tuple<Types...>& x, tuple<Types...>& y); 
template <class... Types>
  void swap(tuple<Types...>&& x, tuple<Types...>& y);
template <class... Types>
  void swap(tuple<Types...>& x, tuple<Types...>&& y);

Effects: x.swap(y)

20.6.16.2.2 function modifiers [func.wrap.func.mod]

Change the declaration of function's swap as follows:

void swap(function&& other);

Effects: interchanges the targets of *this and other.
Throws: nothing.

20.7.12.2.5 unique_ptr modifiers [unique.ptr.single.modifiers]

Change the declaration of unique_ptr's swap as follows:

  void swap(unique_ptr&& u);

Requires: The deleter D shall be Swappable and shall not throw an exception under swap.
Effects: The stored pointers of this and u are exchanged. The stored deleters are swap'd (un-qualified).
Throws: nothing.

20.7.12.4 unique_ptr specialized algorithms [unique.ptr.special]

Change the declaration of unique_ptr's swap as follows:

template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y); 
template <class T, class D> void swap(unique_ptr<T, D>&& x, unique_ptr<T, D>& y); 
template <class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y);

Effects: Calls x.swap(y).

20.7.13.2.4 shared_ptr modifiers [util.smartptr.shared.mod]

Change the declaration of shared_ptr's swap as follows:

void swap(shared_ptr&& r);

Effects: Exchanges the contents of *this and r.
Throws: nothing.

20.7.13.2.9 shared_ptr specialized algorithms [util.smartptr.shared.spec]

Change the declaration of shared_ptr's swap as follows:

template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b); 
template<class T> void swap(shared_ptr<T>&& a, shared_ptr<T>& b);
template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>&& b);

Effects: Equivalent to a.swap(b).
Throws: nothing.

21.3.6.8 basic_string::swap [string::swap]

Change the declaration of basic_string's swap as follows:

void swap(basic_string<charT,traits,Allocator>&& s);

Throws: Nothing.
Postcondition: *this contains the same sequence of characters that was in s, s contains the same sequence of characters that was in *this.
Complexity: constant time.

21.3.8.8 swap [string.special]

Change the declaration of basic_string's swap as follows:

template<class charT, class traits, class Allocator> 
  void swap(basic_string<charT,traits,Allocator>& lhs, 
            basic_string<charT,traits,Allocator>& rhs); 
template<class charT, class traits, class Allocator>
  void swap(basic_string<charT,traits,Allocator>&& lhs,
            basic_string<charT,traits,Allocator>& rhs);
template<class charT, class traits, class Allocator>
  void swap(basic_string<charT,traits,Allocator>& lhs,
            basic_string<charT,traits,Allocator>&& rhs);

Effects: lhs.swap(rhs);

21.3.8.9 Inserters and extractors [string.io]

Change the declaration of basic_string's operator>> as follows:

template<class charT, class traits, class Allocator> 
  basic_istream<charT,traits>& 
   operator>>(basic_istream<charT,traits>&& is, 
              basic_string<charT,traits,Allocator>& str);

Change the declaration of basic_string's operator<< as follows:

template<class charT, class traits, class Allocator> 
  basic_ostream<charT, traits>& 
    operator<<(basic_ostream<charT, traits>&& os, 
               const basic_string<charT,traits,Allocator>& str);

Add a second declaration of basic_string's getline prior to paragraph 7 as follows:

template<class charT, class traits, class Allocator>
  basic_istream<charT,traits>&
    getline(basic_istream<charT,traits>& is,
            basic_string<charT,traits,Allocator>& str,
            charT delim);
template<class charT, class traits, class Allocator> 
  basic_istream<charT,traits>& 
    getline(basic_istream<charT,traits>&& is, 
            basic_string<charT,traits,Allocator>& str, 
            charT delim);

Add a second declaration of basic_string's getline prior to paragraph 11 as follows:

template<class charT, class traits, class Allocator>
  basic_istream<charT,traits>&
    getline(basic_istream<charT,traits>& is,
            basic_string<charT,traits,Allocator>& str);
template<class charT, class traits, class Allocator> 
  basic_istream<charT,traits>& 
    getline(basic_istream<charT,traits>&& is, 
            basic_string<charT,traits,Allocator>& str);

23.2.2 Class template deque [deque]

Change the declaration of deque's swap as follows:

void swap(deque<T,Alloc>&&);

23.2.2.4 deque specialized algorithms [deque.special]

Change the declaration of deque's swap as follows:

template <ValueType T, class Alloc> 
  void swap(deque<T,Alloc>& x, deque<T,Alloc>& y); 
template <ValueType T, class Alloc>
  void swap(deque<T,Alloc>&& x, deque<T,Alloc>& y);
template <ValueType T, class Alloc>
  void swap(deque<T,Alloc>& x, deque<T,Alloc>&& y);

Effects: x.swap(y);

23.2.3 Class template forward_list [forwardlist]

Change the declaration of forward_list's swap as follows:

void swap(forward_list<T,Alloc>&&);

23.2.3.6 forward_list specialized algorithms [forwardlist.spec]

Change the declaration of forward_list's swap as follows:

template <ValueType T, class Alloc> 
  void swap(forward_list<T,Alloc>& x, forward_list<T,Alloc>& y); 
template <ValueType T, class Alloc>
  void swap(forward_list<T,Alloc>&& x, forward_list<T,Alloc>& y);
template <ValueType T, class Alloc>
  void swap(forward_list<T,Alloc>& x, forward_list<T,Alloc>&& y);

Effects: x.swap(y)

23.2.4 Class template list [list]

Change the declaration of list's swap as follows:

  void swap(list<T,Alloc>&&);

23.2.4.5 list specialized algorithms [list.special]

Change the declaration of list's swap as follows:

template <ValueType T, class Alloc> 
  void swap(list<T,Alloc>& x, list<T,Alloc>& y);
template <ValueType T, class Alloc>
  void swap(list<T,Alloc>&& x, list<T,Alloc>& y);
template <ValueType T, class Alloc>
  void swap(list<T,Alloc>& x, list<T,Alloc>&& y);

Effects: x.swap(y);

23.2.5.1.1 queue definition [queue.defn]

Change the definition of queue's swap as follows:

  void swap(queue&& q) { swap(c, q.c); }

23.2.5.1.3 queue specialized algorithms [queue.special]

Change the declaration of queue's swap as follows:

template <ObjectType T, Swappable Cont> 
  void swap(queue<T, Cont>& x, queue<T, Cont>& y); 
template <ObjectType T, Swappable Cont>
  void swap(queue<T, Cont>&& x, queue<T, Cont>& y);
template <ObjectType T, Swappable Cont> 
  void swap(queue<T, Cont>& x, queue<T, Cont>&& y);

Effects: x.swap(y).

23.2.5.2 Class template priority_queue [priority.queue]

Change the declaration of priority_queue's swap as follows:

requires Swappable<Cont>
  void swap(priority_queue&&);

23.2.5.2.3 priority_queue specialized algorithms [priqueue.special]

Change the declaration of priority_queue's swap as follows:

template <class T, Swappable Cont, Swappable Compare> 
  void swap(priority_queue<T, Cont, Compare>& x, priority_queue<T, Cont, Compare>& y); 
template <class T, Swappable Cont, Swappable Compare>
  void swap(priority_queue<T, Cont, Compare>&& x, priority_queue<T, Cont, Compare>& y);
template <class T, Swappable Cont, Swappable Compare>
  void swap(priority_queue<T, Cont, Compare>& x, priority_queue<T, Cont, Compare>&& y);

Effects: x.swap(y).

23.2.5.3.1 stack definition [stack.defn]

Change the definition of stack's swap as follows:

requires Swappable<Cont>
  void swap(stack&& s) { swap(c, s.c); }

23.2.5.3.3 stack specialized algorithms [stack.special]

template <ObjectType T, Swappable Cont> 
  void swap(stack<T, Cont>& x, stack<T, Cont>& y); 
template <ObjectType T, Swappable Cont>
  void swap(stack<T, Cont>&& x, stack<T, Cont>& y); 
template <ObjectType T, Swappable Cont> 
  void swap(stack<T, Cont>& x, stack<T, Cont>&& y);

Effects: x.swap(y).

23.2.6 Class template vector [vector]

Change the declaration of vector's swap as follows:

  void swap(vector<T,Alloc>&&);

23.2.6.2 vector capacity [vector.capacity]

Modify the declaration of vector's swap prior to paragraph 8 as follows:

  void swap(vector<T,Alloc>&&);

23.2.6.5 vector specialized algorithms [vector.special]

Change the declaration of vector's swap as follows:

template <ValueType T, class Alloc> 
  void swap(vector<T,Alloc>& x, vector<T,Alloc>& y); 
template <ValueType T, class Alloc>
  void swap(vector<T,Alloc>&& x, vector<T,Alloc>& y); 
template <ValueType T, class Alloc>
  void swap(vector<T,Alloc>& x, vector<T,Alloc>&& y);

Effects: x.swap(y);

23.2.7 Class vector<bool> [vector.bool]

Change the declaration of vector<bool>'s swap as follows:

void swap(vector<bool,Alloc>&&);

23.3.1 Class template map [map]

Change the declaration of map's swap as follows:

void swap(map<Key,T,Compare,Alloc>&&);

23.3.1.5 map specialized algorithms [map.special]

Remove map's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(map<Key,T,Compare,Alloc>& x, 
            map<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc>
  void swap(map<Key,T,Compare,Alloc>&& x,
            map<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(map<Key,T,Compare,Alloc>& x,
            map<Key,T,Compare,Alloc>&& y);

23.3.2 Class template multimap [multimap]

Change the declaration of multimap's swap as follows:

void swap(multimap<Key,T,Compare,Alloc>&&);

23.3.2.4 multimap specialized algorithms [multimap.special]

Remove multimap's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(multimap<Key,T,Compare,Alloc>& x, 
            multimap<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc>
  void swap(multimap<Key,T,Compare,Alloc>&& x,
            multimap<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(multimap<Key,T,Compare,Alloc>& x,
            multimap<Key,T,Compare,Alloc>&& y);

23.3.3 Class template set [set]

Change the declaration of set's swap as follows:

void swap(set<Key,T,Compare,Alloc>&&);

23.3.3.2 set specialized algorithms [set.special]

Remove set's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(set<Key,T,Compare,Alloc>& x, 
            set<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc>
  void swap(set<Key,T,Compare,Alloc>&& x,
            set<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(set<Key,T,Compare,Alloc>& x,
            set<Key,T,Compare,Alloc>&& y);

23.3.4 Class template multiset [multiset]

Change the declaration of multiset's swap as follows:

void swap(multiset<Key,T,Compare,Alloc>&&);

23.3.4.2 multiset specialized algorithms [multiset.special]

Remove multiset's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(multiset<Key,T,Compare,Alloc>& x, 
            multiset<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc>
  void swap(multiset<Key,T,Compare,Alloc>&& x,
            multiset<Key,T,Compare,Alloc>& y); 
template <ValueType Key, ValueType T, class Compare, class Alloc> 
  void swap(multiset<Key,T,Compare,Alloc>& x,
            multiset<Key,T,Compare,Alloc>&& y);

23.4.1 Class template unordered_map [unord.map]

Change the declaration of unordered_map's swap as follows:

  void swap(unordered_map&&);

23.4.1.3 unordered_map swap [unord.map.swap]

Remove unordered_map's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
            unordered_map<Key, T, Hash, Pred, Alloc>& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc>
  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
            unordered_map<Key, T, Hash, Pred, Alloc>&& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x, 
            unordered_map<Key, T, Hash, Pred, Alloc>& y);

23.4.2 Class template unordered_multimap [unord.multimap]

Change the declaration of unordered_multimap's swap as follows:

  void swap(unordered_multimap&&);

23.4.2.2 unordered_multimap swap [unord.multimap.swap]

Remove unordered_multimap's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
            unordered_multimap<Key, T, Hash, Pred, Alloc>& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc>
  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
            unordered_multimap<Key, T, Hash, Pred, Alloc>&& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x, 
            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

23.4.3 Class template unordered_set [unord.set]

Change the declaration of unordered_set's swap as follows:

  void swap(unordered_set&&);

23.4.3.2 unordered_set swap [unord.set.swap]

Remove unordered_set's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x, 
            unordered_set<Key, T, Hash, Pred, Alloc>& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc>
  void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x, 
            unordered_set<Key, T, Hash, Pred, Alloc>&& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_set<Key, T, Hash, Pred, Alloc>&& x, 
            unordered_set<Key, T, Hash, Pred, Alloc>& y);

23.4.4 Class template unordered_multiset [unord.multiset]

Change the declaration of unordered_multiset's swap as follows:

  void swap(unordered_multiset&&);

23.4.4.2 unordered_multiset swap [unord.multiset.swap]

Remove unordered_multiset's swap algorithms that operate on rvalue references:

template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x, 
            unordered_multiset<Key, T, Hash, Pred, Alloc>& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc>
  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x, 
            unordered_multiset<Key, T, Hash, Pred, Alloc>&& y); 
template <ValueType Key, ValueType T, class Hash, class Pred, class Alloc> 
  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>&& x, 
            unordered_multiset<Key, T, Hash, Pred, Alloc>& y);

24.1.1 Iterator [iterator.iterators]

Change the iterator concept as follows:

concept Iterator<typename X> : Semiregular<X> { 
  MoveConstructible reference = typename X::reference; 
  MoveConstructible postincrement_result; 
  requires HasDereference<postincrement_result>; 
  reference operator*(X&);
  reference operator*(X&&); 
  X& operator++(X&); 
  postincrement_result operator++(X&, int); 
}

24.4.3.2.4 move_iterator::operator* [move.iter.op.star]

reference operator*() const;

Returns: std::move(*current)~~, implicitly converted to an rvalue reference~~.

24.4.3.2.12 move_iterator::operator[] [move.iter.op.index]

requires RandomAccessIterator 
  unspecified operator[](difference_type n) const;

Returns: std::move(current[n])~~, implicitly converted to an rvalue reference~~.

26.5.2 Class template valarray [template.valarray]

Change the declaration of valarray's swap as follows:

  void swap(valarray&&);

26.5.2.7 valarray member functions [valarray.members]

Change the declaration of valarray's swap as follows:

  void swap(valarray&&);

26.5.3.4 valarray specialized algorithms [valarray.special]

Remove valarray's swap specialized algorithms that use rvalue references as follows:

template <class T> void swap(valarray<T>& x, valarray<T>& y); 
template <class T> void swap(valarray<T>&& x, valarray<T>& y);
template <class T> void swap(valarray<T>& x, valarray<T>&& y);

27.4.4 Class template basic_ios [ios]

Change the declaration of basic_ios's swap as follows:

  void swap(basic_ios&& rhs);

27.4.4.2 Member functions [basic.ios.members]

Modify the declaration of basic_ios's swap prior to paragraph 21 as follows:

  void swap(basic_ios&& rhs);

27.5.2 Class template basic_streambuf [streambuf]

Change the declaration of basic_streambuf's swap as follows:

  void swap(basic_streambuf&& rhs);

27.5.2.3.1 Assignment [streambuf.assign]

Change the declaration of basic_streambuf's swap before paragraph 4 as follows:

  void swap(basic_streambuf&& rhs);

27.6 Formatting and manipulators [iostream.format]

Modify the header <istream> synopsis as follows:

namespace std {
  template <class charT, class traits = char_traits<charT> >
    class basic_istream; 

  typedef basic_istream<char> istream; 
  typedef basic_istream<wchar_t> wistream; 
  template <class charT, class traits = char_traits<charT> > 
    class basic_iostream; 
  typedef basic_iostream<char> iostream; 
  typedef basic_iostream<wchar_t> wiostream;

  template <class charT, class traits> 
    basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);

  template<typename charT, typename traits, typename T>
    basic_istream<charT, traits>&
    operator>>(basic_istream<charT, traits>&& is, T& x);
}

Modify the header <ostream> synopsis as follows:

namespace std { 
  template <class charT, class traits = char_traits<charT> > 
    class basic_ostream; 
  typedef basic_ostream<char> ostream; 
  typedef basic_ostream<wchar_t> wostream;

  template <class charT, class traits> 
    basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os); 
  template <class charT, class traits> 
    basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os); 
  template <class charT, class traits> 
    basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os); 

  template<typename charT, typename traits, typename T>
    basic_ostream<charT, traits>&
    operator<<(basic_ostream<charT, traits>&& os, const T& x);
}

27.6.1 Input streams [input.streams]

The header <istream> defines two types and a function signature that control input from a stream buffer along with a function template that performs extraction from stream rvalues.

27.6.1.1 Class template basic_istream [istream]

Change the declaration of basic_istream's swap as follows:

  void swap(basic_istream&& rhs);

27.6.1.1.2 Class basic_istream assign and swap [istream.assign]

Change the declaration of basic_istream's swap as follows:

  void swap(basic_istream&& rhs);

Remove the rvalue-reference overloads of basic_istream's swap as follows:

template <class charT, class traits> 
  void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_istream<charT, traits>&& x, basic_istream<charT, traits>& y);
template <class charT, class traits>
  void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>&& y);

27.6.1.2.3 basic_istream::operator>> [istream::extractors]

Change the declarations of basic_istream's operator>> prior to paragraph 7 as follows:

template<class charT, class traits> 
  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&& in, 
                                          charT* s); 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, 
                                         unsigned char* s); 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in,
                                         signed char* s);

Change the declarations of basic_istream's operator>> prior to paragraph 12 as follows:

template<class charT, class traits> 
  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&& in, 
                                          charT& c); 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, 
                                         unsigned char& c); 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&& in, 
                                         signed char& c);

27.6.1.5 Class template basic_iostream [iostreamclass]

Change the declaration of basic_iostream's swap as follows:

  void swap(basic_iostream&& rhs);

27.6.1.5.3 basic_iostream assign and swap [iostream.assign]

Change the declaration of basic_iostream's swap prior to paragraph 2 as follows:

  void swap(basic_iostream&& rhs);

Change the declaration of basic_iostream's swap prior to paragraph 4 as follows:

template <class charT, class traits> 
  void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_iostream<charT, traits>&& x, basic_iostream<charT, traits>& y); 
template <class charT, class traits> 
  void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>&& y);

Add the following new section:

27.6.1.6 Rvalue stream extraction [istream.rvalue]

template<typename charT, typename traits, typename T>
  basic_istream<charT, traits>&
  operator>>(basic_istream<charT, traits>&& is, T& x);

Effects: is >> x
Returns: is

27.6.2 Output streams [output.streams]

The header <ostream> defines a type and several function signatures that control output to a stream buffer along with a function template that performs insertion into stream rvalues.

27.6.2.1 Class template basic_ostream [ostream]

Change the declaration of basic_ostream's swap as follows:

  void swap(basic_ostream&& rhs);

27.6.2.3 Class basic_ostream assign and swap [ostream.assign]

Change the declaration of basic_ostream's swap prior to paragraph 3 as follows:

  void swap(basic_ostream&& rhs);

Change the declaration of basic_ostream's swap prior to paragraph 4 as follows:

template <class charT, class traits> 
  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_ostream<charT, traits>&& x, basic_ostream<charT, traits>& y);
template <class charT, class traits>
  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>&& y);

27.6.2.6.4 Character inserter function templates [ostream.inserters.character]

Remove the rvalue-reference overloads of basic_ostream's inserter function templates prior to paragraph 1 as follows:

template<class charT, class traits> 
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, 
                                          charT c); 
template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&& out,
                                          charT c);
template<class charT, class traits> 
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, 
                                          char c);
template<class charT, class traits> 
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&& out,
                                          char c);
// specialization 
template<class traits> 
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out, 
                                          char c); 
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&& out,
                                          char c);
// signed and unsigned 
template<class traits> 
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out, 
                                          signed char c); 
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&& out,
                                          signed char c);
template<class traits> 
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out, 
un                                          signed char c); 
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&& out,
                                          unsigned char c);

Remove the rvalue-reference overloads of basic_ostream's inserter function templates prior to paragraph 3 as follows:

template<class charT, class traits> 
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, 
                                          const charT* s); 
template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&& out,
                                          const charT* s);
template<class charT, class traits> 
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out, 
                                          const char* s); 
template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&& out,
                                          const char* s);
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out, 
                                          const char* s); 
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&& out,
                                          const char* s);
template<class traits> 
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out, 
                                          const signed char* s); 
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&& out,
                                          const signed char* s);
template<class traits> 
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out, 
                                          const unsigned char* s); 
template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&& out,
                                          const unsigned char* s);

27.6.2.9 Rvalue stream insertion [ostream.rvalue]

template<typename charT, typename traits, typename T>
  basic_ostream<charT, traits>&
  operator<<(basic_ostream<charT, traits>&& os, const T& x);

Effects: os << x
Returns: os

27.7.1 Class template basic_stringbuf [stringbuf]

Change the declaration of basic_stringbuf's swap as follows:

  void swap(basic_stringbuf&& rhs);

27.7.1.2 Assign and swap [stringbuf.assign]

Change the declaration of basic_stringbuf's swap prior to paragraph 3 as follows:

  void swap(basic_stringbuf&& rhs);

Change the declaration of basic_stringbuf's swap prior to paragraph 4 as follows:

template <class charT, class traits, class Allocator> 
  void swap(basic_stringbuf<charT, traits, Allocator>& x, 
            basic_stringbuf<charT, traits, Allocator>& y); 
template <class charT, class traits, class Allocator>
  void swap(basic_stringbuf<charT, traits, Allocator>&& x,
            basic_stringbuf<charT, traits, Allocator>& y);
template <class charT, class traits, class Allocator>
  void swap(basic_stringbuf<charT, traits, Allocator>& x,
            basic_stringbuf<charT, traits, Allocator>&& y);

27.7.2 Class template basic_istringstream [istringstream]

Change the declaration of basic_istringstream's swap as follows:

  void swap(basic_istringstream&& rhs);

27.7.2.2 Assign and swap [istringstream.assign]

Change the declaration of basic_istringstream's swap prior to paragraph 3 as follows:

  void swap(basic_istringstream&& rhs);

Change the declaration of basic_istringstream's swap prior to paragraph 4 as follows:

template <class charT, class traits, class Allocator> 
  void swap(basic_istringstream<charT, traits, Allocator>& x, 
            basic_istringstream<charT, traits, Allocator>& y); 
template <class charT, class traits, class Allocator>
  void swap(basic_istringstream<charT, traits, Allocator>&& x,
            basic_istringstream<charT, traits, Allocator>& y);
template <class charT, class traits, class Allocator>
  void swap(basic_istringstream<charT, traits, Allocator>& x,
            basic_istringstream<charT, traits, Allocator>&& y);

27.7.3 Class template basic_ostringstream [ostringstream]

Change the declaration of basic_ostringstream's swap as follows:

  void swap(basic_ostringstream&& rhs);

27.7.3.2 Assign and swap [ostringstream.assign]

Change the declaration of basic_ostringstream's swap prior to paragraph 3 as follows:

  void swap(basic_ostringstream&& rhs);

Change the declaration of basic_ostringstream's swap prior to paragraph 4 as follows:

template <class charT, class traits, class Allocator> 
  void swap(basic_ostringstream<charT, traits, Allocator>& x, 
            basic_ostringstream<charT, traits, Allocator>& y); 
template <class charT, class traits, class Allocator>
  void swap(basic_ostringstream<charT, traits, Allocator>&& x,
            basic_ostringstream<charT, traits, Allocator>& y);
template <class charT, class traits, class Allocator>
  void swap(basic_ostringstream<charT, traits, Allocator>& x,
            basic_ostringstream<charT, traits, Allocator>&& y);

27.7.4 Class template basic_stringstream [stringstream]

Change the declaration of basic_stringstream's swap as follows:

  void swap(basic_stringstream&& rhs);

27.7.4.2 Assign and swap [stringstream.assign]

Change the declaration of basic_stringstream's swap prior to paragraph 3 as follows:

  void swap(basic_stringstream&& rhs);

Change the declaration of basic_stringstream's swap prior to paragraph 4 as follows:

template <class charT, class traits, class Allocator> 
  void swap(basic_stringstream<charT, traits, Allocator>& x, 
            basic_stringstream<charT, traits, Allocator>& y); 
template <class charT, class traits, class Allocator>
  void swap(basic_stringstream<charT, traits, Allocator>&& x,
            basic_stringstream<charT, traits, Allocator>& y);
template <class charT, class traits, class Allocator>
  void swap(basic_stringstream<charT, traits, Allocator>& x,
            basic_stringstream<charT, traits, Allocator>&& y);

27.8.1.1 Class template basic_filebuf [filebuf]

Change the declaration of basic_filebuf's swap as follows:

  void swap(basic_filebuf&& rhs);

27.8.1.3 Assign and swap [filebuf.assign]

Change the declaration of basic_filebuf's swap prior to paragraph 3 as follows:

  void swap(basic_filebuf&& rhs);

Change the declaration of basic_filebuf's swap prior to paragraph 4 as follows:

template <class charT, class traits> 
  void swap(basic_filebuf<charT, traits>& x, 
            basic_filebuf<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_filebuf<charT, traits>&& x,
            basic_filebuf<charT, traits>& y);
template <class charT, class traits>
  void swap(basic_filebuf<charT, traits>& x,
            basic_filebuf<charT, traits>&& y);

27.8.1.6 Class template basic_ifstream [ifstream]

Change the declaration of basic_ifstream's swap as follows:

  void swap(basic_ifstream&& rhs);

27.8.1.8 Assign and swap [ifstream.assign]

Change the declaration of basic_ifstream's swap prior to paragraph 3 as follows:

  void swap(basic_ifstream&& rhs);

Change the declaration of basic_ifstream's swap prior to paragraph 4 as follows:

template <class charT, class traits> 
  void swap(basic_ifstream<charT, traits>& x, 
            basic_ifstream<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_ifstream<charT, traits>&& x,
            basic_ifstream<charT, traits>& y);
template <class charT, class traits>
  void swap(basic_ifstream<charT, traits>& x,
            basic_ifstream<charT, traits>&& y);

27.8.1.10 Class template basic_ofstream [ofstream]

Change the declaration of basic_ofstream's swap as follows:

  void swap(basic_ofstream&& rhs);

27.8.1.12 Assign and swap [ofstream.assign]

Change the declaration of basic_ofstream's swap prior to paragraph 3 as follows:

  void swap(basic_ofstream&& rhs);

Change the declaration of basic_ofstream's swap prior to paragraph 4 as follows:

template <class charT, class traits> 
  void swap(basic_ofstream<charT, traits>& x, 
            basic_ofstream<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_ofstream<charT, traits>&& x,
            basic_ofstream<charT, traits>& y);
template <class charT, class traits>
  void swap(basic_ofstream<charT, traits>& x,
            basic_ofstream<charT, traits>&& y);

27.8.1.14 Class template basic_fstream [fstream]

Change the declaration of basic_fstream's swap as follows:

  void swap(basic_fstream&& rhs);

27.8.1.16 Assign and swap [fstream.assign]

Change the declaration of basic_fstream's swap prior to paragraph 3 as follows:

  void swap(basic_fstream&& rhs);

Change the declaration of basic_fstream's swap prior to paragraph 4 as follows:

template <class charT, class traits> 
  void swap(basic_fstream<charT, traits>& x, 
            basic_fstream<charT, traits>& y); 
template <class charT, class traits>
  void swap(basic_fstream<charT, traits>&& x,
            basic_fstream<charT, traits>& y);
template <class charT, class traits>
  void swap(basic_fstream<charT, traits>& x,
            basic_fstream<charT, traits>&& y);

30.2.1 Class thread [thread.thread.class]

Change the declaration of thread's swap as follows:

  void swap(thread&&);

30.2.1.1 Class thread::id [thread.thread.id]

Change the declaration of thread's operator<< prior to paragraph 18 as follows:

template<class charT, class traits> 
  basic_ostream<charT, traits>& 
  operator<< (basic_ostream<charT, traits>&& out, thread::id id);

30.2.1.5 thread members [thread.thread.member]

Change the declaration of thread's swap as follows:

  void swap(thread&&);

30.2.1.7 thread specialized algorithms [thread.thread.algorithm]

Remove the rvalue-reference overloads of thread's swap as follows:

void swap(thread& x, thread& y); 
void swap(thread&& x, thread& y);
void swap(thread& x, thread&& y);

30.3.3.2 Class template unique_lock [thread.lock.unique]

Change the declaration of unique_lock's swap as follows:

  void swap(unique_lock&& u);

30.3.3.2.3 unique_lock modifiers [thread.lock.unique.mod]

Change the declaration of unique_lock's swap as follows:

  void swap(unique_lock&& u);

Remove the rvalue-reference overloads of unique_ptr's swap as follows:

template <class Mutex> 
  void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y); 
template <class Mutex> 
  void swap(unique_lock<Mutex>&& x, unique_lock<Mutex>& y); 
template <class Mutex> 
  void swap(unique_lock<Mutex>& x, unique_lock<Mutex>&& y);

30.5.8 Class template packaged_task [futures.task]

Change the declaration of packaged_task's swap as follows:

  void swap(packaged_task&& other);

Last modified: Thu Mar 5 13:37:53 EST 2009