<stdexcept>


Include the standard header <stdexcept> to define several classes used for reporting exceptions. The classes form a derivation hierarchy, as indicated by the indenting above, all derived from class exception.

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;
}  // namespace std

domain_error

class domain_error : public logic_error {
public:
    explicit domain_error(const string& message);
    explicit domain_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report a domain error. The value returned by what() is a copy of message.data().

invalid_argument

class invalid_argument : public logic_error {
public:
    explicit invalid_argument(const string& message);
    explicit invalid_argument(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report an invalid argument. The value returned by what() is a copy of message.data().

length_error

class length_error : public logic_error {
public:
    explicit length_error(const string& message);
    explicit length_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report an attempt to generate an object too long to be specified. The value returned by what() is a copy of message.data().

logic_error

class logic_error : public exception {
public:
    explicit logic_error(const string& message);
    explicit logic_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report errors presumably detectable before the program executes, such as violations of logical preconditions. The value returned by what() is a copy of message.data().

out_of_range

class out_of_range : public logic_error {
public:
    explicit out_of_range(const string& message);
    explicit out_of_range(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report an argument that is out of its valid range. The value returned by what() is a copy of message.data().

overflow_error

class overflow_error : public runtime_error {
public:
    explicit overflow_error(const string& message);
    explicit overflow_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report an arithmetic overflow. The value returned by what() is a copy of message.data().

range_error

class range_error : public runtime_error {
public:
    explicit range_error(const string& message);
    explicit range_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report a range error. The value returned by what() is a copy of message.data().

runtime_error

class runtime_error : public exception {
public:
    explicit runtime_error(const string& message);
    explicit runtime_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report errors presumably detectable only when the program executes. The value returned by what() is a copy of message.data().

underflow_error

class underflow_error : public runtime_error {
public:
    explicit underflow_error(const string& message);
    explicit underflow_error(const char *message); [added with C++11]
    };

The class serves as the base class for all exceptions thrown to report an arithmetic underflow. The value returned by what() is a copy of message.data().


See also the Table of Contents and the Index.

Copyright © 1992-2013 by P.J. Plauger. All rights reserved.