19 Diagnostics library [diagnostics]

19.2 Exception classes [std.exceptions]

1
#
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.
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 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);
  };
}
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);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
logic_error(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
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);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
domain_error(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
The class invalid_­argument defines the type of objects thrown as exceptions to report an invalid argument.
🔗
invalid_argument(const string& what_arg);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
invalid_argument(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
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);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
length_error(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
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);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
out_of_range(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
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);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
runtime_error(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
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);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
range_error(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
The class overflow_­error defines the type of objects thrown as exceptions to report an arithmetic overflow error.
🔗
overflow_error(const string& what_arg);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
overflow_error(const char* what_arg);
3
#
Postconditions: 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);
  };
}
1
#
The class underflow_­error defines the type of objects thrown as exceptions to report an arithmetic underflow error.
🔗
underflow_error(const string& what_arg);
2
#
Postconditions: strcmp(what(), what_­arg.c_­str()) == 0.
🔗
underflow_error(const char* what_arg);
3
#
Postconditions: strcmp(what(), what_­arg) == 0.