The class tt(std::system_error)hi(system_error) is derived from
tt(std::runtime_error). 

    hi(error_code: required header)
    hi(error_category: required header)
    hi(error_condition: required header)
Before using the class tt(system_error) or related classes the
tthi(system_error) header file must be included.

tt(System_error) objects can be thrown when errors are encountered having
associated (system) em(error values). Such errors are typically associated
with low-level (like operating system) functions, but other types of errors
(e.g., bad user input, non-existing requests) can also be handled. 

Error codes are objects storing error values and matching categories. Such
categories define domains to which error codes belong. In practice this means
that an enum is associated with a series of error codes, and that a unique
em(category) is associated with such an enum. New enums and associated
categories may be defined, and enum symbols and values may be identical across
different enums. To avoid confusion their categories can be used, like name
spaces. One reason for using categories is that enums don't support
inheritance: inside tt(error_code) objects they are stored as tt(int) values,
losing their original enum classes.

In addition to error codes and error categories error em(conditions) are
distinguished. Error conditions are associated with `higher level' errors
causes, like bad user input, failing system functions or non-existing
requests. Error conditions are also considered platform independent (as in:
users provide bad input on all kinds of platforms) whereas error codes and
error categories are tailored to specific programs and library functions.

When constructing tt(system_error) objects tt(error_codes) and
tt(error_categories) may be specified. These latter two classes as well as
tt(error_condition) are now introduced, after which tt(system_error) itself is
covered in more detail.

Figure ref(SYSERRFIG) illustrates how the various components interact.

    figure(exceptions/systemerror)
        (System_error: associated components)
        (SYSERRFIG)

As tt(system_error) is eventually derived from tt(exception) it offers the
standard tt(what) member. A second data element is an
tt(error_code). tt(Error_codes) can be constructed from tt(int) values, but
also from separately defined error code enumerations. Since tt(error_codes)
are associated with tt(error_categories) a matching tt(error_category) must be
provided when tt(int) error values are available.

In POSIX systems the tt(errno) variable may be associated with many, often
rather cryptic, symbols. The predefined tt(enum class errc) is an attempt to
use intuitively more appealing symbols instead. Since its symbols are defined
in a strongly typed enumeration, they cannot directly be used when defining a
matching tt(error_code). Instead, a function tt(make_error_code) is available,
converting tt(enum class errc) values to tt(error_code) objects.

Now that the general outline has been presented, it's time to have a closer
look at the various components shown in figure ref(SYSERRFIG).
