______________________________________________________________________
19 Diagnostics library [lib.diagnostics]
______________________________________________________________________
1 This clause describes components that C++ programs may use to detect
and report error conditions.
2 The following subclauses describe components for reporting several
kinds of exceptional conditions, documenting program assertions, and a
global variable for error number codes, as summarized in Table 1:
Table 1--Diagnostics library summary
+-----------------------------------------------------+
| Subclause Header(s) |
+-----------------------------------------------------+
|_lib.std.exceptions_ Exception classes <stdexcept> |
+-----------------------------------------------------+
|_lib.assertions_ Assertions <cassert> |
+-----------------------------------------------------+
|_lib.errno_ Error numbers <cerrno> |
+-----------------------------------------------------+
19.1 Exception classes [lib.std.exceptions]
1 The Standard C++ library provides classes to be used to report errors
in C++ programs. In the error model reflected in these classes,
errors are divided into two broad categories: logic errors and runtime
errors.
2 The distinguishing characteristic of logic errors is that they are due
to errors in the internal logic of the program. In theory, they are
preventable.
3 By contrast, runtime errors are due to events beyond the scope of the
program. They cannot be easily predicted in advance. The header
<stdexcept> defines several types of predefined exceptions for report
ing errors in a C++ program. These exceptions are related via inheri
tance.
Header <stdexcept> synopsis
#include <string>
namespace std {
class exception;
class logic_error;
class domain_error;
class invalid_argument;
class length_error;
class out_of_range;
class runtime_error;
class range_error;
class overflow_error;
}
19.1.1 Class exception [lib.exception]
namespace std {
class exception {
public:
exception() throw();
exception& exception(const exception&) throw();
exception& operator=(const exception&) throw();
virtual ~exception() throw();
virtual const char* what() const throw();
};
}
1 The class exception defines the base class for the types of objects
thrown as exceptions by C++ Standard library components, and certain
expressions, to report errors detected during program execution.
exception() throw();
Effects:
Constructs an object of class exception.
Notes:
Does not throw any exceptions.
exception& exception(const exception&) throw();
exception& operator=(const exception&) throw();
Effects:
Copies an exception object.
Notes:
The effects of calling what() after assignment are implementation-
defined.
virtual ~exception() throw();
Effects:
Destroys an object of class exception.
Notes:
Does not throw any exceptions.
virtual const char* what() const throw();
Returns:
An implementation-defined NTBS.
Notes:
The message may be a null-terminated multibyte string
(_lib.multibyte.strings_), suitable for conversion and display as a
wstring (_lib.wstring_, _lib.locale.codecvt_)
19.1.2 Class logic_error [lib.logic.error]
namespace std {
class logic_error : public exception {
public:
logic_error(const string& what_arg);
};
}
1 The class logic_error defines the type of objects thrown as exceptions
to report errors presumably detectable before the program executes,
such as violations of logical preconditions or class invariants.
logic_error(const string& what_arg);
Effects:
Constructs an object of class logic_error.
Postcondition:
what() == what_arg.data().
19.1.3 Class domain_error [lib.domain.error]
namespace std {
class domain_error : public logic_error {
public:
domain_error(const string& what_arg);
};
}
1 The class domain_error defines the type of objects thrown as excep
tions by the implementation to report domain errors.
domain_error(const string& what_arg);
Effects:
Constructs an object of class domain_error.
Postcondition:
what() == what_arg.data().
19.1.4 Class invalid_argument [lib.invalid.argument]
namespace std {
class invalid_argument : public logic_error {
public:
invalid_argument(const string& what_arg);
};
}
1 The class invalid_argument defines the type of objects thrown as
exceptions to report an invalid argument.
invalid_argument(const string& what_arg);
Effects:
Constructs an object of class invalid_argument.
Postcondition:
what() == what_arg.data().
19.1.5 Class length_error [lib.length.error]
namespace std {
class length_error : public logic_error {
public:
length_error(const string& what_arg);
};
}
1 The class length_error defines the type of objects thrown as excep
tions to report an attempt to produce an object whose length equals or
exceeds its maximum allowable size.
length_error(const string& what_arg);
Effects:
Constructs an object of class length_error.
Postcondition:
what() == what_arg.data().
19.1.6 Class out_of_range [lib.out.of.range]
namespace std {
class out_of_range : public logic_error {
public:
out_of_range(const string& what_arg);
};
}
1 The class out_of_range defines the type of objects thrown as excep
tions to report an argument value not in its expected range.
out_of_range(const string& what_arg);
Effects:
Constructs an object of class out_of_range.
Postcondition:
what() == what_arg.data().
19.1.7 Class runtime_error [lib.runtime.error]
namespace std {
class runtime_error : public exception {
public:
runtime_error(const string& what_arg);
};
}
1 The class runtime_error defines the type of objects thrown as excep
tions to report errors presumably detectable only when the program
executes.
runtime_error(const string& what_arg);
Effects:
Constructs an object of class runtime_error.
Postcondition:
what() == what_arg.data().
19.1.8 Class range_error [lib.range.error]
namespae std {
class range_error : public runtime_error {
public:
range_error(const string& what_arg);
};
}
1 The class range_error defines the type of objects thrown as exceptions
to report range errors.
range_error(const string& what_arg);
Effects:
Constructs an object of class range_error.
Postcondition:
what() == what_arg.data().
19.1.9 Class overflow_error [lib.overflow.error]
namespace std {
class overflow_error : public runtime_error {
public:
overflow_error(const string& what_arg);
};
}
1 The class overflow_error defines the type of objects thrown as excep
tions to report an arithmetic overflow error.
overflow_error(const string& what_arg);
Effects:
Constructs an object of class overflow_error.
Postcondition:
what() == what_arg.data().
19.2 Assertions [lib.assertions]
1 Provides macros for documenting C++ program assertions, and for dis
abling the assertion checks.
2 Header <cassert> (Table 2):
Table 2--Header <cassert> synopsis
+--------------------+
| Type Name(s) |
+--------------------+
|Macro: assert |
+--------------------+
3 The contents are the same as the Standard C library.
SEE ALSO: ISO C subclause 7.2.
19.3 Error numbers [lib.errno]
1 Header <cerrno> (Table 3):
Table 3--Header <cerrno> synopsis
+--------------------------------+
| Type Name(s) |
+--------------------------------+
|Macros: EDOM ERANGE errno |
+--------------------------------+
2 The contents are the same as the Standard C library.
SEE ALSO: ISO C subclause 7.1.4, 7.2, Amendment 1 subclause 4.3.