throw new std::exception vs throw std::exception

by

The conventional way to throw and catch exceptions is to throw an exception object and to catch it by reference (usually const reference). The C++ language requires the compiler to generate the appropriate code to construct the exception object and to properly clean it up at the appropriate time.

Throwing a pointer to a dynamically allocated object is never a good idea. Exceptions are supposed to enable you to write more robust code in the face of error conditions. If you throw an exception object in the conventional manner you can be sure that whether it is caught by a catch clause naming the correct type, by a catch (...), whether it is then re-thrown or not it will be destroyed correctly at the appropriate time. (The only exception being if it is never caught at all but this is a non-recoverable situation whichever way you look at it.)

If you throw a pointer to a dynamically allocated object you have to be sure that whatever the call stack looks like at the point you want to throw your exception there is a catch block that names the correct pointer type and has the appropriate delete call. Your exception must never be caught by catch (...) unless that block re-throws the exception which is then caught by another catch block that does deal correctly with the exception.

Effectively, this means you’ve taken the exception handling feature that should make it easier to write robust code and made it very hard to write code that is correct in all situations. This is leaving aside the issue that it will be almost impossible to act as library code for client code that won’t be expecting this feature.

More Related Contents:

  1. Exception Handling with pointer [closed]
  2. If you shouldn’t throw exceptions in a destructor, how do you handle errors in it?
  3. Does C++ support ‘finally’ blocks? (And what’s this ‘RAII’ I keep hearing about?)
  4. C++ display stack trace on exception
  5. How can I propagate exceptions between threads?
  6. Throwing exceptions from constructors
  7. Why should exceptions be used conservatively?
  8. Should I use an exception specifier in C++?
  9. Why doesn’t C++ use std::nested_exception to allow throwing from destructor?
  10. How do exceptions work (behind the scenes) in c++
  11. Who deletes the memory allocated during a “new” operation which has exception in constructor?
  12. When and how should I use exception handling?
  13. C++: Safe to use longjmp and setjmp?
  14. In what ways do C++ exceptions slow down code when there are no exceptions thown?
  15. Catching exceptions from a constructor’s initializer list
  16. How much footprint does C++ exception handling add
  17. Will C++ exceptions safely propagate through C code?
  18. C++ – Arguments for Exceptions over Return Codes
  19. Why are C++ STL iostreams not “exception friendly”?
  20. Exception Error c0000005 in VC++
  21. How is the C++ exception handling runtime implemented?
  22. Reset Cuda Context after exception
  23. Throwing an exception from within a signal handler
  24. Should I inherit from std::exception?
  25. Does throw inside a catch ellipsis (…) rethrow the original error in C++?
  26. What happens if a constructor throws an exception?
  27. C++ : handle resources if constructors may throw exceptions (Reference to FAQ 17.4]
  28. How to throw std::exceptions with variable messages?
  29. Why vector access operators are not specified as noexcept?
  30. New (std::nothrow) vs. New within a try/catch block

Leave a Comment