Linux Manuals session 3

std::condition_variable_any::notify_all – std::condition_variable_any::notify_all Synopsis void notify_all() noexcept; (since C++ 11) Unblocks all threads currently waiting for *this. Parameters (none) Return value (none) Notes The effects of notify_one()/notify_all() and each of the three atomic parts of wait()/wait_for()/wait_until() (unlock+wait, wakeup, and lock) take place in a single total order that can be viewed as modification_order of an…

std::condition_variable_any::~condition_variable_any – std::condition_variable_any::~condition_variable_any Synopsis ~condition_variable_any(); (1) (since C++11) Destroys the object of type std::condition_variable_any It is only safe to invoke the destructor if all threads have been notified. It is not required that they have exited their respective wait functions: some threads may still be waiting to reacquire the associated lock, or may be waiting…

std::condition_variable_any – std::condition_variable_any Synopsis Defined in header <condition_variable> class condition_variable_any; (since C++11) The condition_variable_any class is a generalization of std::condition_variable. Whereas std::condition_variable works only on std::unique_lock<std::mutex>, condition_variable_any can operate on any lock that meets the BasicLockable requirements. See std::condition_variable for the description of the semantics of condition variables. The class std::condition_variable_any is a StandardLayoutType. It…

std::condition_variable::wait_until – std::condition_variable::wait_until Synopsis template <class Clock, class Duration> std::cv_status(1)(since C++ 11) wait_until(std::unique_lock<std::mutex> &lock, const std::chrono::time_point<Clock, Duration> &timeout_time); template <class Clock, class Duration, class Pred> bool wait_until(std::unique_lock<std::mutex> &lock, (2)(since C++ 11) const std::chrono::time_point<Clock, Duration> &timeout_time, Pred pred); wait_until causes the current thread to block until the condition variable is notified, a specific time is reached,…

std::condition_variable::wait_for – std::condition_variable::wait_for Synopsis template <class Rep, class Period> std::cv_status wait_for(std::unique_lock<std::mutex> &lock, (1)(since C++ 11) const std::chrono::duration<Rep, Period> &rel_time); template <class Rep, class Period, class Predicate> bool wait_for(std::unique_lock<std::mutex> &lock, (2)(since C++ 11) const std::chrono::duration<Rep, Period> &rel_time, Predicate pred); 1) Atomically releases lock, blocks the current executing thread, and adds it to the list of threads…

std::condition_variable::wait – std::condition_variable::wait Synopsis void wait(std::unique_lock<std::mutex> &lock); (1)(since C++ 11) template <class Predicate> (2)(since C++ 11) void wait(std::unique_lock<std::mutex> &lock, Predicate pred); wait causes the current thread to block until the condition variable is notified or a spurious wakeup occurs, optionally looping until some predicate is satisfied. 1) Atomically unlocks lock, blocks the current executing thread,…

std::condition_variable::notify_one – std::condition_variable::notify_one Synopsis void notify_one() noexcept; (since C++ 11) If any threads are waiting on *this, calling notify_one unblocks one of the waiting threads. Parameters (none) Return value (none) Notes The effects of notify_one()/notify_all() and each of the three atomic parts of wait()/wait_for()/wait_until() (unlock+wait, wakeup, and lock) take place in a single total order…

std::condition_variable::notify_all – std::condition_variable::notify_all Synopsis void notify_all() noexcept; (since C++ 11) Unblocks all threads currently waiting for *this. Parameters (none) Return value (none) Notes The effects of notify_one()/notify_all() and each of the three atomic parts of wait()/wait_for()/wait_until() (unlock+wait, wakeup, and lock) take place in a single total order that can be viewed as modification_order of an…

std::condition_variable::native_handle – std::condition_variable::native_handle Synopsis 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…

std::condition_variable::~condition_variable – std::condition_variable::~condition_variable Synopsis ~condition_variable(); (1) (since C++11) Destroys the object of type std::condition_variable It is only safe to invoke the destructor if all threads have been notified. It is not required that they have exited their respective wait functions: some threads may still be waiting to reacquire the associated lock, or may be waiting…

