What is the point of nothrow?

Jonathan M Davis newsgroup.d at jmdavisprog.com
Mon Jun 11 00:47:27 UTC 2018


On Sunday, June 10, 2018 23:59:17 Bauss via Digitalmars-d-learn wrote:
> What is the point of nothrow if it can only detect when Exception
> is thrown and not when Error is thrown?
>
> It seems like the attribute is useless because you can't really
> use it as protection to write bugless, safe code since the nasty
> bugs will pass by just fine.
>
> I'm aware that it's a feature that nothrow can throw Error, but
> it makes the attribute completely useless because you basically
> have no safety to guard against writing code that throws Error.
>
> To an extend @safe works, but there are tons of stuff that throws
> Error which you can only detect and guard against manually.
>
> So what is the point of nothrow when it can only detect
> exceptions you'd catch anyway.
>
> To me it would be so much more useful if you could detect code
> that could possibly throw Error.

Why do you care about detecting code that can throw an Error? Errors are
supposed to kill the program, not get caught. As such, why does it matter if
it can throw an Error?

Now, personally, I'm increasingly of the opinion that the fact that we have
Errors is kind of dumb given that if it's going to kill the program, and
it's not safe to do clean-up at that point, because the program is in an
invalid state, then why not just print the message and stack trace right
there and then kill the program instead of throwing anything? But
unforntunately, that's not what happens, which does put things in the weird
state where code can catch an Error even though it shouldn't be doing that.

As for the benefits of nothrow, as I understand it, they're twofold:

1. You know that you don't have to worry about any Exceptions being thrown
from that code. You don't have to worry about doing any exception handling
or having to ensure that anything gets cleaned up because of an Exception
being thrown.

2. If the compiler knows that a function can't throw an Exception, then it
doesn't have to insert any of the Exception handling mechanism stuff that it
normally does when a function is called. It can assume that nothing ever
gets thrown. If an Error does get thrown, then none of the proper clean-up
will get done (e.g. constructors or scope statements), but because an Error
being thrown means that the program is in an invalid state, it's not
actually safe to be doing clean-up anyway. So, the fact that a function is
nothrow gives you a performance benefit, because none of that extra
Exception handling stuff gets inserted. How large a benefit that is in
practice, I don't know, but it is a gain that can't be had with a function
that isn't nothrow.

- Jonathan M Davis



More information about the Digitalmars-d-learn mailing list