Standard library header <system_error> (C++11)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Standard library headers

Language support <cfloat> <climits> <compare>(C++20) <contracts>(C++26) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) Concepts <concepts>(C++20) Diagnostics <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Memory management <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramming <type_traits>(C++11) <ratio>(C++11)

General utilities <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <stdbit.h>(C++26) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Containers <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <hive>(C++26) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iterators <iterator> Ranges <generator>(C++23) <ranges>(C++20)

Algorithms <algorithm> <numeric> Strings <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Text processing <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numerics <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <stdckdint.h>(C++26) <valarray> Time <chrono>(C++11) <ctime> C compatibility <ccomplex>(C++11/17/20*) <ciso646>(until C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Input/output <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) Concurrency support <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) Execution support <execution>(C++17)

 

This header is part of the error handling library.

Includes
<compare> (C++20)	Three-way comparison operator support
Classes
error_category (C++11)	base class for error categories (class)
error_condition (C++11)	holds a portable error code (class)
errc (C++11)	the std::error_condition enumeration listing all standard <cerrno> macro constants (class)
error_code (C++11)	holds a platform-dependent error code (class)
system_error (C++11)	exception class used to report conditions that have an error_code (class)
is_error_code_enum (C++11)	identifies a class as an error_code enumeration (class template)
is_error_condition_enum (C++11)	identifies an enumeration as an std::error_condition (class template)
std::hash<std::error_code> (C++11)	hash support for std::error_code (class template specialization)
Forward declarations
Defined in header <functional>
hash (C++11)	hash function object (class template)
Functions
generic_category (C++11)	identifies the generic error category (function)
system_category (C++11)	identifies the operating system error category (function)
operator==operator!=operator<operator<=> (removed in C++20)(removed in C++20)(C++20)	compares two error_codes (function)
operator<<	outputs the value and the category name to an output stream (function)
make_error_code(std::errc) (C++11)	creates error code value for errc enum e (function)
operator==operator!=operator<operator<=> (removed in C++20)(removed in C++20)(C++20)	compares error_conditions and error_codes (function)
make_error_condition(std::errc) (C++11)	creates an error condition for an errc value e (function)

Synopsis

#include <compare>   namespace std {class error_category;const error_category& generic_category()noexcept;const error_category& system_category()noexcept;   class error_code;class error_condition;class system_error;   template<class T>struct is_error_code_enum :public false_type {};   template<class T>struct is_error_condition_enum :public false_type {};   enumclass errc {// freestanding address_family_not_supported, // EAFNOSUPPORT address_in_use, // EADDRINUSE address_not_available, // EADDRNOTAVAIL already_connected, // EISCONN argument_list_too_long, // E2BIG argument_out_of_domain, // EDOM bad_address, // EFAULT bad_file_descriptor, // EBADF bad_message, // EBADMSG broken_pipe, // EPIPE connection_aborted, // ECONNABORTED connection_already_in_progress, // EALREADY connection_refused, // ECONNREFUSED connection_reset, // ECONNRESET cross_device_link, // EXDEV destination_address_required, // EDESTADDRREQ device_or_resource_busy, // EBUSY directory_not_empty, // ENOTEMPTY executable_format_error, // ENOEXEC file_exists, // EEXIST file_too_large, // EFBIG filename_too_long, // ENAMETOOLONG function_not_supported, // ENOSYS host_unreachable, // EHOSTUNREACH identifier_removed, // EIDRM illegal_byte_sequence, // EILSEQ inappropriate_io_control_operation, // ENOTTY interrupted, // EINTR invalid_argument, // EINVAL invalid_seek, // ESPIPE io_error, // EIO is_a_directory, // EISDIR message_size, // EMSGSIZE network_down, // ENETDOWN network_reset, // ENETRESET network_unreachable, // ENETUNREACH no_buffer_space, // ENOBUFS no_child_process, // ECHILD no_link, // ENOLINK no_lock_available, // ENOLCK no_message_available, // ENODATA no_message, // ENOMSG no_protocol_option, // ENOPROTOOPT no_space_on_device, // ENOSPC no_stream_resources, // ENOSR no_such_device_or_address, // ENXIO no_such_device, // ENODEV no_such_file_or_directory, // ENOENT no_such_process, // ESRCH not_a_directory, // ENOTDIR not_a_socket, // ENOTSOCK not_a_stream, // ENOSTR not_connected, // ENOTCONN not_enough_memory, // ENOMEM not_supported, // ENOTSUP operation_canceled, // ECANCELED operation_in_progress, // EINPROGRESS operation_not_permitted, // EPERM operation_not_supported, // EOPNOTSUPP operation_would_block, // EWOULDBLOCK owner_dead, // EOWNERDEAD permission_denied, // EACCES protocol_error, // EPROTO protocol_not_supported, // EPROTONOSUPPORT read_only_file_system, // EROFS resource_deadlock_would_occur, // EDEADLK resource_unavailable_try_again, // EAGAIN result_out_of_range, // ERANGE state_not_recoverable, // ENOTRECOVERABLE stream_timeout, // ETIME text_file_busy, // ETXTBSY timed_out, // ETIMEDOUT too_many_files_open_in_system, // ENFILE too_many_files_open, // EMFILE too_many_links, // EMLINK too_many_symbolic_link_levels, // ELOOP value_too_large, // EOVERFLOW wrong_protocol_type, // EPROTOTYPE};   template<>struct is_error_condition_enum<errc>: true_type {};   // non-member functions error_code make_error_code(errc e)noexcept;   template<class CharT, class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const error_code& ec);   // non-member functions error_condition make_error_condition(errc e)noexcept;   // comparison functionsbool operator==(const error_code& lhs, const error_code& rhs)noexcept;bool operator==(const error_code& lhs, const error_condition& rhs)noexcept;bool operator==(const error_condition& lhs, const error_condition& rhs)noexcept; strong_ordering operator<=>(const error_code& lhs, const error_code& rhs)noexcept; strong_ordering operator<=>(const error_condition& lhs, const error_condition& rhs)noexcept;   // hash supporttemplate<class T>struct hash;template<>struct hash<error_code>;template<>struct hash<error_condition>;   // system error supporttemplate<class T>inlineconstexprbool is_error_code_enum_v = is_error_code_enum<T>::value;template<class T>inlineconstexprbool is_error_condition_enum_v = is_error_condition_enum<T>::value;}

