Linux Manuals session 3

std::shared_lock<Mutex>::lock – std::shared_lock<Mutex>::lock Synopsis void lock(); (since C++ 14) Locks the associated mutex in shared mode. Effectively calls mutex()->lock_shared(). Parameters (none) Return value (none) Exceptions * Any exceptions thrown by mutex()->lock_shared() * If there is no associated mutex, std::system_error with an error code of std::errc::operation_not_permitted * If the associated mutex is already locked by this…

std::shared_lock – std::shared_lock Synopsis Defined in header <shared_mutex> template< class Mutex > (since C++14) class shared_lock; The class shared_lock is a general-purpose shared mutex ownership wrapper allowing deferred locking, timed locking and transfer of lock ownership. Locking a shared_lock locks the associated shared mutex in shared mode (to lock it in exclusive mode, std::unique_lock can…

std::shared_future<T>::wait_until – std::shared_future<T>::wait_until Synopsis template <class Clock, class Duration> (since C++ 11) std::future_status wait_until(const std::chrono::time_point<Clock, Duration> &timeout_time) const; wait_until waits for a result to become available. It blocks until specified timeout_time has been reached or the result becomes available, whichever comes first. The return value indicates why wait_until returned. The behavior is undefined if valid()==…

std::shared_future<T>::wait_for – std::shared_future<T>::wait_for Synopsis template <class Rep, class Period> (since C++ 11) std::future_status wait_for(const std::chrono::duration<Rep, Period> &timeout_duration) const; Waits for the result to become available. Blocks until specified timeout_duration has elapsed or the result becomes available, whichever comes first. Returns value identifies the state of the result. This function may block for longer than timeout_duration…

std::shared_future<T>::wait – std::shared_future<T>::wait Synopsis void wait() const; (since C++ 11) Blocks until the result becomes available. valid() == true after the call. The behavior is undefined if valid()== false before the call to this function. Parameters (none) Return value (none) Exceptions (none) Notes The implementations are encouraged to detect the case when valid == false…

std::shared_future<T>::valid – std::shared_future<T>::valid Synopsis bool valid() const noexcept; (since C++11) Checks if the future refers to a shared state. This is the case only for futures that were not default-constructed or moved from. Unlike std::future, std::shared_future’s shared state is not invalidated when get() is called. The behavior is undefined if any member function other than…

std::shared_future<T>::~shared_future – std::shared_future<T>::~shared_future Synopsis ~shared_future(); (since C++11) If *this is the last object referring to the shared state, destroys the shared state. Otherwise does nothing.

std::shared_future<T>::operator= – std::shared_future<T>::operator= Synopsis shared_future &operator=(const shared_future &other); (since C++ 11)(1)(until C++ 17) shared_future & operator=(const shared_future &other) noexcept; (since C++ 17) shared_future & operator=(shared_future &&other) noexcept; (2)(since C++ 11) Assigns the contents of another shared_future. 1) Releases any shared state and assigns the contents of other to *this. After the assignment, this->valid() == other.valid()….

std::shared_future<T>::get – std::shared_future<T>::get Synopsis const T &get() const; (1)(member only of generic shared_future template)(since C++ 11) T &get() const; (2)(member only of shared_future<T &> template specialization)(since C++ 11) void get() const; (3)(member only of shared_future<void> template specialization)(since C++ 11) The get method waits until the shared_future has a valid result and (depending on which template…

std::shared_future – std::shared_future Synopsis Defined in header <future> template< class T > class shared_future; (1) (since C++11) template< class T > class shared_future<T&>; (2) (since C++11) template<> class shared_future<void>; (3) (since C++11) The class template std::shared_future provides a mechanism to access the result of asynchronous operations, similar to std::future, except that multiple threads are allowed…

std::setw – std::setw Synopsis Defined in header<iomanip> /*unspecified*/ setw(int n); When used in an expression out << setw(n) or in >> setw(n), sets the width parameter of the stream out or in to exactly n. Parameters n – new value for width Return value Returns an object of unspecified type such that if str is…

std::setvbuf – std::setvbuf Synopsis Defined in header<cstdio> int setvbuf(std::FILE *stream, char *buffer, int mode, std::size_t size); Changes the the buffering mode of the given file stream stream as indicated by the argument mode. In addition, * If buffer is a null pointer, resizes the internal buffer to size. * If buffer is not a null…

std::setprecision – std::setprecision Synopsis Defined in header<iomanip> /*unspecified*/ setprecision(int n); When used in an expression out << setprecision(n) or in >> setprecision(n), sets the precision parameter of the stream out or in to exactly n. Parameters n – new value for precision Return value Returns an object of unspecified type such that if str is…

std::setlocale – std::setlocale Synopsis Defined in header<clocale> char *setlocale(int category, const char *locale); The setlocale function installs the specified system locale or its portion as the new C locale. The modifications remain in effect and influences the execution of all locale-sensitive C library functions until the next call to setlocale. If locale is a null…

std::setiosflags – std::setiosflags Synopsis Defined in header <iomanip> /*unspecified*/ setiosflags( std::ios_base::fmtflags mask ); When used in an expression out << setiosflags(mask) or in >> setiosflags(mask), sets all format flags of the stream out or in as specified by the mask. Parameters mask – bitmask of the flags to set Return value Returns an object of…

std::setfill – std::setfill Synopsis Defined in header <iomanip> template< class CharT > /*unspecified*/ setfill( CharT c ); When used in an expression out << setfill(c) sets the fill character of the stream out to c. Parameters c – new value for the fill character Return value Returns an object of unspecified type such that if…

std::setbuf – std::setbuf Synopsis Defined in header<cstdio> void setbuf(std::FILE *stream, char *buffer); Sets the internal buffer to use for I/O operations performed on the C stream stream. If buffer is not null, equivalent to std::setvbuf(stream, buffer, _IOFBF, BUFSIZ) If buffer is null, equivalent to std::setvbuf(stream, NULL, _IONBF, 0), which turns off buffering. Parameters stream –…

std::setbase – std::setbase Synopsis Defined in header<iomanip> /*unspecified*/ setbase(int base); Sets the numeric base of the stream. When used in an expression out << setbase(base) or in >> setbase(base), changes the basefield flag of the stream out or in, depending on the value of base: * the value 16 sets basefield to std::ios_base::hex * the…

std::set_union – std::set_union Synopsis Defined in header <algorithm> template< class InputIt1, class InputIt2, class OutputIt > OutputIt set_union( InputIt1 first1, InputIt1 last1, (until C++20) InputIt2 first2, InputIt2 last2, OutputIt d_first ); template< class InputIt1, class InputIt2, class OutputIt > constexpr OutputIt set_union( InputIt1 first1, InputIt1 last1, (since C++20) InputIt2 first2, InputIt2 last2, OutputIt d_first );…

std::set_unexpected – std::set_unexpected Synopsis Defined in header <exception> std::unexpected_handler set_unexpected( std::unexpected_handler f ) throw(); (until C++11)                                                                                (since C++11) std::unexpected_handler set_unexpected( std::unexpected_handler f ) noexcept; (deprecated)                                                                                (removed in C++17) Makes f the new global std::unexpected_handler and returns the previously installed std::unexpected_handler. This function is thread-safe. Every call to std::set_unexpected synchronizes-with (see std::memory_order) the subsequent calls to…