Defined in header <functional> template< class T = void > struct bit_not; (since C++14) Function object for performing bitwise NOT. Effectively calls operator~ on type T. Specializations The standard library provides a specialization of std::bit_not when T is not specified, which leaves the parameter types and return type to be deduced. bit_not<void> function object implementing ~x deducing argument and return types (class template specialization) (sin

enum event; Specifies the event type which is passed to functions registered by register_callback() on specific events. The following constants are defined: Constant Explanation erase_event issued on ~ios_base() or basic_ios::copyfmt() (before the copy of members takes place) imbue_event issued on imbue() copyfmt_event issued on basic_ios::copyfmt() (after the copy of members takes place, but before the exception settings are copied) Example

std::basic_ostream<CharT,Traits>* tie() const; (1) std::basic_ostream<CharT,Traits>* tie( std::basic_ostream<CharT,Traits>* str ); (2) Manages the tied stream. A tied stream is an output stream which is synchronized with the sequence controlled by the stream buffer (rdbuf()), that is, flush() is called on the tied stream before any input/output operation on *this. 1) Returns the current tied stream. If there is no tied stream, NULL is returned. 2) Sets the curr

Defined in header <cstdlib> int atoi( const char *str ); long atol( const char *str ); long long atoll( const char *str ); (since C++11) Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value. The valid integer value consists of the f

void unlock(); (since C++17) Unlocks the mutex. The mutex must be locked by the current thread of execution, otherwise, the behavior is undefined. This operation synchronizes-with (as defined in std::memory_order) any subsequent lock operation that obtains ownership of the same mutex. Parameters (none). Return value (none). Exceptions (none). Notes unlock() is usually not called directly: std::unique_lock and std::lock_guard are used to manage exclusive locking. Example

Defined in header <ctime> typedef /* unspecified */ time_t; Arithmetic type capable of representing times. Although not defined, this is almost always an integral value holding the number of seconds (not counting leap seconds) since 00:00, Jan 1 1970 UTC, corresponding to POSIX time. See also time returns the current time of the system as time since epoch (function) localtime converts time since epoch to calendar time expressed as local time (function) gmtim

basic_ifstream(); (1) explicit basic_ifstream( const char* filename, ios_base::openmode mode = ios_base::in ); (2) explicit basic_ifstream( const string& filename, ios_base::openmode mode = ios_base::in ); (3) (since C++11) basic_ifstream( basic_ifstream&& other ); (4) (since C++11) basic_ifstream( const basic_ifstream& rhs) = delete; (5) (since C++11) Constructs new file stream. 1

void seed( result_type value = default_seed ); (1) (since C++11) template< class Sseq > void seed( Sseq& seq ); (2) (since C++11) Reinitializes the internal state of the random-number engine using new seed value. Parameters value - seed value to use in the initialization of the internal state seq - seed sequence to use in the initialization of the internal state Exceptions (none). Complexity

size_type count( const Key& key ) const; (1) template< class K > size_type count( const K& x ) const; (2) (since C++14) 1) Returns the number of elements with key key. 2) Returns the number of elements with key that compares equivalent to the value x. This overload only participates in overload resolution if the qualified-id Compare::is_transparent is valid and denotes a type. They allow calling this function without constructing an instance of Key. Parameters

Defined in header <cstddef> typedef decltype(nullptr) nullptr_t; (since C++11) std::nullptr_t is the type of the null pointer literal, nullptr. It is a distinct type that is not itself a pointer type or a pointer to member type. Example If two or more overloads accept different pointer types, an overload for std::nullptr_t is necessary to accept a null pointer argument. #include <cstddef> #include <iostream> void f(int* pi) { std::cout << "Pointer