Usos del try en lugar de if

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