`<system_error>`

[added with C++11]

errc · error_code · error_category · error_condition · hash · generic_category · generic_errno · is_error_code_enum · is_error_condition_enum · make_error_code · make_error_condition · system_category · system_error

operator== · operator!=

address_family_not_supported · address_in_use · address_not_available · already_connected · argument_list_too_long · argument_out_of_domain · bad_address · bad_file_descriptor · bad_message · broken_pipe · connection_aborted · connection_already_in_progress · connection_refused · connection_reset · cross_device_link · destination_address_required · device_or_resource_busy · directory_not_empty · executable_format_error · file_exists · file_too_large · filename_too_long · function_not_supported · host_unreachable · identifier_removed · illegal_byte_sequence · inappropriate_io_control_operation · interrupted · invalid_argument · invalid_seek · io_error · is_a_directory · message_size · network_down · network_reset · network_unreachable · no_buffer_space · no_child_process · no_link · no_lock_available · no_message_available · no_message · no_protocol_option · no_space_on_device · no_stream_resources · no_such_device_or_address · no_such_device · no_such_file_or_directory · no_such_process · not_a_directory · not_a_socket · not_a_stream · not_connected · not_enough_memory · not_supported · operation_canceled · operation_in_progress · operation_not_permitted · operation_not_supported · operation_would_block · owner_dead · permission_denied · protocol_error · protocol_not_supported · read_only_file_system · resource_deadlock_would_occur · resource_unavailable_try_again · result_out_of_range · state_not_recoverable · stream_timeout · text_file_busy · timed_out · too_many_files_open_in_system · too_many_files_open · too_many_links · too_many_synbolic_link_levels · value_too_large · wrong_protocol_type

Include the header <system_error> to define the exception class system_error and related templates for processing low-level system errors.

namespace std {
    // TYPES
enum class errc;
typedef errc generic_errno;

class error_code;
class error_condition;
class error_category;
class system_error;

template<Enum>
    class is_error_code_enum;
template<Enum>
    class is_error_condition_enum;

template<>
    struct hash<error_code>
        : public unary_function<bitset<Bits>, size_t> {
    size_t operator()(error_code val) const;
    };
    // FUNCTIONS
const error_category& generic_category() noexcept;
const error_category& system_category() noexcept;

bool operator==(const error_code& left, const error_condition& right) noexcept;
bool operator==(const error_condition& left, const error_code& right) noexcept;
bool operator!=(const error_code& left, const error_condition& right) noexcept;
bool operator!=(const error_condition& left, const error_code& right) noexcept;

error_code make_error_code(generic_errno errval) noexcept;
error_code make_error_condition(generic_errno errval) noexcept;

template<class Elem,
    class Traits>
    basic_ostream<Elem, Traits>&
        operator<<(basic_ostream<Elem, Traits>& ostr,
            const error_code& code);
}  // namespace std

`errc`

enum class errc {
    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_synbolic_link_levels = ELOOP,
    value_too_large = EOVERFLOW,
    wrong_protocol_type = EPROTOTYPE,
    };

The scoped enumeration supplies symbolic names for all the error-code macros defined by Posix in <errno.h>.

`error_category`

class error_category {
public:
    error_category();
    virtual ~error_category() noexcept;

    virtual const char *name() const noexcept = 0;
    virtual string message(int val) const = 0;

    virtual error_condition 
        default_error_condition(int errval) const noexcept;
    virtual bool equivalent(int errval,
        const error_condition& code) const noexcept;
    virtual bool equivalent(const error_code& code,
        int errval) const noexcept;

    bool operator==(const error_category& right) const noexcept;
    bool operator!=(const error_category& right) const noexcept;
    bool operator<(const error_category& right) const noexcept;

    error_category(const error_category&) = delete;
    error_category& operator=(const error_category&) = delete;
    };

The abstract class is the common base for objects that characterize a category of error codes. Two such objects are predefined, one for the generic category and one for the system category.

`error_category::default_error_condition`

virtual error_condition
    default_error_condition(int errval) const noexcept;

The member function returns error_condition(errval, *this). For the system category class, if errval corresponds to a Posix code, the function returns error_condition(errval, generic_category()). Otherwise, it returns error_condition(errval, system_category()).

