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 {};
 
  enum class 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 functions
  bool 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 support
  template<class T> struct hash;
  template<> struct hash<error_code>;
  template<> struct hash<error_condition>;
 
  / system error support
  template<class T>
    inline constexpr bool is_error_code_enum_v = is_error_code_enum<T>::value;
  template<class T>
    inline constexpr bool 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;
    virtual const char* name() const noexcept = 0;
    virtual error_condition default_error_condition(int ev) const noexcept;
    virtual bool equivalent(int code, const error_condition& condition) const noexcept;
    virtual bool equivalent(const error_code& code, int condition) const noexcept;
    virtual string message(int ev) const = 0;
 
    bool operator==(const error_category& rhs) const noexcept;
    strong_ordering operator<=>(const error_category& rhs) const noexcept;
  };
 
  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;
 
    / modifiers
    void assign(int val, const error_category& cat) noexcept;
    template<class ErrorCodeEnum>
      error_code& operator=(ErrorCodeEnum e) noexcept;
    void clear() noexcept;
 
    / observers
    int value() const noexcept;
    const error_category& category() const noexcept;
    error_condition default_error_condition() const noexcept;
    string message() const;
    explicit operator bool() const noexcept;
 
  private:
    int val_;                   / exposition only
    const 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;
 
    / modifiers
    void assign(int val, const error_category& cat) noexcept;
    template<class ErrorConditionEnum>
      error_condition& operator=(ErrorConditionEnum e) noexcept;
    void clear() noexcept;
 
    / observers
    int value() const noexcept;
    const error_category& category() const noexcept;
    string message() const;
    explicit operator bool() const noexcept;
 
  private:
    int val_;                   / exposition only
    const 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, const char* 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, const char* what_arg);
    system_error(int ev, const error_category& ecat);
    const error_code& code() const noexcept;
    const char* what() const noexcept override;
  };
}

Follow Lee on X/Twitter - Father, Husband, Serial builder creating AI, crypto, games & web tools. We are friends :) AI Will Come To Life!

Check out: eBank.nz (Art Generator) | Netwrck.com (AI Tools) | Text-Generator.io (AI API) | BitBank.nz (Crypto AI) | ReadingTime (Kids Reading) | RewordGame | BigMultiplayerChess | WebFiddle | How.nz | Helix AI Assistant