protected: virtual std::basic_streambuf<CharT, Traits>* setbuf( char_type* s, std::streamsize n ) If s is a null pointer and n is zero, the filebuf becomes unbuffered for output, meaning pbase() and pptr() are null and any output is immediately sent to file. Otherwise, a call to setbuf() replaces the internal buffer (the controlled character sequence) with the user-supplied character array whose first element is pointed to by s and allows this std::basic_filebuf object to use up t

basic_istream& ignore( std::streamsize count = 1, int_type delim = Traits::eof() ); Extracts and discards characters from the input stream until and including delim. ignore behaves as an UnformattedInputFunction. After constructing and checking the sentry object, it extracts characters from the stream and discards them until any one of the following conditions occurs: count characters were extracted. This test is disabled in the special case when count equals std::numeric_limits<

template <class... Args> iterator emplace_hint( const_iterator hint, Args&&... args ); (since C++11) Inserts a new element into the container as close as possible to the position just before hint. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with std::forward<Args>(args).... No iterators or references are invalidated.

Defined in header <type_traits> template< class T > struct is_arithmetic; (since C++11) If T is an arithmetic type (that is, an integral type or a floating-point type), provides the member constant value equal true. For any other type, value is false. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_arithmetic_v = is_arithmetic<T>::value; (since C++17) Inherited from std::inte

Defined in header <array> template< class T, std::size_t N > struct array; (since C++11) std::array is a container that encapsulates fixed size arrays. This container is an aggregate type with the same semantics as a struct holding a C-style array T[N] as its only non-static data member. Unlike a C-style array, it doesn't decay to T* automatically. As an aggregate type, it can be initialized with aggregate-initialization given at most N initializers that ar

Defined in header <algorithm> template< class RandomIt > void random_shuffle( RandomIt first, RandomIt last ); (1) (until C++17)(deprecated in C++14) (2) template< class RandomIt, class RandomFunc > void random_shuffle( RandomIt first, RandomIt last, RandomFunc& r ); (until C++11) template< class RandomIt, class RandomFunc > void random_shuffle( RandomIt first, RandomIt last, RandomFunc&& r ); (since C++11) (until C++17)(deprecated in

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 <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 <cmath> float abs( float arg ); (1) double abs( double arg ); (2) long double abs( long double arg ); (3) double abs( Integral arg ); (4) (since C++11) float fabs( float arg ); (5) double fabs( double arg ); (6) long double fabs( long double arg ); (7) double fabs( Integral arg ); (8) (since C++11) 1-3,5-7) Computes the absolute value of a floating point value arg. 4,8) A set of ov

Defined in header <memory> template< class T > struct allocator; (1) template<> struct allocator<void>; (2) The std::allocator class template is the default Allocator used by all standard library containers if no user-specified allocator is provided. The default allocator is stateless, that is, all instances of the given allocator are interchangeable, compare equal and can deallocate memory allocated by any other instance of the same allocator type.