C++ Exception Handling Questions

Question

1) For convenience I have my entire program in a try block. This way I can throw an exception at any point in my code and know that it will be handled the same way. As the program becomes larger will this technique cause a hit in performance?

2) If objects are de-allocated when out of scope, why would throwing a temporary object be valid? e.g.:

class Error : public std::exception  
{
  private:
    char *m;
  private:
    Error(char *l) : m(l) {}
    virtual char *what()
    {
      return m;
    }
};

int main()
{
  try
  {
    throw Error("test");
  }
  catch(std::exception &e)
  {
    puts(e.what());
    return -1;
  }
  return 0;
}

In the throw statement, why wouldn't the temporary object become invalid since it's been declared only in the try scope?

3) With Windows operating systems of a language other than English, would the what() member of the STL exception class still return a char* string? Or could it return a wchar_t* string?

You really should not have your whole program in a try block. If you get any error, your whole program ends rather than allowing you to elegantly handle it and continue. This kinda defeats the purpose of exceptions. — JoshD
I disagree, if you log meaningful information from the exception at this level then it is perfectly valid. It gives you better information than if std::terminate was called, which is what happens if the exception isn't caught. — radman
@JoshD within certain areas of my code I could have more try-catch blocks, with which I could elegantly handle exceptions. The first try-catch block would be to handle fatal errors where the program could not continue further. — kaykun
@radman: I wasn't saying that no catching should be done. I was saying that having one huge try block around the whole program is not as useful as having finer grain try and catch blocks. I agree that catching an exception is better than letting the program crash. — JoshD
How could the return type of the function change at runtime? — André Caron

Mark Ransom Mark Ransom · Accepted Answer · 2010-10-18T22:22:45

Technically you don't throw the actual object, you throw a copy of it. That's why you can get away with throwing a temporary. Catching a reference also gets a reference to the copy.

This can bite you if you rethrow an exception from within a catch block, you can fall victim to the slicing problem. That's why you don't do:

catch (std::exception & e)
{
    throw e;  // bad, always throws std::exception rather than what was caught
}

But rather

catch (std::exception & e)
{
    throw;  // good, rethrows the exact copy that you caught without making another copy
}

P.S. There's no rule saying you couldn't return a UTF-8 string from what. It would be up to you to convert it to UTF-16 for Windows I/O. The standard exception classes were never explicitly designed or extended for Unicode, nor are any non-standard extensions added just for Windows.

C++ Exception Handling Questions

2 Answers