condition_variable(); (1) (since C++11) condition_variable(const condition_variable&) = delete; (2) (since C++11) 1) Constructs an object of type std::condition_variable. 2) Copy constructor is deleted. Parameters (none). Exceptions 1) May throw std::system_error with std::error_condition equal to std::errc::operation_not_permitted if the thread has no privilege to create a condition variable, std::errc::resource_unavailable_try_again if a non-memory resource limitation

Defined in header <condition_variable> class condition_variable; (since C++11) The condition_variable class is a synchronization primitive that can be used to block a thread, or multiple threads at the same time, until another thread both modifies a shared variable (the condition), and notifies the condition_variable. The thread that intends to modify the variable has to. acquire a std::mutex (typically via std::lock_guard) perform the modification while the lock is held

void notify_all(); (since C++11) Unblocks all threads currently waiting for *this. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Notes The effects of notify_one()/notify_all() and wait()/wait_for()/wait_until() take place in a single total order, so it's impossible for notify_one() to, for example, be delayed and unblock a thread that started waiting just after the call to notify_one() was made. The notifying thread does not need to ho

native_handle_type native_handle(); (since C++11) Accesses the native handle of *this. The meaning and the type of the result of this function is implementation-defined. On a POSIX system, this may be a value of type pthread_cond_t*. On a Windows system, this may be a PCONDITION_VARIABLE. Parameters (none). Return value The native handle of this condition variable. See also native_handle returns the underlying implementation-defined thread handle (public member function of

template< class T > complex<T> operator+( const complex<T>& val ); (1) template< class T > complex<T> operator-( const complex<T>& val ); (2) Implements the analogs of the unary arithmetic operators for complex numbers. 1) Returns the value of its argument 2) Negates the argument Parameters val - the complex number argument Return value 1) a copy of the argument, complex<T>(val) 2) negated argument, complex<T&

primary template complex<T> T real() const; (1) (until C++14) constexpr T real() const; (1) (since C++14) void real( T value ); (2) specialization complex<float> float real() const; (1) (until C++11) constexpr float real(); (1) (since C++11) (until C++14) constexpr float real() const; (1) (since C++14) void real( float value ); (2) specialization complex<double> double real() const; (1) (until C++11) constexpr double

complex<T>& operator+=( const T& other ); (1) template< class X > complex<T>& operator+=( const complex<X>& other ); (2) complex<T>& operator-=( const T& other ); (3) template< class X > complex<T>& operator-=( const complex<X>& other ); (4) complex<T>& operator*=( const T& other ); (5) template< class X > complex<T>& operator*=( const complex<X>&

Defined in header <type_traits> template< bool B, class T, class F > struct conditional; (since C++11) Provides member typedef type, which is defined as T if B is true at compile time, or as F if B is false. Member types Member type Definition type T if B == true, F if B == false Helper types template< bool B, class T, class F > using conditional_t = typename conditional<B,T,F>::type; (since C++14) Possible implementation templa

primary template complex<T> T imag() const; (1) (until C++14) constexpr T imag() const; (1) (since C++14) void imag( T value ); (2) specialization complex<float> float imag() const; (1) (until C++11) constexpr float imag(); (1) (since C++11) (until C++14) constexpr float imag() const; (1) (since C++14) void imag( float value ); (2) specialization complex<double> double imag() const; (1) (until C++11) constexpr double

primary template complex<T> complex( const T& re = T(), const T& im = T() ); (1) (until C++14) constexpr complex( const T& re = T(), const T& im = T() ); (1) (since C++14) complex( const complex& other ); (2) (until C++14) constexpr complex( const complex& other ); (2) (since C++14) template< class X > complex( const complex<X>& other); (3) (until C++14) template< class X > constexpr complex( const complex<