[SOLUCIONADO] Usos del try en lugar de if

[dmorill]

Hola amigos,

Les traigo una duda luego de ver un código y buscar un poco acerca de los try{} en c++, las "exceptions", exactamente para que sirve, es decir no se puede hacer lo mismo con un if o con un switch?

saludos,

[eferion]

try-catch sirve para la gestión de excepciones. Las excepciones, en el caso de usarlas, únicamente deberían usarse para indicar situaciones anómalas, como por ejemplo que se ha perdido la conexión con la base de datos o que ha habido un problema al reservar memoria para un proceso.

La gracia de usar excepciones es que proporcionas a la aplicación un sistema homogéneo de gestión de errores capaz de proporcionar en tiempo de ejecución mucha más información que un simple return (como en C). La pega es que la gestión de excepciones exige código adicional en las funciones, además de que puedes provocar errores nuevos si no tienes en cuenta las exepciones... como fugas de memoria:

Código C++:

int* func()
{
  int* toReturn = new int[10];
  throw "Error";
 
  // Este return no se ejecuta nunca pero la memoria sí que se ha reservado
  return toReturn;
}
 

El uso de excepciones se puede retorcer hasta el extremo de que podrías usarlas como sustituto del return... pero es desaconsejable por tres razones básicas:

• no están pensadas para eso
• Se va a tardar algo más de tiempo en entender el funcionamiento del código
• El tiempo de ejecución es mayor

Código C++:

void suma(int a, int b)
{
  throw a+b;
}
 
int main()
{
  try
  {suma(4,3);}
 
  catch( int resultado )
  { std::cout << "4 + 3 = " << resultado << std::end; }
}
 

Así que no, try-catch no es un sustituto natural de if o de switch. La primera estructura sirve para la gestión de excepciones y las dos últimas para el control del flujo del programa. Son elementos diferentes con responsabilidades totalmente distintas.

--------------------
EDITO:

¿Qué pueden proporcionar las excepciones que no se pueda conseguir con otras estructuras? Dependiendo de cómo estructures tus excepciones, varias cosas:

• Claridad en el diseño
• Mucha información sobre la excepción sin necesidad de depurar
• otros

Por ejemplo:

Código C++:

#include <iostream>
#include <string>
 
class CustomException
{
  public:
    CustomException(
        const std::string& what,
        const std::string& where,
        int line)
      : _what(what),_where(where),_line(line),_nested(0)
    {
    }
 
    CustomException(
        const std::string& what,
        const std::string& where,
        int line,
        const CustomException& nested)
      : _what(what),_where(where),_line(line),_nested(new CustomException(nested))
    {
    }
 
    CustomException(const CustomException& other)
      : _what(other._what),_where(other._where),_line(other._line),_nested(0)
    {
      if( other._nested)
        _nested = new CustomException(*other._nested);
    }
 
    ~CustomException()
    { delete _nested; }
 
    std::string What() const
    {return _what; }
 
    std::string Where() const
    { return _where; }
 
    int Line() const
    { return _line; }
 
    std::string ToString() const
    {
      std::string toReturn = _what + " in " + _where + ": " + std::to_string(_line) + "\n";
      CustomException* ptr = _nested;
      if( ptr )
        toReturn += "Stack:\n";
 
      while( ptr )
      {
        toReturn += "\t" + ptr->Where() + ":" + std::to_string(ptr->_line) + " - " + ptr->What() + "\n";
        ptr = ptr->_nested;
      }
 
      return toReturn;
    }
 
  private:
    std::string _what;
    std::string _where;
    int _line;
    CustomException* _nested;
};
 
void func3()
{
  throw CustomException("Error X",__FUNCTION__,__LINE__);
}
 
void func2()
{
  try
  {
    func3();
  }
 
  catch( const CustomException& exc )
  {
    throw CustomException("Error raro",__FUNCTION__,__LINE__, exc);
  }
}
 
void func()
{
  try
  {
    func2();
  }
 
  catch( const CustomException& exc )
  {
    throw CustomException("Error muy raro",__FUNCTION__,__LINE__,exc);
  }
}
 
int main()
{
  try
  {
    func();
  }
 
  catch(const CustomException& exc)
  {
    std::cout << exc.ToString() << std::endl;
  }
}
 

Hacer esto con control de flujo requeriría bastante más esfuerzo y el resultado sería menos elegante.

Un saludo.

[dmorill]

Muchas gracias, el ultimo ejemplo tengo que digerirlo detalladamente jeje. Por tanto una excepción es una forma de adelantarse a un problema que uno sabe puede ocurrir y decirle al codigo que hacer cuando lo encuentre.

Saludos

[eferion]

Iniciado por dmorill

Muchas gracias, el ultimo ejemplo tengo que digerirlo detalladamente jeje. Por tanto una excepción es una forma de adelantarse a un problema que uno sabe puede ocurrir y decirle al codigo que hacer cuando lo encuentre.

Saludos

No exactamente. Una excepción es una forma de avisar de que ha ocurrido algo anormal en el programa. La excepción debería contener suficiente información (mediante polimorfismo y métodos) como para identificar el origen del problema... por lo menos hasta un nivel mínimo que permita localizar el origen del problema.

Entonces, la excepción es recuperada por otra sección del código (que de forma directa o indirecta ha llamado al código que ha generado la excepción) y que actúa en consecuencia, ya sea mostrando un mensaje al usuario, abortando la aplicación o el proceso en curso, añadiendo una entrada en un log, ...

Un motivo para las excepciones es permitir que la aplicación se recupere de un error en las mejores condiciones posibles, ya que normalmente los errores se producen en el núcleo y dicha capa de código no es capaz de responder de forma conveniente ante un error. Sin excepciones la solución pasaría por propagar un mensaje de error entre las diferentes capas de código hasta llegar a una capaz de iniciar las acciones que permitan recuperarse del error... con las excepciones este proceso se automatiza.

PD.: el ejemplo anterior lo que propone es una secuencia de excepciones anidadas... al final el main recibe información precisa sobre dónde se ha producido el error (en qué función y en qué línea) y qué ruta de llamadas ha seguido el código para llegar hasta ese error.

Un saludo

[dmorill]

Gracias de nuevo, creo que ya lo voy entendiendo.

Por tanto ejemplos que he visto del uso del try (a modo explicativo) como el siguiente, son correctos, pero mal usados, pues no es necesario el uso el try, ya que no se va a incurrir en un error propiamente dicho.

Código C++:

int main(){
    try{
        int x;
        cout << "Enter a number from 1 to 10: ";
        cin >> x;
        if (x > 0 && x < 11){
            cout << "Correct number." << endl;
        }else{
            throw x;
        }
    }catch (int y){
        cout << "Incorrect number." << endl;
    }
}
 

Quizá su uso está reservado a códigos más complejos.

saludos,

[eferion]

Exacto. No hay una norma escrita sobre cómo se deben usar las excepciones... es algo libre de cada uno o de la política que te obliguen a llevar en la empresa de turno.

A mi modo de ver las excepciones deben usarse para situaciones como las que te he comentado... aquellas donde el error se genera en una parte del código pero la recuperación correspondiente no se puede realizar sino varias capas por encima.

Piensa también que si se genera una excepción y no la capturas, esta subirá por la pila hasta llegar al main... si ahí sigue sin capturarse el programa terminará con error.