void sort(); (1) (since C++11) template< class Compare > void sort( Compare comp ); (2) (since C++11) Sorts the elements in ascending order. The order of equal elements is preserved. The first version uses operator< to compare the elements, the second version uses the given comparison function comp. Parameters comp - comparison function object (i.e. an object that satisfies the requirements of Compare) which returns ​true if the first argument is less than (i.e.

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. 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 this function without constructing an instance of Key. Parameters

explicit dynarray( size_type count ); (1) (since C++14) template< class Alloc > dynarray( size_type count, const Alloc& alloc ); (2) (since C++14) dynarray( size_type count, const T& value ); (3) (since C++14) template< class Alloc > dynarray( size_type count, const T& value, const Alloc& alloc ); (4) (since C++14) dynarray( const dynarray& other ); (5) (since C++14) template< class Alloc > dynarray( const dynarray& other,

static const int radix; (until C++11) static constexpr int radix; (since C++11) The value of std::numeric_limits<T>::radix is the base of the number system used in the representation of the type. It is 2 for all binary numeric types, but it may be, for example, 10 for IEEE 754 decimal floating-point types or for third-party binary-coded decimal integers. This constant is meaningful for all specializations. Standard specializations T value of std::numeric_limits<T>

indirect_array( const indirect_array& other ); indirect_array() = delete; Constructs a indirect_array from another indirect_array other. The default constructor is implicitly deleted. Parameters other - indirect_array to initialize with

template< class CharT, class Traits, class ResultType > std::basic_ostream<CharT,Traits>& operator<<( std::basic_ostream<CharT,Traits>& ost, const exponential_distribution<ResultType>& d ); (1) template< class CharT, class Traits, class ResultType > std::basic_istream<CharT,Traits>& operator>>( std::basic_istream<CharT,Traits>& ist,

A template is a C++ entity that defines one of the following: a family of classes (class template), which may be nested classes a family of functions (function template), which may be member functions an alias to a family of types (alias template) (since C++11) a family of variables (variable template) (since C++14) Templates are parametrized by one or more template parameters, of three kinds: type template parameters, non-type template parameters, and template template parameters. Wh

Usage alternative operators: as an alternative for ^=

Defined in header <chrono> template< class Clock, class Duration = typename Clock::duration > class time_point; (since C++11) Class template std::chrono::time_point represents a point in time. It is implemented as if it stores a value of type Duration indicating the time interval from the start of the Clock's epoch. Member types Member type Definition clock Clock, the clock on which this time point is measured duration Duration, a std::chrono:

Defined in header <forward_list> template< class T, class Allocator = std::allocator<T> > class forward_list; (since C++11) std::forward_list is a container that supports fast insertion and removal of elements from anywhere in the container. Fast random access is not supported. It is implemented as a singly-linked list and essentially does not have any overhead compared to its implementation in C. Compared to std::list this container provides more space