Defined in header <algorithm> template< class ForwardIt, class T > bool binary_search( ForwardIt first, ForwardIt last, const T& value ); (1) template< class ForwardIt, class T, class Compare > bool binary_search( ForwardIt first, ForwardIt last, const T& value, Compare comp ); (2) Checks if an element equivalent to value appears within the range [first, last). For std::binary_search to succeed, the range [first, last) must be at least partially or

Defined in header <scoped_allocator> template< class T > void destroy( T* p ); (since C++11) Uses the outer allocator to call the destructor of the object pointed to by p, by calling. std::allocator_traits<OUTERMOST>::destroy(OUTERMOST(*this), p). where OUTERMOST is the type that would be returned by calling this->outer_allocator(), and then calling the outer_allocator() member function recursively on the result of this call until reaching the type that has n

Defined in header <cmath> float remquo( float x, float y, int* quo ); (1) (since C++11) double remquo( double x, double y, int* quo ); (2) (since C++11) long double remquo( long double x, long double y, int* quo ); (3) (since C++11) Promoted remquo( Arithmetic1 x, Arithmetic2 y, int* quo ); (4) (since C++11) 1-3) Computes the floating-point remainder of the division operation x/y as the std::remainder() function does. Additionally, the sign

Defined in header <cctype> int ispunct( int ch ); Checks if the given character is a punctuation character as classified by the current C locale. The default C locale classifies the characters !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ as punctuation. The behavior is undefined if the value of ch is not representable as unsigned char and is not equal EOF. Parameters ch - character to classify Return value Non-zero value if the character is a punctuation charact

Manipulators are helper functions that make it possible to control input/output streams using operator<< or operator>>. The manipulators that are invoked without arguments (e.g. std::cout << std::boolalpha; or std::cin >> std::hex;) are implemented as functions that take a reference to a stream as their only argument. The special overloads of basic_ostream::operator<< and basic_istream::operator>> accept pointers to these functions. The manipulators that are

Defined in header <cstdlib> std::size_t wcstombs( char* dst, const wchar_t* src, std::size_t len); Converts a sequence of wide characters from the array whose first element is pointed to by src to its narrow multibyte representation that begins in the initial shift state. Converted characters are stored in the successive elements of the char array pointed to by dst. No more than len bytes are written to the destination array. Each character is converted as if by a call to s

Defined in header <iterator> template< class C > auto begin( C& c ) -> decltype(c.begin()); (1) (since C++11) template< class C > auto begin( const C& c ) -> decltype(c.begin()); (1) (since C++11) (2) template< class T, std::size_t N > T* begin( T (&array)[N] ); (since C++11) (until C++14) template< class T, std::size_t N > constexpr T* begin( T (&array)[N] ); (since C++14) template< class C > constex

protected: virtual pos_type seekpos(pos_type sp, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out ); Repositions std::basic_streambuf::gptr and/or std::basic_streambuf::pptr, if possible, to the position indicated by sp. Effectively executes seekoff(off_type(sp), std::ios_base::beg, which). Parameters sp - stream position, such as one obtained by seekoff() or seekpos() which - defines whether the input sequences, the output se

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

Defined in header <cuchar> std::size_t c16rtomb( char* s, char16_t c16, std::mbstate_t* ps ); (since C++11) Converts a UCS-2 code point to narrow multibyte character. If s is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of c16 (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by s. At most MB_CUR_MAX bytes can