stdexcept(3C++)


stdexcept -- exception classes

Synopsis

   #include <stdexcept> 
   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; 
   } 

Description

The C++ Standard Library provides classes to be used to report certain errors 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. stdexcept defines several types of predefined exceptions for reporting errors in a C++ program. These exceptions are related via inheritance.

Classes

logic_error
   namespace std { 
     class logic_error : public exception { 
     public: 
       logic_error(const string& 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); 
Effects: Constructs an object of class logic_error.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

domain_error
   namespace std { 
     class domain_error : public logic_error { 
     public: 
       domain_error(const string& what_arg); 
     }; 
   } 
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:
     strcmp(what(), what_arg.c_str()) == 0. 

invalid_argument
   namespace std { 
     class invalid_argument : public logic_error { 
     public: 
       invalid_argument(const string& 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); 
Effects: Constructs an object of class invalid_argument.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

length_error
   namespace std { 
     class length_error : public logic_error { 
     public: 
       length_error(const string& 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); 
Effects: Constructs an object of class length_error.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

out_of_range
   namespace std { 
     class out_of_range : public logic_error { 
     public: 
       out_of_range(const string& 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); 
Effects: Constructs an object of class out_of_range.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

runtime_error
   namespace std { 
     class runtime_error : public exception { 
     public: 
       runtime_error(const string& 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); 
Effects: Constructs an object of class runtime_error.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

range_error
   namespace std { 
     class range_error : public runtime_error { 
     public: 
       range_error(const string& 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); 
Effects: Constructs an object of class range_error.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

overflow_error
   namespace std { 
     class overflow_error : public runtime_error { 
     public: 
       overflow_error(const string& 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); 
Effects: Constructs an object of class overflow_error.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

underflow_error
   namespace std { 
     class underflow_error : public runtime_error { 
     public: 
       underflow_error(const string& 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); 
Effects: Constructs an object of class underflow_error.
Postcondition:
     strcmp(what(), what_arg.c_str()) == 0. 

30 January 1998
© 1998 The Santa Cruz Operation, Inc. All rights reserved.