El lanzamiento de una excepción se realiza llamando a la función throw(). Cuando se lanza una excepción, en realidad lo que se hace es crear un objeto de la clase que se le indique a throw(), y precisamente será dicho objeto la excepción en sí.

Suele ser muy útil crear clases de excepciones propias para controlar las situaciones anómalas de nuestra aplicación. Por ejemplo,

En ObjGraf.h:

//*************************************************/
// Definicion de la clase EFueraRango
// Clase de excepcion por entrar en "fuera de rango":
// salirse de los limites del PaintBox al calcular
// las nuevas coordenadas de dibujo de la pelota.
//*************************************************/

class EFueraRango {};

Con lo que podríamos lanzar una excepción de la siguiente manera:

   throw EfueraRango();

Nota: Aunque las excepciones sean clases, en C++ Builder existe la convención de que su nombre empiece por la letra E, y no por T como el resto de las clases.

Aunque en el ejemplo anterior la clase creada para la excepción, no tiene ningún miembro (propiedades o métodos), se le pueden añadir. Éstos servirán para poder incorporar información en el objeto excepción, acerca de la situación en la que se produjo la excepción, que podrá ser utilizada por la sección de código que lo trate.
Por ejemplo, si tuvieramos un método que lanzara una excepción por falta de memoria, podría ser interesante que incorporara una propiedad que indicara cual era el máximo de memoria disponible cuando se lanzó la excepción.

C++ cuenta con una característica denominada especificación de excepciones, que sirve para enumerar, en una declaración, las excepciones que puede lanzar un método. Si queremos que un método pueda lanzar un determinado tipo de excepción deberemos especificarlo de esta manera.

En ObjGraf.h, en la clase TObjGraf:

//*************************************************/
// Definicion de la clase base TObjGraf
//*************************************************/

class TObjGraf {

private:

   int FX;
   int FY;

   void SetX   (int _X) throw (EFueraRango); // Si hay problemas,crean un
   void SetY   (int _Y) throw (EFueraRango); // objeto de clase EFueraRango

   virtual int GetAncho (void) = 0; // Metodo virtual puro
   virtual int GetAlto  (void) = 0; // Metodo virtual puro
   ...

En ObjGraf.cpp:

// Funciones de escritura de las propiedades virtuales X e Y

void TObjGraf :: SetX (int _X) throw (EFueraRango)
{
   if (_X < 0) {  // Coordenada negativa 
      FX = 0;  // Ajustar al margen izquierdo 
      throw EFueraRango();  // Lanzar excepcion 
   }
   else
      if (_X > (PaintBox->Width - Ancho)) {  // Demasiado alta 
         FX = PaintBox->Width - Ancho;  // Ajustar al margen derecho
         throw EFueraRango();  // Lanzar excepcion
      }
      else
         FX = _X;  // Correcto: escribir sin modificar 
}


void TObjGraf :: SetY (int _Y) throw (EFueraRango)
{
   if (_Y < 0) {  // Coordenada negativa
      FY = 0;  // Ajustar al margen superior 
      throw EFueraRango();  // Lanzar excepcion
   }
   else
      if (_Y > (PaintBox->Height - Alto)) {  // Demasiado alta 
         FY = PaintBox->Height - Alto;  // Ajustar al margen inferior 
         throw EFueraRango();  // Lanzar excepcion
      }
      else
         FY = _Y; // Correcto: escribir sin modificar 
}

El bloque susceptible de producir alguna excepción ("zona crítica") se encierra en un bloque try, la captura (discriminación de la excepción que se ha producido) se efectúa en una instrucción catch y su procesamiento se realiza a continuación, en el bloque catch.

Podemos especificar tantos bloques catch para un bloque try como deseemos, en el momento que ocurra una excepción se ejecutará el bloque catch cuya clase concuerde con la de la excepción. Si se especifica catch (...) se capturará cualquier excepción.

La excepción no tiene porqué lanzarse explícitamente en el bloque try sino que puede ser consecuencia de la ejecución de una función que se ha llamado dentro de ese bloque.

En ObjGraf.cpp:

void TPelota :: Mover (void)
{
   Borrar ();

   try {
      X += FDirX * Velocidad;
   }
   catch (EFueraRango) {
      FDirX = -FDirX;
   };

   try {
      Y += FDirY * Velocidad;
   }
   catch (EFueraRango) {
      FDirY = -FDirY;
   };

   Mostrar ();
}

En este ejemplo, la instrucción "crítica":