std::condition_variable – std::condition_variable Synopsis 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…

std::complex<T>::real – std::complex<T>::real Synopsis primary template complex<T> T real() const; (until C++14) constexpr T real() const; (since C++14) void real( T value ); (until C++20) constexpr void real( T value ); (since C++20) specialization complex<float> float real() const; (until C++11) constexpr float real(); (since C++11)                                                                               (until C++14) constexpr float real() const; (since C++14) void real(…

std::complex<T>::operator= – std::complex<T>::operator= Synopsis primary template complex<T> complex &operator=(const T &x); (until C++ 20) constexpr complex & operator=(const T &x); (since C++ 20) specialization complex<float> complex &operator=(float x); (until C++ 20) constexpr complex & operator=(float x); (since C++ 20) specialization complex<double> complex &operator=(double x); (until C++ 20) constexpr complex & operator=(double x); (since C++ 20)…

std::complex<T>::operator+(unary),operator-(unary) – std::complex<T>::operator+(unary),operator-(unary) Synopsis template <class T> (until C++ 20) std::complex<T> operator+(const std::complex<T> &val); template <class T> (since C++ 20) constexpr std::complex<T> operator+(const std::complex<T> &val); (1) template <class T> (until C++ 20) std::complex<T> operator-(const std::complex<T> &val); (2) template <class T> (since C++ 20) constexpr std::complex<T> operator-(const std::complex<T> &val); Implements the analogs of the unary arithmetic…

std::complex<T>::imag – std::complex<T>::imag Synopsis primary template complex<T> T imag() const; (until C++14) constexpr T imag() const; (since C++14) void imag( T value ); (until C++20) constexpr void imag( T value ); (since C++20) specialization complex<float> float imag() const; (until C++11) constexpr float imag(); (since C++11)                                                                               (until C++14) constexpr float imag() const; (since C++14) void imag(…

std::complex<T>::complex – std::complex<T>::complex Synopsis 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> (3)(until C++ 14) complex(const complex<X>…

std::complex – std::complex Synopsis Defined in header <complex> template< class T > (1) class complex; template<> class complex<float>; (2) template<> class complex<double>; (3) template<> class complex<long double>; (4) The specializations std::complex<float>, std::complex<double>, and std::complex<long double> are LiteralTypes for representing and manipulating complex_numbers. The effect of instantiating the template complex for any other type is unspecified….

std::compare_3way – std::compare_3way Synopsis Defined in header<algorithm> template <class T, class U> (since C++ 20) constexpr auto compare_3way(const T &a, const U &b); Compares two values using three-way comparison and produces a result of the strongest applicable comparison category type. In detail: * If the expression a <=> b is well-formed, returns its result *…

std::comp_ellint_3,std::comp_ellint_3f,std::comp_ellint_3l – std::comp_ellint_3,std::comp_ellint_3f,std::comp_ellint_3l Synopsis double comp_ellint_3( double k, double ν ); float comp_ellint_3f( float k, float ν ); (1) (since C++17) long double comp_ellint_3l( long double k, long double ν ); Promoted comp_ellint_3( Arithmetic k, Arithmetic ν ); (2) (since C++17) 1) Computes the complete_elliptic_integral_of_the_third_kind of the arguments k and ν. 2) A set of…

std::comp_ellint_2,std::comp_ellint_2f,std::comp_ellint_2l – std::comp_ellint_2,std::comp_ellint_2f,std::comp_ellint_2l Synopsis double comp_ellint_2( double k); float comp_ellint_2( float k ); long double comp_ellint_2( long double k ); (1) (since C++17) float comp_ellint_2f( float k ); long double comp_ellint_2l( long double k ); double comp_ellint_2( IntegralType k ); (2) (since C++17) 1) Computes the complete_elliptic_integral_of_the_second_kind of k. 2) A set of overloads or…