template<class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); (1) (since C++11) template<class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); (2) (since C++11) template<class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)

Defined in header <regex> std::regex_constants::error_type code() const; (since C++11) Returns the std::regex_constants::error_type that was passed to the std::regex_error constructor. See Also error_type (C++11) describes different types of matching errors (typedef) (constructor) constructs a regex_error object (public member function)

Defined in header <algorithm> template< class InputIt1, class InputIt2, class OutputIt > OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first ); (1) template< class InputIt1, class InputIt2, class OutputIt, class Compare > OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,

string_type str( size_type n = 0 ) const; (since C++11) Returns a string representing the indicated sub-match. If n == 0, a string representing entire matched expression is returned. If n > 0 && n < size(), a string representing nth sub-match is returned. if n >= size(), a string representing the unmatched match is returned. The call is equivalent to string_type((*this)[n]); Parameters n - integral number specifying which match to return Return value Retur

Defined in header <type_traits> template< std::size_t Len, class... Types > struct aligned_union; (since C++11) Provides the member typedef type, which is a POD type of a size and alignment suitable for use as uninitialized storage for an object of any of the types listed in Types. The size of the storage is at least Len. std::aligned_union also determines the strictest (largest) alignment requirement among all Types and makes it available as the constant alignment_va

void swap( map& other ); Exchanges the contents of the container with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. The Pred objects must be Swappable, and they are exchanged using unqualified call to non-member swap. If std::allocator_traits<allocator_type>::propagate_on_container_swap::value is true, then the allocators are exchanged using an unq

Defined in header <locale> explicit money_get( std::size_t refs = 0 ); Creates a std::money_get facet and forwards the starting reference count refs to the base class constructor, locale::facet::facet(). Parameters refs - starting reference count

param_type param() const; (1) (since C++11) void param( const param_type& params ); (2) (since C++11) Manages the associated distribution parameter set. 1) Returns the associated parameter set. 2) Sets the associated parameter set to params. Parameters params - new contents of the associated parameter set Return value 1) The associated parameter set. 2) (none). Complexity Constant.

A BidirectionalIterator is a ForwardIterator that can be moved in both directions (i.e. incremented and decremented). Requirements The type It satisfies BidirectionalIterator if. The type It satisfies ForwardIterator And, given. a and b, iterators of type It reference, the type denoted by std::iterator_traits<It>::reference The following expressions must be valid and have their specified effects. Expression Return Equivalent expression Notes --a It& Preconditions: a is

Defined in header <algorithm> template< class RandomIt > RandomIt is_heap_until( RandomIt first, RandomIt last ); (1) (since C++11) template< class RandomIt, class Compare > RandomIt is_heap_until( RandomIt first, RandomIt last, Compare comp ); (2) (since C++11) Examines the range [first, last) and finds the largest range beginning at first which is a max heap. The first version of the function uses operator< to compare the elements, the second uses the