Re: Undefined behaviour [was Re: The D Programming Language]
Ian McCulloch wrote:
Kevin Hall wrote:
Ian McCulloch wrote:
David Abrahams wrote:
There's no
reason in principle that a C++ system couldn't be written that
immediately detects way, _way_ more of the errors that lead to
undefined behavior and invokes a debugger immediately. Every pointer
dereference could be fully checked, for example.
Right - and there are systems that already do this. Valgrind (
http://www.valgrind.org/) springs to mind at this point. In the face of
a programming error, you want as much `undefined' behaviour as possible,
to give the tools that detect such behaviour the most information
possible.
I think valgrind is the single most useful debugging tool on Linux, even
though I don't use it that often, much less frequently than a debugger,
or
even printf() debugging[*]. AFAIU valgrind would be completely useless
for debugging java programs, which leaves a few possibilities: (1) the
Java (or D?) language design is such that bugs that are typically caught
by valgrind would never be made in the first place, or (2) Java debuggers
already cover this functionality, or (3) Java programs are harder to
debug than C++ programs. I wonder which?
And it is possible that someone could write a debugging version of the
JVM that could do the similar things -- break into a debugger when an
out-of-bounds access occurred. Then the user could decide to debug or
to continue and allow the standard out-of-bounds exception to be
thrown.
Unfortunately, to the best of my knowledge, noone has created such a
JVM.
How do you debug a Java program then? The location where the exception is
actually caught might be far away from the location of the bug. Is the
context information propogated somehow as part of the exception?
But of course. In Java, all exceptions must derive from
Throwable. Which has a member functions getStackTrace,
printStackTrace, etc.
This is of course relevant to C++ (yes mods, really it is!) because throwing
an exception is sometimes advocated as the correct thing to do in the case
of a programming error (and hence the existence of std::logic_error). I
regard that practice, at best, dubious and probably misguided.
I thought that there was more or less a consensus about this.
In the Java community, it's one size fits all, whereas in the
C++ community, I thought it was pretty much recognized that
different types of errors are, well, different. Some are best
handled by return codes, others by exceptions, definite
program errors should usually result in an abort, and there are
special cases where other strategies apply as well.
It's my feeling as well that if you need the stack walkback,
it's probably not the type of error which should be handled by
an exception.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]