# std::errc

> C++ Atlas: `cppatlas.com/w/cpp/error/errc` | Source: https://en.cppreference.com/w/cpp/error/errc | Domain: Diagnostics | Standards: C++11

The scoped enumeration std::errc defines the values of portable error conditions that correspond to the POSIX error codes.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <system_error>
enum class errc; // (since C++11)
```

The scoped enumeration `std::errc` defines the values of portable error conditions that correspond to the POSIX error codes.

### Member constants

**Name — Equivalent POSIX Error**

- `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` (deprecated): `ENODATA`
- `no_message`: `ENOMSG`
- `no_protocol_option`: `ENOPROTOOPT`
- `no_space_on_device`: `ENOSPC`
- `no_stream_resources` (deprecated): `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` (deprecated): `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` (deprecated): `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`

### Non-member functions

- `make_error_code(std::errc)` (C++11): creates error code value for `errc` enum `e` (function)
- `make_error_condition(std::errc)` (C++11): creates an error condition for an `errc` value `e` (function)

### Helper classes

- `is_error_condition_enum<std::errc>` (C++11): extends the type trait `std::is_error_condition_enum` to identify `errc` values as error conditions (function template)

### Example

```cpp
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
#include <system_error>
#include <thread>

void print_error(const std::string& details, std::error_code error_code)
{
    std::string value_name;
    if (error_code == std::errc::invalid_argument)
        value_name = "std::errc::invalid_argument";
    if (error_code == std::errc::no_such_file_or_directory)
        value_name = "std::errc::no_such_file_or_directory";
    if (error_code == std::errc::is_a_directory)
        value_name = "std::errc::is_a_directory";
    if (error_code == std::errc::permission_denied)
        value_name = "std::errc::permission_denied";

    std::cout << details << ":\n  "
              << std::quoted(error_code.message())
              << " (" << value_name << ")\n\n";
}

void print_errno(const std::string& details, int errno_value = errno)
{
    print_error(details, std::make_error_code(std::errc(errno_value)));
}

int main()
{
    std::cout << "Detaching a not-a-thread...\n";
    try
    {
        std::thread().detach();
    }
    catch (const std::system_error& e)
    {
        print_error("Error detaching empty thread", e.code());
    }

    std::cout << "Opening nonexistent file...\n";
    std::ifstream nofile{"nonexistent-file"};
    if (!nofile.is_open())
        print_errno("Error opening nonexistent file for reading");

    std::cout << "Reading from directory as a file...\n";
    std::filesystem::create_directory("dir");
    std::ifstream dir_stream{"dir"};
    [[maybe_unused]] char c = dir_stream.get();
    if (!dir_stream.good())
        print_errno("Error reading data from directory");

    std::cout << "Open read-only file for writing...\n";
    std::fstream{"readonly-file", std::ios::out};
    std::filesystem::permissions("readonly-file", std::filesystem::perms::owner_read);
    std::fstream write_readonly("readonly-file", std::ios::out);
    if (!write_readonly.is_open())
        print_errno("Error opening read-only file for writing");
}
```

Possible output:

```text
Detaching a not-a-thread...
Error detaching empty thread:
  "Invalid argument" (std::errc::invalid_argument)

Opening nonexistent file...
Error opening nonexistent file for reading:
  "No such file or directory" (std::errc::no_such_file_or_directory)

Reading from directory as a file...
Error reading data from directory:
  "Is a directory" (std::errc::is_a_directory)

Open read-only file for writing...
Error opening read-only file for writing:
  "Permission denied" (std::errc::permission_denied)
```

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| LWG 3869 | C++11 | the member constants `no_message_available`, `no_stream_resources`, `not_a_stream` and `stream_timeout` referred to the obsolete POSIX STREAMS API[1] | deprecated them |

1. ↑ Although the corresponding POSIX error numbers ENODATA, ENOSR, ENOSTR and ETIME were marked "obsolescent" in POSIX 2017, the STREAMS API was optional and not required for conformance to the previous POSIX standard (because popular unix-like systems refused to implement it).

### See also

- [`error_code`](https://en.cppreference.com/w/cpp/error/error_code) (C++11): holds a platform-dependent error code (class)
- [`error_condition`](https://en.cppreference.com/w/cpp/error/error_condition) (C++11): holds a portable error code (class)

---
Attribution: content from https://en.cppreference.com/w/cpp/error/errc (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.