result_type max() const; (since C++11) Returns the maximum value potentially generated by the distribution. Parameters (none). Return value The maximum value potentially generated by the distribution. Complexity Constant. See also min returns the minimum potentially generated value (public member function)

Defined in header <mutex> struct defer_lock_t { }; (since C++11) struct try_to_lock_t { }; (since C++11) struct adopt_lock_t { }; (since C++11) std::defer_lock_t, std::try_to_lock_t and std::adopt_lock_t are empty struct tag types used to specify locking strategy for std::lock_guard, std::unique_lock and std::shared_lock. Type Effect(s) defer_lock_t do not acquire ownership of the mutex try_to_lock_t try to acquire ownership of the mutex without block

Defined in header <functional> template< class T > struct divides; (until C++14) template< class T = void > struct divides; (since C++14) Function object for performing division. Effectively calls operator/ on two instances of type T. Specializations The standard library provides a specialization of std::divides when T is not specified, which leaves the parameter types and return type to be deduced. divides<void> function object implementing

size_type count( const Key& key ) const; (1) template< class K > size_type count( const K& x ) const; (2) (since C++14) 1) Returns the number of elements with key key, which is either 1 or 0 since this container does not allow duplicates 2) Returns the number of elements with key that compares equivalent to the value x. This overload only participates in overload resolution if the qualified-id Compare::is_transparent is valid and denotes a type. They allow calling

The algorithms library defines functions for a variety of purposes (e.g. searching, sorting, counting, manipulating) that operate on ranges of elements. Note that a range is defined as [first, last) where last refers to the element past the last element to inspect or modify. Non-modifying sequence operations Defined in header <algorithm> all_ofany_ofnone_of (C++11)(C++11)(C++11) checks if a predicate is true for all, any or none of the elements in a range (function templat

Defined in header <algorithm> template< class InputIt, class Size, class OutputIt > OutputIt copy_n( InputIt first, Size count, OutputIt result ); (since C++11) Copies exactly count values from the range beginning at first to the range beginning at result, if count>0. Does nothing otherwise. Parameters first - the beginning of the range of elements to copy from count - number of the elements to copy result - the beginning of the destination rang

Defined in header <type_traits> template< class T > struct add_cv; (1) (since C++11) template< class T > struct add_const; (2) (since C++11) template< class T > struct add_volatile; (3) (since C++11) Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). 1) adds both const and volatile. 2) adds const. 3) adds volatile. Member types

void reset(); (since C++11) Releases the reference to the managed object. After the call *this manages no object. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept

valarray<T> operator+() const; (1) valarray<T> operator-() const; (2) valarray<T> operator~() const; (3) valarray<bool> operator!() const; (4) Applies unary operators to each element in the numeric array. Parameters (none). Return value A numeric array containing elements with values obtained by applying corresponding operator to the values in *this. Exceptions (none). Notes Each of the operators can only be instantiated if the follo

void swap(unique_ptr& other); (since C++11) Swaps the managed objects and associated deleters of *this and another unique_ptr object other. Parameters other - another unique_ptr object to swap the managed object and the deleter with Return value (none). Exceptions noexcept specification: noexcept Example #include <iostream> #include <memory> struct Foo { Foo(int _val) : val(_val) { std::cout << "Foo...\n"; } ~Foo() { std::cout <