• 1Parameters
• 2Return value
• 3Signal handler
• 4Notes
• 5Example
• 6References
• 7Defect reports
• 8See also

• SIG_DFL macro. The signal handler is set to default signal handler.
• SIG_IGN macro. The signal is ignored.
• A pointer to a function. The signature of the function must be equivalent to the following:

If the signal handler is called NOT as a result ofstd::abort orstd::raise (asynchronous signal), the behavior is undefined if

• the signal handler calls any function within the standard library, except

• std::abort
• std::_Exit
• std::quick_exit
• std::signal with the first argument being the number of the signal currently handled (async handler can re-register itself, but not other signals).

• the signal handler refers to any object with static storage duration that is notstd::atomic or(since C++11)volatilestd::sig_atomic_t.

Aplain lock-free atomic operation is an invocation of a functionf from<atomic> or<stdatomic.h>(since C++23), such that:

• f is the functionstd::atomic_is_lock_free,
• f is the member functionis_lock_free (e.g.std::atomic::is_lock_free()),
• f is a non-static member function ofstd::atomic_flag,
• f is a non-member function, and the first parameter off has typecvstd::atomic_flag*,
• f is a non-static member function invoked on an objectobj, such thatobj.is_lock_free() yieldstrue, or
• f is a non-member function, and for every pointer-to-atomic argumentarg passed tof,std::atomic_is_lock_free(arg) yieldstrue.

The behavior is undefined if any signal handler performs any of the following:

• call to any library function, except for plain lock-free atomic operations and the followingsignal-safe functions (note, in particular, dynamic allocation is not signal-safe):

• std::signal with the first argument being the number of the signal currently handled (signal handler can re-register itself, but not other signals).
• member functions ofstd::numeric_limits
• std::_Exit
• std::abort
• std::quick_exit
• The member functions ofstd::initializer_list and thestd::initializer_list overloads ofstd::begin andstd::end
• std::forward,std::move,std::move_if_noexcept
• All functions from<type_traits>
• std::memcpy andstd::memmove

• access to an object with thread storage duration
• adynamic_cast expression
• athrow expression
• entry to atry block
• initialization of a static variable that performsdynamic non-local initialization (including delayed until first ODR-use)
• waits for completion of initialization of any variable with static storage duration due to another thread concurrently initializing it

On entry to the signal handler, the state of thefloating-point environment and the values of all objects is unspecified, except for

• objects of typevolatilestd::sig_atomic_t

On return from a signal handler, the value of any object modified by the signal handler that is notvolatilestd::sig_atomic_t or lock-freestd::atomic is indeterminate.

A call to the functionsignal()synchronizes-with any resulting invocation of the signal handler.

If a signal handler is executed as a result of a call tostd::raise (synchronously), then the execution of the handler issequenced-after the invocation ofstd::raise andsequenced-before the return from it and runs on the same thread asstd::raise. Execution of the handlers for other signals isunsequenced with respect to the rest of the program and runs on an unspecified thread.

Two accesses to the same object of typevolatilestd::sig_atomic_t do not result in a data race if both occur in the same thread, even if one or more occurs in a signal handler. For each signal handler invocation, evaluations performed by the thread invoking a signal handler can be divided into two groups A and B, such that no evaluations in Bhappen-before evaluations in A, and the evaluations of suchvolatilestd::sig_atomic_t objects take values as though all evaluations in Ahappened-before the execution of the signal handler and the execution of the signal handlerhappened-before all evaluations in B.