All data types may be thrown as exceptions. Several additional exception
classes are now defined by the bf(C++) standard. Before using those additional
exception classes the tthi(stdexcept) header file must be included.

All of these emi(standard exceptions)
  hi(exception: standard) are class types by themselves, but also offer
all facilities of the hi(exception class) tt(std::exception) class and objects
of the standard exception classes may also be considered objects of the
tt(std::exception) class.

The tt(std::exception) class offers the member
        verb(    char const *what() const;)

hi(what) describing in a short textual message the nature of the
exception.

    bf(C++) defines the following standard exception classes:
    itemization(
    itht(bad_alloc)(std::bad_alloc) (this requires the tthi(new) header file):
        thrown when ti(operator new) fails;
    itht(bad_array_new_length)(std::bad_array_new_length) (this requires the 
        tthi(new) header file): thrown when an illegal array size is requested
        when using tt(new Type[...]). Illegal sizes are negative values,
        values that exceed an implementation defined maximum, the number of
        initializer clauses exceeds the specified number of array elements
        (e.g., tt(new int[2]{ 1, 2, 3 }));
    itht(bad_cast)(std::bad_cast) (this requires the tthi(typeinfo) header
        file): thrown in the context of em(polymorphism)
        (see section ref(DYNAMICCAST));
    itht(bad_exception)(std::bad_exception) (this requires the 
        tthi(exception) header file): thrown when a function tries to
        generate another type of exception than declared in its
        hi(throw list)i(function throw list);
    itht(bad_typeid)(std::bad_typeid) (this requires the tthi(typeinfo) header
        file): also thrown in the context of
        em(polymorphism) (see section ref(TYPEID));
    )

All additional exception classes were derived from tt(std::exception). The
constructors of all these additional classes accept tt(std::string const &)
arguments summarizing the reason for the exception (retrieved by the
tt(exception::what) member).  The additionally defined exception classes are:
    itemization(
    itht(domain_error)(std::domain_error): a (mathematical) domain error is
detected;
    itht(invalid_argument)(std::invalid_argument): the argument of a function
has an invalid value;
    itht(length_error)(std::length_error): thrown when an object would have
exceeded its maximum permitted length;
    itht(logic_error)(std::logic_error): a logic error should be thrown when a
problem is detected in the internal logic of the program. Example: a function
like bf(C)'s tt(printf) is called with more arguments than there are format
specifiers in its format string;
    itht(out_of_range)(std::out_of_range): thrown when an argument exceeds its
permitted range. Example: thrown by tt(at) members when their arguments exceed
the range of admissible index values;
    itht(overflow_error)(std::overflow_error): an overflow error should be
thrown when an arithmetic overflow is detected. Example: dividing a
value by a very small value;
    itht(range_error)(std::range_error): a range error should be thrown when
an internal computation results in a value exceeding a permissible range;
    itht(runtime_error)(std::runtime_error): a runtime error should be thrown
when a problem is encountered that can only be detected while the program is
being executed.  Example: a non-integral is entered when the program's input
expects an integral value.
    itht(underflow_error)(std::underflow_error): an underflow error should be
thrown when an arithmetic underflow is detected. Example: dividing a very
small value by a very large value.
    itht(tx_exception)(std::tx_exception<Type>): derived from
tt(std::runtime_error). This exception can be thrown from an tt(atomic_cancel)
compound statement (cf. section ref(TRANSMEM)) to undo statements executed so
far. 
    )