`error_category::equivalent`

virtual bool equivalent(int errval,
    const error_condition& code) const noexcept;
virtual bool equivalent(const error_code& code,
    int errval) const noexcept;

The member function returns *this == code.category() && code.value() == errval.

`error_category::message`

virtual string message(int val) const = 0;

The virtual function returns a description of the error code val for the category.

`error_category::name`

virtual const char *name() const noexcept = 0;

The virtual function returns the name of the category as an NTBS. For the generic category class, the function returns a pointer to the NTBS "generic". For the system category class, the function returns a pointer to the NTBS "system".

`error_category::operator==`

bool operator==(const error_category& right) const noexcept;

The member operator returns this == &right.

`error_category::operator!=`

bool operator!=(const error_category& right) const noexcept;

The member operator returns (!*this == right).

`error_category::operator<`

bool operator<(const error_category& right) const noexcept;

The member operator returns this < &right.

`error_code`

class error_code {
public:
    error_code() noexcept;
    error_code(int val, const error_category& cat) noexcept;
    template<class Enum>
        error_code(Enum error) noexcept;

    void assign(int val, const error_category& cat) noexcept;
    template<class Enum>
        error_code& operator=(Enum error) noexcept;
    void clear() noexcept;

    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;

    bool operator==(const error_code& right) const noexcept;
    bool operator!=(const error_code& right) const noexcept;
    bool operator<(const error_code& right) const noexcept;
    };

The class stores an error code value and a pointer to an object that characterizes a category of error codes to characterize a reported low-level system error.

`error_code::assign`

void assign(int val, const error_category& cat) noexcept;

The member function stores val as the error code value and a pointer to cat.

`error_code::category`

const error_category& category() const noexcept;

The member function returns a reference to the stored category.

`error_code::clear`

clear() noexcept;

The member function stores a zero error code value and a pointer to the system category.

`error_code::default_error_condition`

error_condition default_error_condition() const noexcept;

The member function returns category(). default_error_condition( value()).

`error_code::error_code`

error_code() noexcept;
error_code(int val, const error_category& cat) noexcept;
template<class Enum>
    error_code(Enum error) noexcept;

The first constructor stores a zero error code value and a pointer to the system category.

The second constructor stores val as the error code value and a pointer to cat.

The third constructor assigns make_error_code(error) to *this. Unless is_error_code_enum<Enum> holds true, the constructor does not participate in overload resolution.

`error_code::message`

string message() const noexcept;

The member function returns category(). message( value()).

`error_code::operator bool`

explicit operator bool() const noexcept;

The operator returns a value convertible to true only if value() != 0. The return type is convertible only to bool, not to void * or other known scalar type.

`error_code::operator=`

template<class Enum>
    error_code& operator=(Enum error) noexcept;

The member operator assigns make_error_code(error) to *this. It returns *this. Unless is_error_code_enum<Enum> holds true, the operator does not participate in overload resolution.

`error_code::operator==`

bool operator==(const error_code& right) const noexcept;

The member operator returns category() == right.category() && value == right.value().

`error_code::operator!=`

bool operator!=(const error_code& right) const noexcept;

The member operator returns !(*this == right).

`error_code::operator<`

bool operator<(const error_code& right) const noexcept;

The member operator returns category() < right.category() || category() == right.category() && value < right.value().

`error_code::value`

int value() const noexcept;

The member function returns the stored error code value.

`error_condition`

class error_condition {
public:
    error_condition() noexcept;
    error_condition(int val, const error_category& cat) noexcept;
    template<class Enum>
        error_condition(Enum error) noexcept;

    void assign(int val, const error_category& cat) noexcept;
    template<class Enum>
        error_condition> operator=(Enum error) noexcept;
    void clear();

    int value() const noexcept;
    const error_category& category() const noexcept;
    string message() const;
    explicit operator bool() const noexcept;

    bool operator==(const error_condition& right) const noexcept;
    bool operator!=(const error_condition& right) const noexcept;
    bool operator<(const error_condition& right) const noexcept;
    };

The class stores an error code value and a pointer to an object that characterizes a category of error codes to characterize a reported user-defined error.

`error_condition::assign`

void assign(int val, const error_category& cat) noexcept;

