Re: Why do some code bases don't use exceptions?
On Nov 17, 8:43 pm, Paavo Helde <myfirstn...@osa.pri.ee> wrote:
krel <k...@example.invalid> wrote innews:hduq8e$4f9$1@news.eternal-
september.org:
James Kanze wrote:
Today? Except possibly for very small embedded systems.
Fear, uncertainy and doubt about compiler support, maybe,
but exceptions are probably more stable than templates or
RTTI today.
I probably should have added RTTI and templates to my
original question but I as I understand from your answer the
main reasons for companies not to use exceptions, templates
or RTTI are:
1) Lack of compiler support
2) Does not integrate well with old code
Is that right?
(1) might be an issue, but actually it should not, after
having the C++ standard around for more than 10 years already.
Yes and no. How many compilers do you know that implement
standard conforming templates (including export)? It is still
an issue.
In the end, you weigh the advantages and the disadvantages, and
make a choice. Not using std::vector, and having to use
<generic.h> for your own generic classes, makes banning
templates completely a non-starter, regardless of how poorly
they are (typically) implemented.
Regarding (2), RTTI and templates are local features, so the
integration should be no big concern.
Exactly. The "existing code" argument mainly affects
exceptions, and not much else.
What I mean is that the reasons are not related to the
actual functionality of the feature, as in "X is a broken
and badly designed feature".
In C++, there are surprisingly few "broken and badly designed
features".
That's very arguable. The question isn't so much whether C++
does it right; it's usually a question of other languages not
supporting it at all.
Non-empty exception specifications are one example,
Broken and badly designed, or simply a more or less good
solution without a problem?
the "most-vexing-c++- parse" another. The latter was kept for
C compatibility, but I strongly suspect the amount of C code
saved this way is very close to zero.
Are you kidding? Take a look at any of the C headers on your
machine. How many systematically use "extern" before function
declarations, and how many just count on the fact that a
function declaration is always "extern", unless specified
otherwise.
Regarding Google, maybe they might have banned exceptions
because of the run-time overhead (just guessing). Throwing
exceptions is notoriously slow, so they should not be used
unless something goes very wrong - but for a 24/7 service like
Google nothing should go wrong ever, so no need for
exceptions, right?
If something truely goes wrong, you should have an assertion
failure, not an exception. Exceptions are for things that
exceptionally occur:-). Seriously, exceptions are the preferred
solution when the error is expected, but very infrequently, and
cannot reasonably be handled locally, by the calling function.
(Depending on context, I imagine that something like a dropped
connection could be reasonably reported by an exception. And it
would certainly be unrealistic for Google to expect never to see
one of those.)
--
James Kanze