This header is part of the regular expressions library. Namespace std::regex_constants Types Defined in namespace std::regex_constants syntax_option_type (C++11) general options controlling regex behavior (typedef) match_flag_type (C++11) options specific to matching (typedef) error_type (C++11) describes different types of matching errors (typedef) Classes basic_regex (C++11) regular expression object (class template) sub_match (C++11) identif

template< class CharT, class Traits > void swap( basic_ofstream<CharT,Traits> &lhs, basic_ofstream<CharT,Traits> &rhs ); Specializes the std::swap algorithm for std::basic_ofstream. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - streams whose state to swap Return value (none). Exceptions (none). Example See also swap (C++11) swaps two file streams (public member function)

template< class RandomIt > void generate( RandomIt begin, RandomIt end ); (since C++11) Fills the range [begin, end) with unsigned integer values i, 0 ≤ i < 232, based on the data originally provided in the constructor of this seed_seq. The produced values are distributed over the entire 32-bit range even if the initial values were strongly biased. The following algorithm is used (adapted from the initialization sequence of the Mersenne Twister generator by Makoto Matsumoto and

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