19 Diagnostics library [diagnostics]

19.2 Exception classes [std.exceptions]

The C++ standard library provides classes to be used to report certain errors ([res.on.exception.handling]) in C++ programs.
In the error model reflected in these classes, errors are divided into two broad categories: logic errors and runtime errors.
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.
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 reporting errors in a C++ program.
These exceptions are related by inheritance.

19.2.1 Header <stdexcept> synopsis [stdexcept.syn]

namespace std {
  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;
    class underflow_error;
}

19.2.2 Class logic_­error [logic.error]

namespace std {
  class logic_error : public exception {
  public:
    explicit logic_error(const string& what_arg);
    explicit logic_error(const char* what_arg);
  };
}
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);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
logic_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.3 Class domain_­error [domain.error]

namespace std {
  class domain_error : public logic_error {
  public:
    explicit domain_error(const string& what_arg);
    explicit domain_error(const char* what_arg);
  };
}
The class domain_­error defines the type of objects thrown as exceptions by the implementation to report domain errors.
domain_error(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
domain_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.4 Class invalid_­argument [invalid.argument]

namespace std {
  class invalid_argument : public logic_error {
  public:
    explicit invalid_argument(const string& what_arg);
    explicit invalid_argument(const char* what_arg);
  };
}
The class invalid_­argument defines the type of objects thrown as exceptions to report an invalid argument.
invalid_argument(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
invalid_argument(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.5 Class length_­error [length.error]

namespace std {
  class length_error : public logic_error {
  public:
    explicit length_error(const string& what_arg);
    explicit length_error(const char* what_arg);
  };
}
The class length_­error defines the type of objects thrown as exceptions to report an attempt to produce an object whose length exceeds its maximum allowable size.
length_error(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
length_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.6 Class out_­of_­range [out.of.range]

namespace std {
  class out_of_range : public logic_error {
  public:
    explicit out_of_range(const string& what_arg);
    explicit out_of_range(const char* what_arg);
  };
}
The class out_­of_­range defines the type of objects thrown as exceptions to report an argument value not in its expected range.
out_of_range(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
out_of_range(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.7 Class runtime_­error [runtime.error]

namespace std {
  class runtime_error : public exception {
  public:
    explicit runtime_error(const string& what_arg);
    explicit runtime_error(const char* what_arg);
  };
}
The class runtime_­error defines the type of objects thrown as exceptions to report errors presumably detectable only when the program executes.
runtime_error(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
runtime_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.8 Class range_­error [range.error]

namespace std {
  class range_error : public runtime_error {
  public:
    explicit range_error(const string& what_arg);
    explicit range_error(const char* what_arg);
  };
}
The class range_­error defines the type of objects thrown as exceptions to report range errors in internal computations.
range_error(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
range_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.9 Class overflow_­error [overflow.error]

namespace std {
  class overflow_error : public runtime_error {
  public:
    explicit overflow_error(const string& what_arg);
    explicit overflow_error(const char* what_arg);
  };
}
The class overflow_­error defines the type of objects thrown as exceptions to report an arithmetic overflow error.
overflow_error(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
overflow_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.

19.2.10 Class underflow_­error [underflow.error]

namespace std {
  class underflow_error : public runtime_error {
  public:
    explicit underflow_error(const string& what_arg);
    explicit underflow_error(const char* what_arg);
  };
}
The class underflow_­error defines the type of objects thrown as exceptions to report an arithmetic underflow error.
underflow_error(const string& what_arg);
Ensures: strcmp(what(), what_­arg.c_­str()) == 0.
underflow_error(const char* what_arg);
Ensures: strcmp(what(), what_­arg) == 0.