float load_factor() const; (since C++11) Returns the average number of elements per bucket. Parameters (none). Return value Average number of elements per bucket. Complexity Constant. See also max_load_factor manages maximum average number of elements per bucket (public member function)

basic_filebuf(); (1) basic_filebuf( const std::basic_filebuf& rhs ) = delete; (2) (since C++11) basic_filebuf( std::basic_filebuf&& rhs ); (3) (since C++11) Contructs new std::basic_filebuf object. 1) Constructs a std::basic_filebuf object, initializing the base class by calling the default constructor of std::basic_streambuf. The created basic_filebuf is not associated with a file, and is_open() returns false. 2) The copy constructor is deleted; std::basic_fil

This header is part of the dynamic memory management library, in particular provides low level memory management features. Functions operator newoperator new[] allocation functions (function) operator deleteoperator delete[] deallocation functions (function) get_new_handler (C++11) obtains the current new handler (function) set_new_handler registers a new handler (function) Classes bad_alloc exception thrown when memory allocation fails (class) bad_arr

Defined in header <functional> template<> class greater_equal<void>; (since C++14) std::greater_equal<> is a specialization of std::greater_equal with parameter and return type deduced. Member types Member type Definition is_transparent /* unspecified */ Member functions operator() tests if the lhs compares greater or equal than rhs (public member function) std::greater_equal<>::operator() template< class T, class U>

void swap( std::basic_filebuf& rhs ); (since C++11) Swaps the state and the contents of *this and rhs. Parameters rhs - another basic_filebuf Return value (none). Notes This function is called automatically when swapping std::fstream objects, it is rarely necessary to call it directly. Example #include <fstream> #include <string> #include <iostream> int main() { std::ifstream fin("test.in"); // read-only std::ofstream fout("test.out"

iterator find( const Key& key ); (1) const_iterator find( const Key& key ) const; (2) template< class K > iterator find( const K& x ); (3) (since C++14) template< class K > const_iterator find( const K& x ) const; (4) (since C++14) 1,2) Finds an element with key equivalent to key. 3,4) Finds an element with key that compares equivalent to the value x. This overload only participates in overload resolution if the qualified-id Compare::is_t

template<class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); (1) (since C++11) template<class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); (2) (since C++11) template<class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y)

protected: virtual int_type pbackfail( int_type c = Traits::eof() ); This protected virtual function is called by the public functions sungetc() and sputbackc() (which, in turn, are called by basic_istream::unget and basic_istream::putback) when either: 1) There is no putback position in the get area (pbackfail() is called with no arguments). In this situation, the purpose of pbackfail() is to back up the get area by one character, if the associated character sequence allows this (e.g.

Defined in header <cwchar> const wchar_t* wmemchr( const wchar_t* ptr, wchar_t ch, std::size_t count ); wchar_t* wmemchr( wchar_t* ptr, wchar_t ch, std::size_t count ); Locates the first occurrence of wide character ch in the initial count wide characters of the wide character array pointed to by ptr. If count is zero, the function returns a null pointer. Parameters ptr - pointer to the wide character array to be examined ch - wide character

Defined in header <functional> template< class Predicate > std::binary_negate<Predicate> not2(const Predicate& pred); (until C++14) template< class Predicate > constexpr std::binary_negate<Predicate> not2(const Predicate& pred); (since C++14) not2 is a helper function to create a function object that returns the complement of the binary predicate function passed. The function object created is of type std::binary_negate<Predicate>