## exception

    Standard Exception

- Summary
- Data Type and Member Function Indexes
- Synopsis
- Description
- Interface
- Constructors
- Destructors
- Operators
- Member Functions
- Constructors for Derived Classes
- Example

### Summary

A class that supports logic and runtime errors.

### Data Type and Member Function Indexes
(exclusive of constructors and destructors)

Member Functions
operator=() what()

### Synopsis

    #include <exception>
    class exception;

### Description

The class exception defines the base class for the types of objects thrown as exceptions by Standard C++ Library components and some expressions. This class is used to report errors detected during program execution. Users can also use these exceptions to report errors in their own programs.

### Interface

    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:
         explicit logic_error (const string& what_arg);
     };

     class domain_error : public logic_error {
       public:
         explicit domain_error (const string& what_arg);
     };

     class invalid_argument : public logic_error {
       public:
         explicit invalid_argument (const string& what_arg);
     };

     class length_error : public logic_error {
       public:
         explicit length_error (const string& what_arg);
     };

     class out_of_range : public logic_error {
       public:
         explicit out_of_range (const string& what_arg);
     };

     class runtime_error : public exception {
       public:
         explicit runtime_error (const string& what_arg);
     };

     class range_error : public runtime_error {
       public:
         explicit range_error (const string& what_arg);
     };

     class overflow_error : public runtime_error {
       public:
         explicit overflow_error (const string& what_arg);
     };

     class underflow_error : public runtime_error {
       public:
         explicit underflow_error (const string& what_arg);
     };

### Constructors

    exception()
    throw();

Constructs an object of class exception.

    exception(const exception&)
    throw();

Copies an `exception` object.

### Destructors

    virtual
    ~exception()
    throw();

Destroys an object of class exception.

### Operators

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

Copies an `exception` object.

### Member Functions

    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`.

### Constructors for Derived Classes

    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`.

    underflow_error::underflow_error(
                        const string& what_arg);

Constructs an object of class `underflow_error`.

### Example

      //
      // except.cpp
      //
      #include <iostream>
      #include <stdexcept>
      using namespace std;

      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;
      }

Copyright (c) 1998, Rogue Wave Software, Inc.
Send mail to report errors or comment on the documentation.
OEM Release, June 1998