Defined in header <complex> constexpr complex<double> operator""i(long double arg); constexpr complex<double> operator""i(unsigned long long arg); (1) (since C++14) constexpr complex<float> operator""if(long double arg); constexpr complex<float> operator""if(unsigned long long arg); (2) (since C++14) constexpr complex<long double> operator""il(long double arg); constexpr complex<long double> operator""il(unsigned long long arg); (3

void resize( size_type count ); (1) void resize( size_type count, CharT ch ); (2) Resizes the string to contain count characters. If the current size is less than count, additional characters are appended. If the current size is greater than count, the string is reduced to its first count elements. The first version initializes new characters to CharT(), the second version initializes new characters to ch. Parameters count - new size of the string ch - character to i

Defined in header <regex> template< class BidirIt, class Alloc, class CharT, class Traits > bool regex_search( BidirIt first, BidirIt last, std::match_results<BidirIt,Alloc>& m, const std::basic_regex<CharT,Traits>& e, std::regex_constants::match_flag_type flags = std::regex_constants::match_default ); (1) (since C++11) template< class CharT, class Alloc,

template< class... Args > iterator emplace( Args&&... args ); (since C++11) Inserts a new element into the container by constructing it in-place with the given args . Careful use of emplace allows the new element to be constructed while avoiding unnecessary copy or move operations. The constructor of the new element (i.e. std::pair<const Key, T>) is called with exactly the same arguments as supplied to emplace, forwarded via std::forward<Args>(args).... If reha

size_type max_size() const; Returns the maximum number of elements the container is able to hold due to system or library implementation limitations, i.e. std::distance(begin(), end()) for the largest container. Parameters (none). Return value Maximum number of elements. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. Notes This value is typically equal to std::numeric_limits<size_type>::max(), and reflects the

reverse_iterator rbegin(); const_reverse_iterator rbegin() const; const_reverse_iterator crbegin() const; (since C++11) Returns a reverse iterator to the first element of the reversed container. It corresponds to the last element of the non-reversed container. Parameters (none). Return value Reverse iterator to the first element. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. See also rend crend r

Defined in header <cmath> float nextafter( float from, float to ); (1) (since C++11) double nextafter( double from, double to ); (2) (since C++11) long double nextafter( long double from, long double to ); (3) (since C++11) Promoted nextafter( Arithmetic from, Arithmetic to ); (4) (since C++11) float nexttoward( float from, long double to ); (5) (since C++11) double nexttoward( double from, long double to ); (6) (since C++

T* data(); (since {std}) const T* data() const; (since {std}) Returns pointer to the underlying array serving as element storage. The pointer is such that range [data(); data() + size()) is always a valid range, even if the container is empty. Parameters (none). Return value Pointer to the underlying element storage. For non-empty containers, returns &front(). Complexity Constant. Exceptions noexcept specification: noexcept See also front access the first

Defined in header <cfenv> #define FE_DOWNWARD /*implementation defined*/ (since C++11) #define FE_TONEAREST /*implementation defined*/ (since C++11) #define FE_TOWARDZERO /*implementation defined*/ (since C++11) #define FE_UPWARD /*implementation defined*/ (since C++11) Each of these macro constants expands to a nonnegative integer constant expression, which can be used with std::fesetround and std::fegetround to indicate one of the supporte

Defined in header <exception> template< class T > [[noreturn]] void throw_with_nested( T&& t ); (since C++11) If std::remove_reference_t<T> is a non-final non-union class type that is neither std::nested_exception nor derived from std::nested_exception, throws an exception of an unspecified type that is publicly derived from both std::nested_exception and from std::remove_reference_t<T>, and constructed from std::forward<T>(t). The default co