protected: virtual int_type underflow() Reads more data into the input area. Behaves like the base class std::basic_streambuf::underflow, except that to read the data from the associated character sequence (the file) into the get area, first reads the bytes from the file into a temporary buffer (allocated as large as necessary), then uses std::codecvt::in of the imbued locale to convert the external (typically, multibyte) representation to the internal form which is then used to populat

void swap( basic_ofstream& other ); (since C++11) Exchanges the state of the stream with those of other. This is done by calling basic_ostream<CharT, Traits>::swap(other) and rdbuf()->swap(other.rdbuf()). Parameters other - stream to exchange the state with Return value (none). Example See also operator= (C++11) moves the file stream (public member function) swap (C++11) swaps two basic_filebuf objects (public member function of std::basic_

Defined in header <locale> public: iter_type put(iter_type out, bool intl, std::ios_base& f, char_type fill, long double quant) const; (1) iter_type put(iter_type out, bool intl, std::ios_base& f, char_type fill, const string_type& quant) const; (2) protected: virtual iter_type do_put(iter_type out, bool intl, std::ios_base& str, char_type fill, long double units) const; (3) virtual iter_type do_

Specifies that an object of the type can be constructed from a given set of arguments in uninitialized storage by a given allocator. Requirements The type T is EmplaceConstructible into the Container X (whose value_type is identical to T) from the arguments args if, given. A an allocator type m an lvalue of type A p the pointer of type T* prepared by the container args zero or more arguments where X::allocator_type is identical to std::allocator_traits<A>::rebind_allo

Defined in header <cmath> int ilogb( float arg ); (1) (since C++11) int ilogb( double arg ); (2) (since C++11) int ilogb( long double arg ); (3) (since C++11) int ilogb( Integral arg ); (4) (since C++11) #define FP_ILOGB0 /*implementation-defined*/ (5) (since C++11) #define FP_ILOGBNAN /*implementation-defined*/ (6) (since C++11) 1-3) Extracts the value of the unbiased exponent from the floating-point argument a

Defined in header <cstdlib> void* malloc( std::size_t size ); Allocates size bytes of uninitialized storage. If allocation succeeds, returns a pointer to the lowest (first) byte in the allocated memory block that is suitably aligned for any scalar type. If size is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage). Parameters size - number of bytes to allocate

protected: virtual int_type pbackfail( int_type c = EOF ); This protected virtual function is called by the public functions basic_streambuf::sungetc and basic_streambuf::sputbackc (which, in turn, are called by basic_istream::unget and basic_istream::putback). 1) The caller is requesting that the get area is backed up by one character (pbackfail() is called with no arguments or with EOF as the argument) a) First, checks if there is a putback position, and if there really isn't, fails

protected: virtual int_type overflow (int_type c = EOF); Appends the character c to the put area of the buffer, reallocating if possible. 1) If c==EOF, does nothing 2) Otherwise, if the put area has a write position available (pptr() < epptr()), stores the character as if by *pptr()++ = c 3) Otherwise, if the stream buffer mode is not dynamic or the stream buffer is currently frozen, the function fails and returns EOF 4) Otherwise, the function reallocates (or initially allocat

A seed sequence is an object that produces unsigned integer values i in the range 0 ≤ i < 232 based on a consumed range of integer data. Requirements S is a SeedSequence. q is an object of S and r is a potentially constant object of S. T is the result_type. ib,ie are InputIterators with a value_type of unsigned integer values of at least 32 bits. il is an std::initializer_list<T>. rb,re are mutable RandomAccessIterators with a value_type of unsigned integer values of at l

A destructor is a special member function that is called when the lifetime of an object ends. The purpose of the destructor is to free the resources that the object may have acquired during its lifetime. Syntax ~ class_name (); (1) virtual ~ class_name (); (2) ~ class_name () = default; (3) (since C++11) ~ class_name () = delete; (4) (since C++11) attr(optional) decl-specifier-seq(optional) id-expression ( void(optional) ) except(optional) attr(optional) ; (5)