Re: Templated throw() specifications.

From:

Kai-Uwe Bux <jkherciueh@gmx.net>

Newsgroups:

comp.lang.c++

Date:

Wed, 04 Jun 2008 20:22:29 -0400

Message-ID:

<484731c5$0$25950$6e1ede2f@read.cnntp.org>

jason.cipriani@gmail.com wrote:

Consider this program, which defines a template class who's template
parameter is the type of an exception that can be thrown by members of
the class:

=== BEGIN EXAMPLE ===

#include <iostream>
#include <string>
using namespace std;

void function () throw (string) {
  throw string("Oops");
}

template <class EX> class A {
public:
  typedef void (* FN) ();
  explicit A (FN f) : f_(f) { }
  void Call () throw (EX) { f_(); }
private:
  FN f_;
};

int main () {
  A<string> a(&function);
  try {
    a.Call();
  } catch (const string &s) {
    cout << s << endl;
  }
}

=== END EXAMPLE ===

The goal of the above is to allow the callback function to throw any
exception it wants (not necessarily derived from std::exception, so
simply specifying that is not an option), and still have the generated
template code for A have the correct throw() specifier for A::Call().

What if the callback function can throw objects of various types?

I have a couple of questions:

1. Is having a correct exception specifier even necessary? It's always
been one of those things that C++ has that compilers never seem to
care about (compare to Java, for example, where it is strictly
enforced). VC++ actually generates a compiler warning that throw()
specifiers are ignored, GCC doesn't care, Borland's compiler is the
only one I know of off the top of my head that actually produces
diagnostics when throw() specifications are violated.

You seem to misunderstand throw specifications. They are enforced at
run-time not at compile time. If an exception wants to unwind the stack
past a function from which it is not allowed to escape according to the
exception specification, then the function unexpected() is called.

If it really
doesn't matter (and won't matter in C++0x either), then the above
template stuff is completely unnecessary since I can just declare
Call() with no exception specification at all and not have to deal
with it.

By and large, throw specifications can be considered useless with the
notable exception of throw().

[snip]

Best

Kai-Uwe Bux