Defined in header <complex> template< class T > bool operator==( const complex<T>& lhs, const complex<T>& rhs); (1) (until C++14) template< class T > constexpr bool operator==( const complex<T>& lhs, const complex<T>& rhs); (1) (since C++14) template< class T > bool operator==( const complex<T>& lhs, const T& rhs); (2) (until C++14) template< class T > constexpr bool operator==( const c

Defined in header <system_error> class error_condition; (since C++11) std::error_condition is a platform-independent error code. Like std::error_code, it is uniquely identified by an integer value and a std::error_category, but unlike std::error_code, the value is not platform-dependent. A typical implementation holds one integer data member (the value) and a pointer to an std::error_category. Member functions (constructor) constructs an error_condition (public membe

std::future<T> get_future(); (since C++11) Returns a future object associated with the same shared state as *this. Exception is thrown if *this has no shared state or get_future has already been called. To get multiple "pop" ends of the promise-future communication channel, use std::future::share. Parameters (none). Return value A future referring to the shared state of *this. Exceptions std::future_error on the following conditions: *this has no shared state. The error

Defined in header <exception> void unexpected(); (until C++11) [[noreturn]] void unexpected(); (since C++11) (deprecated) std::unexpected() is called by the C++ runtime when a dynamic exception specification is violated: an exception is thrown from a function whose exception specification forbids exceptions of this type. std::unexpected() may also be called directly from the program. In either case, std::unexpected calls the currently installed std::unexpected_handler

static std::chrono::time_point<std::chrono::steady_clock> now(); (since C++11) Returns a time point representing the current point in time. Parameters (none). Return value A time point representing the current time. Exceptions noexcept specification: noexcept Example #include <iostream> #include <vector> #include <numeric> #include <chrono> volatile int sink; int main() { for (auto size = 1ull; size < 1000000000ull; size *= 100) {

template< class T > T* target(); (1) (since C++11) template< class T > const T* target() const; (2) (since C++11) Returns a pointer to the stored callable function target. Parameters (none). Return value A pointer to the stored function if target_type() == typeid(T), otherwise a null pointer. Exceptions noexcept specification: noexcept Example #include <functional> #include <iostream> int f(int, int) { return 1; } int g(int, int) { retur

template< class T, class Container, class Compare,class Alloc > struct uses_allocator<priority_queue<T,Compare,Container>,Alloc> : std::uses_allocator<Container, Alloc>::type { }; (since C++11) Provides a transparent specialization of the std::uses_allocator type trait for std::priority_queue: the container adaptor uses allocator if and only if the underlying container does. Inherited from std::integral_constant Member constants value [static] tr

RealType lambda() const; (since C++11) Returns the λ distribution parameter the distribution was constructed with. The parameter defines the rate of events, per unit. The default value is 1.0. Parameters (none). Return value Floating point value identifying the rate of events per unit. See also param gets or sets the distribution parameter object (public member function)

static const int min_exponent10; (until C++11) static constexpr int min_exponent10; (since C++11) The value of std::numeric_limits<T>::min_exponent10 is the lowest negative number n such that 10n is a valid normalized value of the floating-point type T. Standard specializations T value of std::numeric_limits<T>::min_exponent10 /* non-specialized */ ​0​ bool ​0​ char ​0​ signed char ​0​ unsigned char ​0​ wchar_t ​0​ char16_t ​0​ char3

Defined in header <complex> template< class T > complex<T> sin( const complex<T>& z ); Computes complex sine of a complex value z. Parameters z - complex value Return value If no errors occur, the complex sine of z is returned. Errors and special cases are handled as if the operation is implemented by -i * std::sinh(i*z), where i is the imaginary unit. Notes The sine is an entire function on the complex plane, and has no branch cuts.