No it doesn't. C++ wants to be a multi-paradigm programming
langauge, supporting many different paradigms, including object
oriented programming. Many (not all) of the criticisms of it
come from people who insist that only one paradigm is good, and
are upset with C++ because it doesn't impose that paradigm. In
practice, the more tools you have in your workbox, the more
effective you can be (provided you know how to use them). For
any given paradigm, C++ is probably a bit harder to use than a
language dedicated to only supporting that paradigm, but it has
the advantage of not imposing any one paradigm, and letting you
use which ever one is most appropriate to the problem at hand.
Having said that: let's look at where your quotes are coming
from.
The term was coined by Alan Key, but has gone one to acquire a
life and a meaning of its own, beyond what he originally
conceived of. In particular, Key's OO was very much dynamically
bound, with inheritance only for implementation; almost all
serious OO languages today use static type checking, with
inheritance mainly of implementation. Arguably, these are two
different things, and a different word should have been chosen,
but it wasn't. (Meyer once defined OO in a way that it couldn't
be done in Smalltalk
.)
Note that Key was the inventer of Smalltalk. (Interested party,
so to speak.)
That's rather obvious, since C++ didn't exist at the time. More
to the point, Key was very much thinking in terms of dynamic
type checking (as in Lisp); as I said, the word has evolved, and
most people associate it with languages with static type
checking: Java and Eiffel, if not C++.
I'm not too sure how to take that (except maybe as sour grapes):
Key obviously was playing with Smalltalk (and probably Lisp,
given the influence of Lisp on Smalltalk) long before C++ was
even invented.
I'm not familiar with any of the above people, but I'd be
interested in knowing more about the context in which they are
speaking. *IF* the goal is to teach OO as the unique solution,
and as an end in itself, then no, C++ is not the ideal language.
If the goal is to teach effective programming, using OO when
appropriate, other languages when appropriate... C++ probably
isn't the ideal language, either, but none of the others are
very good either. It's a real problem; in some ways, I'd argue
that the first programming course should still be taught in
Pascal (but that's just showing my age). In other ways, I'd
argue that the language isn't that important in itself: the best
book on programming (in general) that I know is by far
Stroustrup's: _Programming Principles and Practice Using C++_.
And one of the main reasons is in the title: it insists on the
principles and practice, reducing the language (C++) to the role
of a tool (which is what it should be). He could rewrite the
book to use Java (or Lisp, or just about any other language)
without major modifications.
Bertrand Meyer is the inventor of Eiffel. And he's very
dogmatic; you could replace C++ with any other language except
Eiffel in the above, and he would probably agree. As I said,
I've read a paper in which he proves not only that you can't
really do OO in C++, but that you can't do it in Smalltalk
either. (Meyer's contributions to software engineering are not
to be underestimated, but I do wish he'd be less dogmatic about
Eiffel.)
Given the quality of Linux, I don't think you can quote Linus on
software engineering issues.
