(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.
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.)