Should I use an exception specifier in C++?

by

No.

Here are several examples why:

  1. Template code is impossible to write with exception specifications,

    template<class T>
void f( T k )
{
     T x( k );
     x.x();
}

    The copies might throw, the parameter passing might throw, and x() might throw some unknown exception.

  2. Exception-specifications tend to prohibit extensibility.

    virtual void open() throw( FileNotFound );

    might evolve into

    virtual void open() throw( FileNotFound, SocketNotReady, InterprocessObjectNotImplemented, HardwareUnresponsive );

    You could really write that as

    throw( ... )

    The first is not extensible, the second is overambitious and the third is really what you mean, when you write virtual functions.

  3. Legacy code

    When you write code which relies on another library, you don’t really know what it might do when something goes horribly wrong.

    int lib_f();

void g() throw( k_too_small_exception )
{ 
   int k = lib_f();
   if( k < 0 ) throw k_too_small_exception();
}

    g will terminate, when lib_f() throws. This is (in most cases) not what you really want. std::terminate() should never be called. It is always better to let the application crash with an unhandled exception, from which you can retrieve a stack-trace, than to silently/violently die.

  4. Write code that returns common errors and throws on exceptional occasions.

    Error e = open( "bla.txt" );
if( e == FileNotFound )
    MessageUser( "File bla.txt not found" );
if( e == AccessDenied )
    MessageUser( "Failed to open bla.txt, because we don't have read rights ..." );
if( e != Success )
    MessageUser( "Failed due to some other error, error code = " + itoa( e ) );

try
{
   std::vector<TObj> k( 1000 );
   // ...
}
catch( const bad_alloc& b )
{ 
   MessageUser( "out of memory, exiting process" );
   throw;
}

Nevertheless, when your library just throws your own exceptions, you can use exception specifications to state your intent.

More Related Contents:

  1. Possibilities to quit a function
  2. Throwing exceptions from constructors
  3. How do exceptions work (behind the scenes) in c++
  4. Difference between C++03 throw() specifier C++11 noexcept
  5. Does throw inside a catch ellipsis (…) rethrow the original error in C++?
  6. New to programming: How to call a structure’s variables in a function and then update them? (C++) [closed]
  7. Compilation error: expected constructor, destructor, or type conversion before ‘;’ token [closed]
  8. If you shouldn’t throw exceptions in a destructor, how do you handle errors in it?
  9. Return array in a function
  10. Using generic std::function objects with member functions in one class
  11. Does C++ support ‘finally’ blocks? (And what’s this ‘RAII’ I keep hearing about?)
  12. C++ callback using class member
  13. C++ return array from function [duplicate]
  14. Why doesn’t C++ support functions returning arrays?
  15. Why should exceptions be used conservatively?
  16. catch exception by pointer in C++
  17. Why doesn’t C++ use std::nested_exception to allow throwing from destructor?
  18. ‘foo’ was not declared in this scope c++
  19. Function pointer vs Function reference
  20. std::bind a bound function
  21. How Non-Member Functions Improve Encapsulation
  22. Do class functions/variables have to be declared before being used?
  23. C++ – Arguments for Exceptions over Return Codes
  24. how do I make a portable isnan/isinf function
  25. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  26. Function to mangle/demangle functions
  27. How much overhead is there in calling a function in C++?
  28. is it possible to make function that will accept multiple data types for given argument?
  29. Get signatures of exported functions in a DLL
  30. How to throw std::exceptions with variable messages?

Leave a Comment