void unlock_shared(); (since C++17) Releases the mutex from shared ownership by the calling thread. . The mutex must be locked by the current thread of execution in shared mode, 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_shared() is usually not called directly: std::shar

static const bool is_integer; (until C++11) static constexpr bool is_integer; (since C++11) The value of std::numeric_limits<T>::is_integer is true for all integer arithmetic types T and false otherwise. This constant is meaningful for all specializations. Standard specializations T value of std::numeric_limits<T>::is_integer /* non-specialized */ false bool true char true signed char true unsigned char true wchar_t true char16_t true

Defined in header <iterator> template< class Container > std::back_insert_iterator<Container> back_inserter( Container& c ); back_inserter is a convenience function template that constructs a std::back_insert_iterator for the container c with the type deduced from the type of the argument. Parameters c - container that supports a push_back operation Return value A std::back_insert_iterator which can be used to add elements to the end of the con

unsigned long long to_ullong() const (since C++11) Converts the contents of the bitset to an unsigned long long integer. The first bit of the bitset corresponds to the least significant digit of the number and the last bit corresponds to the most significant digit. Parameters (none). Return value the converted integer. Exceptions std::overflow_error if the value can not be represented in unsigned long long. Example #include <iostream> #include <bitset> #include

Defined in header <cwchar> int wscanf( const wchar_t* format, ... ); (1) (since C++11) int fwscanf( std::FILE* stream, const wchar_t* format, ... ); (2) (since C++11) int swscanf( const wchar_t* buffer, const wchar_t* format, ... ); (3) (since C++11) Reads data from the a variety of sources, interprets it according to format and stores the results into given locations. 1) Reads the data from stdin. 2) Reads the data from file stream stream. 3) Reads the data

This header is part of the general utility library. Includes <initializer_list>(C++11) Namespaces rel_ops Provide automatic comparison operators Defined in namespace std::rel_ops operator!=operator>operator<=operator>= automatically generates comparison operators based on user-defined operator== and operator< (function template) Functions swap swaps the values of two objects (function template) exchange (C++14) replaces the argument with a

constexpr bool empty(); (since C++11) (until C++14) constexpr bool empty() const; (since C++14) Checks if the container has no elements, i.e. whether begin() == end(). Parameters (none). Return value true if the container is empty, false otherwise. Exceptions noexcept specification: noexcept Complexity Constant. Example The following code uses empty to check if a std::array contains any elements: #include <array> #include <iostream> int main() {

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)

Defined in header <functional> template< class T > struct greater; (until C++14) template< class T = void > struct greater; (since C++14) Function object for performing comparisons. Unless specialized, invokes operator> on type T. Specializations The partial specialization of std::greater for any pointer type yields a total order, even if the built-in operator> does not. The standard library provides a specialization of std::greater when T is no

static T infinity(); (until C++11) static constexpr T infinity(); (since C++11) Returns the special value "positive infinity", as represented by the floating-point type T. Only meaningful if std::numeric_limits<T>::has_infinity == true. In IEEE 754, the most common binary representation of floating-point numbers, the positive infinity is the value with all bits of the exponent set and all bits of the fraction cleared. Return value T std::numeric_limits<T>::infini