Defined in header <csignal> #define SIG_DFL /*implementation defined*/ #define SIG_IGN /*implementation defined*/ The SIG_DFL and SIG_IGN macros expand into integral expressions that are not equal to an address of any function. The macros define signal handling strategies for std::signal() function. Constant Explanation SIG_DFL default signal handling SIG_IGN signal is ignored See also C documentation for SIG_DFL, SIG_IGN

Defined in header <csignal> #define SIGTERM /*implementation defined*/ #define SIGSEGV /*implementation defined*/ #define SIGINT /*implementation defined*/ #define SIGILL /*implementation defined*/ #define SIGABRT /*implementation defined*/ #define SIGFPE /*implementation defined*/ Each of the above macro constants expands to an integer constant expression with distinct values, which represent different signals sent to the program. Constant

Usage signed type modifier

Usage short type modifier

This header is part of the thread support library. Classes shared_mutex (C++17) provides shared mutual exclusion facility (class) shared_timed_mutex (C++14) provides shared mutual exclusion facility (class) shared_lock (C++14) implements movable shared mutex ownership wrapper (class template) Functions std::swap(std::shared_lock) specialization of std::swap for shared_lock (function template) Synopsis namespace std { class shared_mutex; class shar

The SharedTimedMutex concept extends the TimedMutex concept to include shared lock ownership mode. Requirements TimedMutex SharedMutex Additionally, for object m of SharedTimedMutex type supports timed shared operations: The expression m.try_lock_shared_for(duration) has the following properties Behaves as an atomic operation. Attempts to obtain shared ownership of the mutex within the duration specified by duration. If duration is less or equal duration.zero(), attempts to obtain

The SharedMutex concept extends the Mutex concept to include shared lock ownership mode. Requirements Mutex Additionally, for object m of SharedMutex type supports another mode of ownership: shared. Multiple threads (or, more generally, execution agents) can simulataneously own this mutex in shared mode, but no thread may obtain shared ownership if there is a thread that owns it in exclusive mode and no thread may obtain exclusive ownership if there is a thread that owns it in shared mode

"Substitution Failure Is Not An Error" This rule applies during overload resolution of function templates: When substituting the deduced type for the template parameter fails, the specialization is discarded from the overload set instead of causing a compile error. This feature is used in template metaprogramming. Explanation Function template parameters are substituted (replaced by template arguments) twice: explicitly specified template arguments are substituted before template argument

Defined in header <csetjmp> #define setjmp(env) /* implementation-defined */ Saves the current execution context into a variable env of type std::jmp_buf. This variable can later be used to restore the current execution context by std::longjmp function. That is, when a call to std::longjmp function is made, the execution continues at the particular call site that constructed the std::jmp_buf variable passed to std::longjmp. In that case setjmp returns the value passed to st

This header is part of the containers library. Includes <initializer_list> (C++11) Classes set collection of unique keys, sorted by keys (class template) multiset collection of keys, sorted by keys (class template) Functions operator==operator!=operator<operator<=operator>operator>= lexicographically compares the values in the set (function template) std::swap(std::set) specializes the std::swap algorithm (function template) operator==opera