On Saturday, 10 October 2020 at 18:16:45 UTC, Ali Çehreli wrote:
On 10/10/20 9:16 AM, DMon wrote:
> catch (Exception e) // implicit (any exception)
> catch (ConvException f) // explicit (conversion only)
>
> Or is that not correct?
I think in class hierarchies, "more general" and "more
specific" are better terms. :)
The answer is, catch by the most general under the Exception
hierarchy that you care about. It depends on the program. In
most of my programs, catching Exception in main is sufficient
because I just print the error message.
However, sometimes the error message does not make sense at
that level:
So, you can augment that error with another one:
One cool thing about storing the 'actual' exception is, you can
later debug it by catching the specific FooException and
printing 'actual' as is, which contains the stack trace:
But really, it all depends on your program. The simplest thing
may to not catch at all. The default behavior is to dump the
stack trace and it works for some programs.
Ali
I will copy that down.
The idea for specific exceptions came from the online docs and
Programing in D, 39.2 The try-catch statemet
try
{ // the code block that is being executed, where an // exception
may be thrown
}
catch (an_exception_type)
{ // expressions to execute if an exception of this // type is
caught
}
catch (another_exception_type)
{ // expressions to execute if an exception of this // other type
is caught // ... more catch blocks as appropriate ...
}
finally
{ // expressions to execute regardless of whether an // exception
is thrown
}
This is where I'm at:
import std.stdio;
import std.conv;
// StdioException
// ConvException
// StringException
// ErrnoException
// FormatException
// UnicodeException
// UTFException
// FileMissingException
// DataCorruptionException
// FE_INEXACT
// FE_UNDERFLOW
// FE_OVERFLOW
//
int main()
{
string z1 = "+ "; string z2 = "++ ";
bool a1 = false; bool a2 = true;
int b1 = 0; int b2 = 1;
uint c1 = 0; uint c2 = 1;
float d1 = 1f; float d2 = 2f;
char e1 = 'a'; char e2 = 'b';
int o1; int o2;
// auto test;
int[3] ar1; int[5] ar2;
string st1 = "arg";
writeln("Control\n\n");
/*
writeln("Testing");
try
{
writeln(z1 ~ e1 ~ st1);
writeln();
}
catch (Exception y1)
{
writeln("Something ", y1.msg,
y1.info);
}
*/
writeln("try...catch");
try
{
o1 = to!int("hello");
}
catch (Exception i1)
{
writefln(z1 ~ "Message from exception i1: %s", i1.msg);
writefln(z1 ~ "Info from exception i1: %s", i1.info);
}
writeln();
writeln("try...finally");
try // Will run as normal code.
{
o1 = a2 + b2;
writeln(z1 ~ "", o1);
}
finally
{
writeln("Continues to run normally and no exceptions are
displayed.");
}
writeln();
writeln("try...catch...finally");
try
{
to!int(z1);
to!int(z2);
}
catch (ConvException j1)
{
writefln(z1 ~ "1st Exception msg: %s", j1.msg);
writeln();
}
catch (Exception k1)
{
writeln(z1 ~ "2nd Exception msg: %s", k1.msg);
}
finally
{
writeln(z1 ~ "There are two exceptions.");
writeln(z2 ~ "The first exception is caught and that,
immediately, exits the try clause.");
}
writeln("This still runs.");
writeln();
/*
writeln("Nesting");
try
{
*/
return 0;
}
