Re: C++0x and Threads - a poor relation to Ada's tasking model?

[REH <spamjunk@stny.rr.com>]

On Aug 12, 4:41 pm, Robert A Duff <bobd...@shell01.TheWorld.com>
wrote:
> The philosophy has nothing to do with "explicitly".  And I don't
> understand why you said "potential".  If you leave out those two words,
> as in "you don't take a performance hit for exceptions or
> range-checking, unless you use them," then I would agree with you 100%.
>
> The point is, if you use some feature X, you should not have
> to pay the cost of feature Y that you do not use, just because
> feature Y exists, and might have some interaction with feature
> X in some other program that DOES use Y with X.
>
> C++ and Ada both share this philosophy.  It's called
> "avoid distributed overhead".

The reason I said "potentially" is you may or maybe pay the cost in
Ada, depending on the implementation. There are implementations where
you will always pay a speed penalty for exceptions (e.g., in setting
up the frame), and there are ones where you only pay if an exception
is raised (e.g., a table-based implementation). A C++ compiler will
not make me "pay" the cost of exceptions if I never make use of them.
What I mean by that is, if I don't have a try block, there will never
be any setup code to catch or propagate exceptions. In Ada, you may or
may not.

Similarly with range-checking. If I index an array in Ada, it may or
may not range check the index (a smart compiler can remove the check
if it can prove it cannot be out-of-range). C++ will not range check
the index. I have to do it explicitly (which is why I used that word),
or if I am using vectors, call the at member explicitly.


REH