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

From cppreference.com
< cpp‎ | header

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_code`s (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_condition`s and `error_code`s (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;
      };
    }

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/system_error&oldid=164377"