The member function stores val as the error code value and a pointer to cat.

`error_condition::category`

const error_category& category() const noexcept;

The member function returns a reference to the stored category.

`error_condition::clear`

clear() noexcept;

The member function stores a zero error code value and a pointer to the generic category.

`error_condition::error_condition`

error_condition() noexcept;
error_condition(int val, const error_category& cat) noexcept;
template<class Enum>
    error_condition(Enum error) noexcept;

The first constructor stores a zero error code value and a pointer to the generic category.

The second constructor stores val as the error code value and a pointer to error_category.

The third constructor assigns make_error_code(error) to *this. Unless is_error_condition_enum<Enum> holds true, the constructor does not participate in overload resolution.

`error_condition::message`

string message() const;

The member function returns category(). message( value()).

`error_condition::operator bool`

explicit operator bool() const noexcept;

The operator returns a value convertible to true only if value() != 0. The return type is convertible only to bool, not to void * or other known scalar type.

`error_condition::operator=`

template<class Enum>
    error_condition>::type& operator=(Enum error) noexcept;

The member operator assigns make_error_code(error) to *this. It returns *this. Unless is_error_condition_enum<Enum> holds true, the operator does not participate in overload resolution.

`error_condition::operator==`

bool operator==(const error_condition& right) const noexcept;

The member operator returns category() == right.category() && value == right.value().

`error_condition::operator!=`

bool operator!=(const error_condition& right) const noexcept;

The member operator returns !(*this == right).

`error_condition::operator<`

bool operator<(const error_condition& right) const noexcept;

The member operator returns category() < right.category() || category() == right.category() && value < right.value().

`error_condition::value`

int value() const noexcept;

The member function returns the stored error code value.

`generic_category`

const error_category& generic_category() noexcept;

The function returns a reference to the generic category.

`generic_errno`

typedef errc generic_error;

The type is a synonym for errc.

`hash`

template<>
    struct hash<error_code>
        : public unary_function<bitset<Bits>, size_t> {
    size_t operator()(error_code val) const;
    };

The template class defines its member function as returning a value uniquely determined by val. The member function defines a hash function, suitable for mapping values of type error_code to a distribution of index values.

`is_error_code_enum`

template<Enum>
    class is_error_code_enum;

An instance of the type predicate holds true if the type Enum is an enumeration suitable for storing in an object of type error_code.

It is permissible to add specializations to this type for user-defined types.

`is_error_condition_enum`

template<Enum>
    class is_error_condition_enum;

An instance of the type predicate holds true if the type Enum is an enumeration suitable for storing in an object of type error_condition.

It is permissible to add specializations to this type for user-defined types.

`make_error_code`

error_code make_error_code(generic_errno errval) noexcept;

The function returns error_code(errval, generic_category()).

It is permissible to add specializations to this function for user-defined types.

`make_error_condition`

error_condition make_error_condition(generic_errno errval) noexcept;

The function returns error_condition(errval, generic_category()).

`operator<<`

template<class Elem,
    class Traits>
    basic_ostream<Elem, Traits>&
        operator<<(basic_ostream<Elem, Traits>& ostr,
            const error_code& code);

The template function returns ostr << code.category() << ':' << code.value().

`operator==`

bool operator==(const error_code& left, const error_condition& right) noexcept;
bool operator==(const error_condition& left, const error_code& right) noexcept;

The function returns left.category().equivalent(left.value(), right) || right.category().equivalent(left, right.value()).

`operator!=`

bool operator!=(const error_code& left, const error_condition& right);
bool operator!=(const error_condition& left, const error_code& right);

The function returns !(left == right).

`system_category`

const error_category& system_category() noexcept;

The function returns a reference to the system category.

`system_error`

class system_error : public runtime_error {
public:
    explicit system_error(error_code code, const string& message = "");
    system_error(error_code code, const char *message);
    system_error(int val, const error_category& cat,
        const string& message);
    system_error(int val, const error_category& cat,
        const char *message);

    const error_code& code() const throw();
    };

The class serves as the base class for all exceptions thrown to report a low-level system overflow. The value returned by what() is constructed from message and the stored object of type error_code (either code or error_code(val, cat)).

The member function code() returns the stored error_code object.

See also the Table of Contents and the Index.