Re: What's wrong with C++?

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

KK6GM wrote on comp.lang.ada:
> This is a serious question, seeking objective information.  I've
> worked with C for many years and I have a very good understanding of
> its weaknesses, which are many.  I haven't done nearly so much C++,
> and what I have done was not very intensive (didn't use a great many C+
> + features), so I don't have a good understanding of its weaknesses.
>
> So, without turning into a bash-fest, what are some general-consensus
> weaknesses or failures or problems with C++?  Comparisons with Ada are
> welcome but not required.  And my focus is in the embedded & real-time
> arenas, FWIW.

The keyword "virtual".

If you forget it, you get static dispatching instead of dynamic
dispatching and the compiler cannot tell you whether that's right or
wrong.  In Ada, any primitive operation of a tagged type is implicitly
and automatically "virtual", so you can't forget the keyword.  In C++,
one particular case of this language flaw is that you can forget to
make your destructors virtual; good luck debugging that later.

In C++, looking at the spec of a derived class, you can't tell which
methods are virtual (because they override an inherited virtual
method) and which are not.  You have to look at all the ancestor
classes to know.  In Ada, you can tell immediately without looking up
any ancestor types.

In C++, looking at a method call, you can't tell whether it dispatches
statically (non-virtual method) or dynamically (virtual method); you
must look it up in the declaration of the class *and* all its
ancestors.  In Ada, you can tell immediately: a call dispatches
statically if the actual parameter is of a specific type, and
dynamically if of a class-wide type.

In C++, you are required to use pointers or references to objects to
achieve dynamic dispatching.  This is wrong.  Pointers and references
should only be used for dynamic memory management and links between
objects, just like they are in Ada.  I find the following quite
confusing:

class C { virtual void foo(); };

C c;
c.foo(); // static dispatch
(&c)->foo(); // dynamic dispatch

The reason for this is that, in C++, all (implicitly declared) pointer
and reference types are (implicitly and always) class-wide, so always
dispatch dynamically; in contrast, objects are always of a specific
type, so cannot dispatch dynamically.  In Ada, the two concepts are
orthogonal; access types can be either specific or class-wide, and
types of objects can also be specific or class-wide.

--
Ludovic Brenta.