   X += FDirX * Velocidad;

   X = X + FDirX * Velocidad;

   SetX (FX + FDirX * Velocidad);

En Ppal.cpp:

1. Dejar únicamente la siguiente declaración global:

      TPelota *Pelota;
   

2. Modificar las funciones FormCreate() y FormDestroy() para que queden:

   //----------------------------------------------------------
   
   void __fastcall TPpalFrm::FormCreate(TObject *Sender)
   {
      Pelota = new TPelota (PaintBox, clYellow, 120,  70, 25);
   }
   //----------------------------------------------------------
   
   void __fastcall TPpalFrm::FormDestroy(TObject *Sender)
   {
      delete Pelota;
   }
   

3. Eliminar el manejador del evento OnPaint del componente PaintBox (borrando su cuerpo solamente).

4. Añadir a PpalFrm un TTimer (Carpeta System) y fijar Interval=100. En el evento OnTimer poner:

   //----------------------------------------------------------
   
   void __fastcall TPpalFrm::Timer1Timer(TObject *Sender)
   {
      Pelota->Mover();
   }
   //----------------------------------------------------------
   

NOTA: El entorno debe estar configurado para que el programa gestione las excepciones, no el entorno. Si no fuera sí, seleccionar Tools | Debuggber Options, abrir la carpeta OS Exceptions y dejarla como se indica en la figura 6.2.

Si una excepción que ha sido lanzada no encuentra un manejador apropiado, se llamará a la función terminate(), la cual por defecto realiza un abort(). Pero se puede definir nuestra propia función terminate() con la orden set_terminate().

Algo muy parecido ocurre si un método lanza una excepción de un tipo que no tiene listado en su especificación de excepciones, entonces se llama a la función unexpected() la cual por defecto llama a terminate(). Pero de igual manera que con terminate() podemos definir nuestra propia función unexpected() con set_unexpected().

Si se utilizan componentes de la VCL en las aplicaciones, es necesario comprender el mecanismo de tratamiento de excepciones de la VCL. El motivo es que las excepciones están integradas en numerosas clases y se lanzan automáticamente cuando se presenta un situación no esperada. Si no se realiza un tratamiento de la excepción, la VCL llevará a cabo un tratamiento por defecto. Normalmente, aparece un mensaje que describe el tipo de error que se ha producido.

1. Clases de Excepciones.

C++ Builder incorpora un extenso conjunto de clases de excepción integradas que permiten tratar automáticamente errores de división por cero, de E/S de archivos, de conversiones de tipos y otras muchas situaciones anómalas. Todas las clases excepción de VCL se derivan de un objeto raíz denominado Exception, que encapsula las propiedades y métodos fundamentales de todas las excepciones por parte de las aplicaciones.

2. Tratamiento de Excepciones de la VCL

Las excepciones de tipo VCL, como todas las clases de la VCL deben de localizarse en el heap (creación dinámica), por lo que se deberá tener en cuenta lo siguiente:

• Las clases de excepción de tipo VCL solamente pueden capturarse por puntero o por referencia (preferible).
• Las excepciones de tipo VCL deben lanzarse con sintaxis "por valor".

Las excepciones pueden pasarse a un bloque catch que toma un parámetro de tipo Exception. Emplear la siguiente sintaxis para capturar las excepciones de la VCL:

   catch (const exception_class & exception_variable)

Se especifica la clase de excepción que se desea capturar y se proporciona una variable por medio de la cual hacer referencia a la excepción.

Por ejemplo,

//--------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

//--------------------------------------------------------

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{

     try {
        throw Exception("Mi excepción VCL");
     }
     catch (const Exception & E) {
        ShowMessage("Clase de la excepción capturada: " +
           AnsiString(E.ClassName()) + "\nMensaje: " + E.Message);
     }

   return (0);
}
//--------------------------------------------------------

La sentencia throw del ejemplo anterior crea una instancia de la clase Exception y llama a su constructor. Todas las excepciones que descienden de Exception cuentan con un mensaje que puede presentarse en pantalla, pasarse a los constructores y recuperarse mediante la propiedad Message. El resultado de la ejecución del programa anterior es el mostrado en la figura 6.5

Figura 6.5. Ejemplo de lanzamiento y captura de excepción VCL.

3. Clases de excepción típicas

Aunque las excepciones no tienen porque indicar un error en la ejecución de una aplicación, las excepciones de la VCL si suelen ser errores. Veamos una selección de las clases de excepción más utilizadas en C++ Builder.

Clase	Descripción
EAccessViolation	Error de acceso a memoria.
EDatabaseError	Especifica un error de acceso a base de datos.
EDBEditError	Datos incompatibles con una máscara especificada.
EDivByZero EZeroDivide	Captura errores de división por cero (para división entera y real, respectivamente).
EInOutError	Representa un error de E/S de archivo.
EInvalidPointer	Operaciones no válidas con punteros.
EPrinterError	Indica un error de impresión.

Aunque todas estas clases funcionen de la misma manera, cada una de ellas tiene particularidades derivadas de la excepción concreta que indican.

Ejemplo.

El siguiente programa (proyecto Division2) es una ampliación del proyecto Division. En éste se van a discriminar distintas excepciones, más que capturar cualquier excepción.

//---------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

//---------------------------------------------------------------------

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{

   AnsiString Valor;
   float Dividendo, Divisor, Cociente;
   float sigo = true;


   while (sigo) {

      try {

         // Leer dividendo y convertirlo

         Valor =InputBox ("Division", "Dividendo", "");
         Dividendo = StrToFloat (Valor);

         if (Dividendo == 0) sigo = false;
         else {

            // Leer divisor y convertirlo

            Valor =InputBox ("Division", "Divisor", "");
            Divisor = StrToFloat (Valor);

            Cociente = (Dividendo / Divisor);
            ShowMessage ("Cociente = " + AnsiString(Cociente));
         }

      } // try

      // Se captura si se ha realizado una división por cero.

      catch (EZeroDivide & ) {
         ShowMessage ("El divisor no puede ser cero.");
      }

      // Más general: se alcanza si no se captura la anterior.

      catch (Exception & e) {
         ShowMessage ("Se produjo una excepción: "+AnsiString(e.ClassName())+
            "\n   " + e.Message);
      }

   } // while sigo

   return (0);
}
//---------------------------------------------------------------------

Si se intenta realizar una division por cero el resultado es el que se indica en la figura 6.6:

Figura 6.6. Ejemplo de división por cero.

Si se introdujera un dato incorrecto, la función StrToFloat() lanzaría una excepción EConvertError que se captura con el último bloque catch (ver figura 6.7).

Figura 6.7. Ejemplo de entrada incorrecta.

Es más, si se produjera algún tipo de desbordamiento también podría controlarse con el último bloque catch (ver figura 6.8).

Figura 6.8. Ejemplos de desbordamiento: A) En la entrada de datos y B) En el cálculo del cociente.

Si quitáramos el primer bloque catch podría capturarse la interrupción EZeroDivide (ver figura 6.9).

Figura 6.9. Otra manera de capturar la división por cero.

Para finalizar, si añadimos el siguiente bloque catch entre los dos anteriores:

      catch (EMathError & e) {
         ShowMessage ("Operación no válida: " + e.Message);
      }

TObject-->Exception-->EExternal-->EMathError-->(EZeroDivide, EOverflow, ...) 	

el alumno deberá interpretar el resultado de la figura 6.10:

Figura 6.10. Otra manera de capturar desbordamientos: A) En la entrada de datos y B) En el cálculo del cociente.

EJERCICIO: Reproductor de sonidos.