Class std::error_category

namespace std {class error_category {public:constexpr error_category()noexcept;virtual ~error_category(); error_category(const error_category&)= delete; error_category& operator=(const error_category&)= delete;virtualconstchar* name()constnoexcept=0;virtual error_condition default_error_condition(int ev)constnoexcept;virtualbool equivalent(int code, const error_condition& condition)constnoexcept;virtualbool equivalent(const error_code& code, int condition)constnoexcept;virtual string message(int ev)const=0;   bool operator==(const error_category& rhs)constnoexcept; strong_ordering operator<=>(const error_category& rhs)constnoexcept;};   const error_category& generic_category()noexcept;const error_category& system_category()noexcept;}

Class std::error_code

namespace std {class error_code {public:// constructors error_code()noexcept; error_code(int val, const error_category& cat)noexcept;template<class ErrorCodeEnum> error_code(ErrorCodeEnum e)noexcept;   // modifiersvoid assign(int val, const error_category& cat)noexcept;template<class ErrorCodeEnum> error_code& operator=(ErrorCodeEnum e)noexcept;void clear()noexcept;   // observersint value()constnoexcept;const error_category& category()constnoexcept; error_condition default_error_condition()constnoexcept; string message()const;explicit operator bool()constnoexcept;   private:int val_;// exposition onlyconst error_category* cat_;// exposition only};   // non-member functions error_code make_error_code(errc e)noexcept;   template<class CharT, class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const error_code& ec);}

Class std::error_condition

namespace std {class error_condition {public:// constructors error_condition()noexcept; error_condition(int val, const error_category& cat)noexcept;template<class ErrorConditionEnum> error_condition(ErrorConditionEnum e)noexcept;   // modifiersvoid assign(int val, const error_category& cat)noexcept;template<class ErrorConditionEnum> error_condition& operator=(ErrorConditionEnum e)noexcept;void clear()noexcept;   // observersint value()constnoexcept;const error_category& category()constnoexcept; string message()const;explicit operator bool()constnoexcept;   private:int val_;// exposition onlyconst error_category* cat_;// exposition only};}

Class std::system_error

namespace std {class system_error :public runtime_error {public: system_error(error_code ec, const string& what_arg); system_error(error_code ec, constchar* what_arg); system_error(error_code ec); system_error(int ev, const error_category& ecat, const string& what_arg); system_error(int ev, const error_category& ecat, constchar* what_arg); system_error(int ev, const error_category& ecat);const error_code& code()constnoexcept;constchar* what()constnoexcept override;};}