exception

     Standard Exception

Classes supporting logic and runtime errors.

Contents

• Synopsis
• Description
• Interface
• Constructors
• Destructor
• Operators
• Member Function
• Constructors for Derived Classes
• Example

 #include <exception>

 class exception;

The class exception defines the base class for the types of objects thrown as exceptions by Standard C++ Library components, and certain expressions, to report errors detected during program execution. User's can also use these exceptions to report errors in their own programs.

class exception {

   public:
     exception () throw();
     exception (const exception&) throw();
     exception& operator= (const exception&) throw();
     virtual ~exception () throw();
     virtual const char* what () const throw();
 };
 class logic_error : public exception {
   public:
     logic_error (const string& what_arg);
 };
 class domain_error : public logic_error {
   public:
     domain_error (const string& what_arg);
 };
 class invalid_argument : public logic_error {
   public:
     invalid_argument (const string& what_arg);
 };
 class length_error : public logic_error {
   public:
     length_error (const string& what_arg);
 };
 class out_of_range : public logic_error {
   public:
     out_of_range (const string& what_arg);
 };
 class runtime_error : public exception {
   public:
     runtime_error (const string& what_arg);
 };
class range_error : public runtime_error {
   public:
     range_error (const string& what_arg);
 };
 class overflow_error : public runtime_error {
   public:
     overflow_error (const string& what_arg);
 };

exception () throw();

Constructs an object of class exception.

exception (const exception&) throw();

The copy constructor. Copies an exception object.

virtual 
~exception() throw();

Destroys an object of class exception.

exception& 
operator= (const exception&) throw();

The assignment operator. Copies an exception object.

virtual const char* 
what()const throw();

Returns an implementation-defined, null-terminated byte string representing a human-readable message describing the exception. The message may be a null-terminated multibyte string, suitable for conversion and display as a wstring.

logic_error::logic_error (const string& what_arg);

Constructs an object of class logic_error.

domain_error::domain_error (const string& what_arg);

Constructs an object of class domain_error.

invalid_argument::invalid_argument (const string& what_arg);

Constructs an object of class invalid_argument.

length_error::length_error (const string& what_arg);

Constructs an object of class length_error.

out_of_range::out_of_range (const string& what_arg);

Constructs an object of class out_of_range.

runtime_error::runtime_error (const string& what_arg);

Constructs an object of class runtime_error.

range_error::range_error (const string& what_arg);

Constructs an object of class range_error.

overflow_error::overflow_error (const string& what_arg);

Constructs an object of class overflow_error.

  //
  // exception.cpp
  //
  #include <iostream.h>
  #include <stdexcept>
  static void f() { throw runtime_error("a runtime error"); }
  int main ()
  {
     //
     // By wrapping the body of main in a try-catch block we can
     // be assured that we'll catch all exceptions in the
     // exception hierarchy.  You can simply catch exception as is
     // done below, or you can catch each of the exceptions in
     // which you have an interest.
     //
     try
     {
         f();
     }
     catch (const exception& e)
     {
         cout << "Got an exception: " << e.what() << endl;
     }
     return 0;
  }