So do I, and it's definitely workable -- but not having RAII, operator
overloading, function overloading, templates and container types
really hurts.
Oh, please. At least to of the above tend to make code unreadable. I
mean, if you see the following line, for instance:
x = y++;
and the compiler doesn't warn on this line on highest level, then in C
we have a pretty limited set of possibilities, namely:
- x and y can both be arithmetic types
- x and y can both be pointers to the same type
- x can be a void* and y can be a typed pointer
- x or y can be preprocessor macros, though in this case that would
really be bad... oh wait, there's at least one instance of it in my
system library:
#define errno (*__errno_location())
C++ adds:
- x or y can be class instances, in which case:
- there might be a typeof y:
perator++() which is then called
- there might be an operator++(typeof y) defined somewhere else
- there might be typeof x:
perator=(typeof y&)
- there might be operator=(typeof x&, typeof y&)
- typeof x might have an implicit constructor taking a typeof y
- typeof x might have an implicit constructor taking whatever
typeof y:
perator++() or operator++(typeof y) return
- I don't know exactly about this one, but operator++(typeof y) might
even return a class instance that has an operator(typeof x)(), IIRC
- even if they aren't class instances, we have:
- x might be a reference to typeof y
- y might be a reference to something
- x might even reference y, which means that this line invokes
undefined behaviour
- or y might reference x, which yields the same
As you can see, C++ blows this line all the way from "something will be
incremented and something else will store the old value" to "no friggin
idea what this line does! Might be anything. And I wouldn't even know
where to start looking"
As of yet I only saw one useful application of operator overloading and
references, and that was a typesafe printf() implementation (which
basically has the compiler choose the correct functions according to the
argument type and those functions then check whether the conversion
specification on the format string was correct).
Templates are yet another pothole to the learning programmer: Every
instanciation creates an entirely new and unrelated set of routines and
class variables. I mean, if I have:
class A { static int count; };
then there's only one A::count in the whole program. If I have
template <class T> class A {static int count; };
suddenly there's no bound to the number of A::counts in the program,
because there is _no_ A::count, but instead A<int>::count,
A said:
Ciao,
Markus
