std::swap(std::queue)

template< class T, class Container > void swap( queue<T,Container>& lhs, queue<T,Container>& rhs ); Specializes the std::swap algorithm for std::queue. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Same as swapping the underlying container. Exceptions noexcept specification: noexcept(noexcept(lhs.swap(rhs))) (since C++17) See

std::swap(std::promise)

Defined in header <future> template< class R > void swap( promise<R> &lhs, promise<R> &rhs ); (since C++11) Specializes the std::swap algorithm for std::promise. Exchanges the shared state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - promises whose states to swap Return value (none). Exceptions noexcept specification: noexcept Example See also swap swaps two promise objects (public mem

std::swap(std::shared_ptr)

template< class T > void swap( shared_ptr<T>& lhs, shared_ptr<T>& rhs ); (since C++11) Specializes the std::swap algorithm for std::shared_ptr. Swaps the pointers of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - smart pointers whose contents to swap Return value (none). Exceptions noexcept specification: noexcept Complexity Constant. See also swap swaps the values of two objects (function template) swap swaps the cont

std::swap(std::shared_lock)

template< class Mutex > void swap( shared_lock<Mutex>& lhs, shared_lock<Mutex>& rhs ); (since C++14) Specializes the std::swap algorithm for std::shared_lock. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - lock wrappers whose states to swap Return value (none). Exceptions noexcept specification: noexcept Example See also swap swaps the data members with another shared_

std::swap(std::set)

template< class Key, class Compare, class Alloc > void swap( set<Key,Compare,Alloc>& lhs, set<Key,Compare,Alloc>& rhs ); Specializes the std::swap algorithm for std::set. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Constant. Exceptions noexcept specification: noexcept(noexcept(lhs.swap(rhs))) (since C++17) See also swap

std::swap(std::multiset)

template< class Key, class Compare, class Alloc > void swap( multiset<Key,Compare,Alloc>& lhs, multiset<Key,Compare,Alloc>& rhs ); Specializes the std::swap algorithm for std::multiset. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Constant. Exceptions noexcept specification: noexcept(noexcept(lhs.swap(rhs))) (since C++17) See

std::swap(std::pair)

Defined in header <utility> template< class T1, class T2 > void swap( pair<T1,T2>& lhs, pair<T1,T2>& rhs ); (since C++11) Swaps the contents of lhs and rhs. Equivalent to lhs.swap(rhs). Parameters lhs, rhs - pairs whose contents to swap Return value (none). Exceptions noexcept specification: noexcept(noexcept(lhs.swap(rhs))) See also swap swaps the values of two objects (function template)

std::swap(std::packaged_task)

template< class Function, class... Args > void swap( packaged_task<Function(Args...)> &lhs, packaged_task<Function(Args...)> &rhs ); (since C++11) Specializes the std::swap algorithm for std::packaged_task. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - packaged tasks whose states to swap Return value (none). Exceptions noexcept specification: noexcept Example See also s

std::swap(std::multimap)

template< class Key, class T, class Compare, class Alloc > void swap( multimap<Key,T,Compare,Alloc>& lhs, multimap<Key,T,Compare,Alloc>& rhs ); Specializes the std::swap algorithm for std::multimap. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Constant. Exceptions noexcept specification: noexcept(noexcept(lhs.swap(rhs))) (since C

std::swap(std::priority_queue)

template< class T, class Container, class Compare > void swap( priority_queue<T,Container,Compare>& lhs, priority_queue<T,Container,Compare>& rhs ); Specializes the std::swap algorithm for std::priority_queue. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Same as swapping the underlying container. Exceptions noexcept specification: