Defined in header <cuchar> std::size_t mbrtoc16( char16_t* pc16, const char* s, std::size_t n, std::mbstate_t* ps ); (since C++11) Converts a narrow multibyte character to UTF-16 character representation. If s is not a null pointer, inspects at most n bytes of the multibyte character string, beginning with the byte pointed to by s to determine the number of bytes necessary to complete the next multibyte chara

Defined in header <utility> template< class T > typename std::remove_reference<T>::type&& move( T&& t ); (since C++11) (until C++14) template< class T > constexpr typename std::remove_reference<T>::type&& move( T&& t ); (since C++14) std::move is used to indicate that an object t may be "moved from", i.e. allowing the efficient transfer of resources from t to another object. In particular, std::move produces an x

Defined in header <regex> template< class BidirIt, class Alloc = std::allocator<std::sub_match<BidirIt>> > class match_results; (since C++11) The class template std::match_results holds a collection of character sequences that represent the result of a regular expression match. This is a specialized allocator-aware container. It can only be default created, obtained from std::regex_iterator, or modified by std::regex_search or std::regex_match. Bec

Exception handling The header <exception> provides several classes and functions related to exception handling in C++ programs. Defined in header <exception> exception base class for exceptions thrown by the standard library components (class) Capture and storage of exception objects uncaught_exceptionuncaught_exceptions (C++17) checks if exception handling is currently in progress (function) exception_ptr (C++11) shared pointer type for handling except

A copy constructor of class T is a non-template constructor whose first parameter is T&, const T&, volatile T&, or const volatile T&, and either there are no other parameters, or the rest of the parameters all have default values. Syntax class_name ( const class_name & ) (1) class_name ( const class_name & ) = default; (2) class_name ( const class_name & ) = delete; (3) Explanation Typical declaration of a copy constructor Forcing a copy

fmtflags setf( fmtflags flags ); (1) fmtflags setf( fmtflags flags, fmtflags mask ); (2) Sets the formatting flags to specified settings. 1) Sets the formatting flags identified by flags. Effectively the following operation is performed fl = fl | flags where fl defines the state of internal formatting flags. 2) Clears the formatting flags under mask, and sets the cleared flags to those specified by flags. Effectively the following operation is performed fl = (fl & ~mask) |

Defined in header <complex> template< class T > complex<T> tanh( const complex<T>& z ); (since C++11) Computes complex hyperbolic tangent of a complex value z. Parameters z - complex value Return value If no errors occur, complex hyperbolic tangent of z is returned. Error handling and special values Errors are reported consistent with math_errhandling. If the implementation supports IEEE floating-point arithmetic, std::tanh(std::conj

Defined in header <algorithm> template< class RandomIt > void nth_element( RandomIt first, RandomIt nth, RandomIt last ); (1) template< class RandomIt, class Compare > void nth_element( RandomIt first, RandomIt nth, RandomIt last, Compare comp ); (2) nth_element is a partial sorting algorithm that rearranges elements in [first, last) such that: The element pointed at by nth is changed to whatever element would occur in that position if [first, last) was s

Defined in header <valarray> template< class T > valarray<T> log( const valarray<T>& va ); For each element in va computes natural logarithm of the value of the element. Parameters va - value array to apply the operation to Return value Value array natural logarithms of the values in va. Notes Unqualified function (log) is used to perform the computation. If such function is not available, std::log is used due to argument dependent loo

Defined in header <cstdlib> void* realloc( void* ptr, std::size_t new_size ); Reallocates the given area of memory. It must be previously allocated by std::malloc(), std::calloc() or std::realloc() and not yet freed with std::free(), otherwise, the results are undefined. The reallocation is done by either: a) expanding or contracting the existing area pointed to by ptr, if possible. The contents of the area remain unchanged up to the lesser of the new and old sizes. If the