TEMA 9: EXCEPCIONES. PATRÓN RAII.

• Las excepciones se emplean en situaciones excepcionales que se producen en tiempo de ejecución y que no se pueden conocer en tiempo de compilación, cuando estamos desarrollando nuestra aplicación o biblioteca.
• Por tanto no se deben confundir con errores en la lógica de nuestro código, estos son otra cosa totalmente distinta.

Simply put, an Error is a bug in the application. An Exception is a bug in the input to the application. The former is not recoverable, the latter is.

– Walter Bright, D Language creator.

• Son la alternativa al tratamiento de errores consistente en devolver un simple código de error (valor numérico).
• Aportan, por tanto, más información al punto de nuestro código donde se recibe el error.
• Pero, sobre todo en el paradigma de POO, donde podemos tener varios objetos vivos en el punto donde se produce el error y que por tanto deberían desaparecer liberando toda la memoria que pudieran tener reservada, nos permite automatizar este proceso.
• Para ello nos permiten deshacer la pila de llamadas, invocando los destructores de los objetos implicados; y ya sabemos lo que podemos/debemos hacer en el destructor de un objeto cuando se invoca.

• C++ (y lenguajes como Java, C#, Vala, D, etc…) emplean una sintáxis similar.
• En C++ se emplean las palabras reservadas:
  • try
  • throw
  • catch

• Un ejemplo muy sencillo:

  #include <iostream>
  
  double f(double d) {
    if (d > 1e7)
        throw std::overflow_error("too big");
    else
        return d;
  }
  
  int main() {
    try {
        std::cout << f(1e10) << '\n';
    } catch (const std::overflow_error& e) {
        std::cout << e.what() << '\n';
    }
  }
  

• Se permite lanzar excepciones de tipos base del lenguaje, p.e., char, int, etc…
• Se puede indicar la lista de excepciones que puede lanzar una función en C++ pre C++14: void f() throw(int);
• Si una función no lanza ninguna se indica así:
  • en C++ pre C++11: void f() throw();
  • en C++11 o posterior así: void f() noexcept; o void f() noexcept(true);
• Aquí tienes más información sobre noexcept.

• Si se lanza una excepción no especificada en la lista de posibles excepciones, se llama a std::unexpected().
• Por defecto unexpected llama a std::terminate y el programa acaba.

• Se puede cambiar la función a la que llama, p.e.:

  #include <exception>      // std::set_unexpected
  void myunexpected () {
    std::cerr << "unexpected called\n";
  }
  int main() {
    std::set_unexpected(myunexpected);
      ...
  }
  

• Si una función no especifica una lista vacía de excepciones o noexcept, se asume que puede lanzar cualquier excepción.

• A un bloque try le podemos asociar varios bloques catch:

  int main (void) {
    std::set_unexpected (myunexpected);
    try {
      myfunction();
    }
    catch (int) { std::cerr << "caught int\n"; }
    catch (...) { std::cerr << "caught some other exception type\n"; }
    return 0;
  }
  

• IMPORTANTE: Los bloques catch se evalúan por orden, por tanto si el tipo de un catch concuerda con el tipo de la excepción lanzada, entonces se trata en ese catch.

  class ExceptionBase {...};
  class ExceptionDerived : public ExceptionBase {...};
  ...
  try {
     f ();                        // throws ExceptionDerived
  }
  catch (ExceptionBase& eb) {...} // <-- se captura aquí
  catch (ExceptionDerived& ed) {...}
  

• Los bloques catch con elipsis (…): catch (...)
  capturan cualquier tipo de excepción, por eso se ponen al final.

• Una excepción se puede relanzar:

  try {
    f ();                        // throws ExceptionDerived
  }
  catch (ExceptionBase& eb) { throw; } // <-- se relanza aquí
  
  

• C++ nos proporciona una serie de clases predefinidas que sirven para representar tipos de error en nuestro código.
• Debemos incluir la cabecera stdexcept (la cual incluye a exception).
• De este modo tenemos acceso a las clases exception y derivadas de ella como logic_error, length_error, etc…

• Todas ellas tienen un constructor a partir de una cadena, p.e.:
  runtime_error( const std::string& what_arg );.
• En esta cadena podemos aprovechar para poner una descripción del error.
• Esta cadena puede ser consultada con el método heredado de la clase exception:
  virtual const char* what() const noexcept;

• Inventado por Bjarne Stroustrup (creador de C++).

• Los recursos (memoria, ficheros, etc…) que usa un objeto se crean cuando este se inicializa (constructor) y se destruyen cuando el objeto desaparece (destructor).

  class file {                    // https://es.wikipedia.org/wiki/RAII
  public:
    file (const char* filename) : file_ (std::fopen(filename, "w+")) {
        if (!file_) {
            throw std::runtime_error ("Error al abrir un archivo.");
        }
    }
  
    ~file() {
        if (std::fclose(file_)) {
            throw std::runtime_error ("Error al cerrar un archivo.");
        }
    }
  
    void write (const char* str) {...}
  }
  

void main () {
   ////////////////////////////////////////////////////////
   // Abrimos el archivo, estamos adquiriendo un recurso //
   ////////////////////////////////////////////////////////
   file logfile ("registro_de_incidencias.txt");

   logfile.write ("¡Hola, registro!");
} // <- Al salir de ámbito, en el destructor de logfile se cierra el fichero

• Sí, claro. Determinados lenguajes de programación han elegido un modelo diferente de tratamiento de errores.
• Veamos el caso de Rust.

• En Rust existe este enumerado:

  enum Result<T,E> {
    Ok(T),     // Constructor de Result<T> a partir de un tipo T, resultado correcto
    Err(E),    // Constructor de Result<E> a partir de un tipo E, error
  }
  

• Podemos ver Ok(T) y Err(E) como sendas funciones que crean un dato de tipo Result a partir de un dato de tipo:
  • T si hay resultado, T es el tipo del resultado
  • E si se produce un error, E es el tipo del error

• En ningún caso estas transparencias son la bibliografía de la asignatura, por lo tanto debes estudiar, aclarar y ampliar los conceptos que en ellas encuentres empleando los enlaces web y bibliografía recomendada que puedes consultar en la página web de la ficha de la asignatura y en la web propia de la asignatura.