Defined in header <cstdio> int fgetpos( std::FILE* stream, std::fpos_t* pos ); Obtains the file position indicator and the current parse state (if any) for the file stream stream and stores them in the object pointed to by pos. The value stored is only meaningful as the input to std::fsetpos. Parameters stream - file stream to examine pos - pointer to a fpos_t object to store the file position indicator to Return value ​0​ upon success, nonzero value oth

protected: virtual int_type underflow(); Reads the next character from the get area of the buffer. If the input sequence has a read position available (gptr() < egptr(), returns (unsigned char)(*gptr()). Otherwise, if pptr() is not null and pptr() > egptr() (there is a put area and it is located after the get area), extends the end of the get area to include the characters that were recently written into the put area by incrementing egptr() to some value between gptr() and pptr(),

Defined in header <iterator> template< class Container > class insert_iterator : public std::iterator< std::output_iterator_tag, void,void,void,void > std::insert_iterator is an OutputIterator that inserts elements into a container for which it was constructed, at the position pointed to by the supplied iterator. The container's insert() member function is called whenever the iterator (whether dereferenced or not) is

Defined in header <random> template< class RealType = double > class lognormal_distribution; (since C++11) The lognormal_distribution random number distribution produces random numbers x > 0 according to a log-normal distribution: f(x; m,s) = 1sx√2 π exp⎛⎜⎝- (ln x - m)2 2s2 ⎞⎟⎠ The parameter m is the mean and the parameter s the standard deviation. std::lognormal_distribution satisfies all requirements of RandomNumberDistribution. Template parameters

Defined in header <algorithm> template< class RandomIt > void make_heap( RandomIt first, RandomIt last ); (1) template< class RandomIt, class Compare > void make_heap( RandomIt first, RandomIt last, Compare comp ); (2) Constructs a max heap in the range [first, last). The first version of the function uses operator< to compare the elements, the second uses the given comparison function comp. Parameters first, last - the range of

constexpr shared_ptr(); (1) template< class Y > explicit shared_ptr( Y* ptr ); (2) template< class Y, class Deleter > shared_ptr( Y* ptr, Deleter d ); (3) template< class Y, class Deleter, class Alloc > shared_ptr( Y* ptr, Deleter d, Alloc alloc ); (4) constexpr shared_ptr( std::nullptr_t ); (5) template< class Deleter > shared_ptr( std::nullptr_t, Deleter d ); (6) template< class Deleter, class Alloc > shared_ptr( std::nul

template< class ForwardIt > char_class_type lookup_classname( ForwardIt first, ForwardIt last, bool icase = false ) const; If the character sequence [first, last) represents the name of a valid character class in the currently imbued locale (that is, the string between [: and :] in regular expressions), returns the implementation-defined value representing this character class. Otherwise, returns zero. If the para

An OutputIterator is an Iterator that can write to the pointed-to element. An example of a type that implements OutputIterator is std::ostream_iterator. When ForwardIterator, BidirectionalIterator, or RandomAccessIterator satisfies the OutputIterator requirements in addition to its own requirements, it is described as mutable. Requirements The type X satisfies OutputIterator if. The type X satisfies Iterator X is a class type or a pointer type And, given. o, a value of some type that

(1) explicit priority_queue( const Compare& compare = Compare(), const Container& cont = Container() ); (until C++11) priority_queue( const Compare& compare, const Container& cont ); (since C++11) explicit priority_queue( const Compare& compare = Compare(), Container&& cont = Container() ); (2) (since C++11) priority_queue( const priority_queue& other ); (3) priority_queue( priority_queue&

A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A function parameter pack is a function parameter that accepts zero or more function arguments. A template with at least one parameter pack is called a variadic template. Syntax Template parameter pack (appears in a class template and in a function template parameter list). type ... Args(optional) (1) (since C++11) typename|class ... Args(optional) (2) (