классы и обработка исключений

#include <iostream>
 
using namespace std;
 
int main()
{
 
 
    try{
 
        int *a=new int[25];
 
        for(int i=0;i<29;i++)
            a[i]=25;  // Пробуем достучаться к эллементу которого нет ..эту ошибку и вылавим...
 
            delete [] a;
 
    }
    catch(...){ // Под любую ошибку...
 
         cout<<"Мы отловили ошибку!";
 
    }
 
}

    protected:
      /// Safety check used only from at().
      void
      _M_range_check(size_type __n) const
      {
        if (__n >= this->size())
          __throw_out_of_range(__N("vector::_M_range_check"));
      }
 
    public:
      /**
       *  @brief  Provides access to the data contained in the %vector.
       *  @param n The index of the element for which data should be
       *  accessed.
       *  @return  Read/write reference to data.
       *  @throw  std::out_of_range  If @a n is an invalid index.
       *
       *  This function provides for safer data access.  The parameter
       *  is first checked that it is in the range of the vector.  The
       *  function throws out_of_range if the check fails.
       */
      reference
      at(size_type __n)
      {
        _M_range_check(__n);
        return (*this)[__n];
      }
 
      /**
       *  @brief  Provides access to the data contained in the %vector.
       *  @param n The index of the element for which data should be
       *  accessed.
       *  @return  Read-only (constant) reference to data.
       *  @throw  std::out_of_range  If @a n is an invalid index.
       *
       *  This function provides for safer data access.  The parameter
       *  is first checked that it is in the range of the vector.  The
       *  function throws out_of_range if the check fails.
       */
      const_reference
      at(size_type __n) const
      {
        _M_range_check(__n);
        return (*this)[__n];
      }

 class vector {
           // определение типа возможных особых ситуаций
         class range { };
           // ...
         };

int & vector::operator [] ( int i )
        {
          if ( i < 0 || sz <= i ) throw range ();
          return v [ i ];
        }

 void f ( int i )
          {
              try
              {
              // в этом блоке обрабатываются особые ситуации
              // с помощью определенного ниже обработчика
              vector v ( i );
              // ...
              v [ i + 1 ] = 7;  // приводит к особой ситуации range
              // ...
              g ();         // может привести к особой ситуации range
                            // на некоторых векторах
              }
              catch ( vector::range )
              {
                  error ( "f (): vector range error" );
                  return;
              }
          }

#include <iostream>
 
class Array
{
public:
    class OutOfRangeException : public std::exception
    {
    public:
        OutOfRangeException()
        {
        }
 
        virtual ~OutOfRangeException() throw()
        {
        }
 
        const char *what() const throw()
        {
            return "Out of range!";
        }
    };
 
public:
    Array(size_t size):
    m_size(size),
    m_array(new int[m_size]())
    {
    }
 
    ~Array()
    {
        delete[] m_array;
    }
 
    size_t size() const
    {
        return m_size;
    }
 
    int& operator[](size_t index)
    {
        if (index >= m_size)
            throw OutOfRangeException();
 
        return m_array[index];
    }
 
    const int& operator[](size_t index) const
    {
        if (index >= m_size)
            throw OutOfRangeException();
 
        return m_array[index];
    }
 
private:
    size_t m_size;
    int *m_array;
};
 
int main()
{
    Array arr(10);
 
    try
    {
        for (size_t i = 0; i < arr.size(); ++i)
            arr[i] = i + 1;
 
        for (size_t i = 0; i < arr.size() + 1; ++i)
            std::cout << arr[i] << "  ";
    }
    catch (const Array::OutOfRangeException &ex)
    {
        std::cerr << ex.what() << std::endl;
    }
 
    return 0;
}