Re: The D Programming Language
peter koch larsen wrote:
Actually - to increase confusion - it should be clear that the check
in Java is only of exceptions that derive from the class Exception.
Exceptions deriving from Throwable and RuntimeError (if I remember
correctly) are not checked at all.
According to
http://java.sun.com/docs/books/jls/second_edition/html/exceptions.doc.html
exceptions derived from Error and RuntimeException are not checked. The
reasons stated are very revealing:
"Those unchecked exception classes which are the error classes (Error
and its subclasses) are exempted from compile-time checking because they
can occur at many points in the program and recovery from them is
difficult or impossible. A program declaring such exceptions would be
cluttered, pointlessly."
and, regarding RuntimeException:
"The information available to a compiler, and the level of analysis the
compiler performs, are usually not sufficient to establish that such
run-time exceptions cannot occur, even though this may be obvious to the
programmer. Requiring such exception classes to be declared would simply
be an irritation to programmers."
If you ask me, this amounts to admitting that static checking of
exceptions is useless at best, which is something that the C++ standard
designers seem to have grasped from the beginning. If I remember
correctly, James Kanze used to point out that Java programmers tend to
derive their user-defined exceptions from RuntimeException because code
using checked exceptions quickly becomes unmanageable.
This raises the question what checked exceptions are good for at all. My
guess is it's situations that one would normally handle using return
codes in C++.
Also, I am unsure of the quality guaranteed by the language. Example:
(C++ used as example to avoid excessive number of classes):
bool is_small_prime(int i) { return i == 2 or i == 3 or i == 5; }
void f(int i) { if (is_small_prime(i) throw Exception("Ups"); }
void never_throws(int i) throw()
{
if (!is_small_prime(i))
f(i);
}
Will the compiler complain about the signature of never_throws? My
guess is that it will and thus you must write a swallowing catch which
in my opinion is bad for releability.
My own Java experience is marginal, but the way I interpret 11.2 in the
document cited above is that the compiler would complain about the
signature of f() because it misses an exception specification. Once this
is corrected, never_throws() would indeed have to wrap the call to f()
in a try/catch block. I think we agree that this is broken.
--
Gerhard Menzl
Non-spammers may respond to my email address, which is composed of my
full name, separated by a dot, followed by at, followed by "fwz",
followed by a dot, followed by "aero".
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]