Yes, that is sarcasm. I just spent two days doing something in C++ that would take two minutes in C. I need to do calculations with phase angles of electromagnetic signals. In particular, I need to calculate the difference in phase angle between two samples (i.e., subtract two angles). Now we treat phase angles as being in degrees from 0 to 360. Yes, you could argue we should use radians, or make the range positive and negative, but it really doesn't matter. I need to subtract angles. The problem, of course, is the wrap-around from 360 to 0. So 359 - 1 should equal -2, not 358. There are various ways to handle this, but the fancy way is to take the sine of the difference, the cosine of the difference, then the arc tangent (atan2) of those to get the phase angle difference. And that's what I've done in C in the past, making a subtract_angles function which takes two floats and returns a float with the difference. It's simple and it works. But now I'm using C++, so hey, I can do this in a class and overload operator-. So I start making my Angle class, with constructor, copy constructor, copy assignment operator, and destructor. (This is already 10 times the size of my one-line subtract_angles C function.) Then I turn my attention to overloading operator-. So I look online for the proper syntax, and I find four different web pages telling me four different ways to do it. Oh Gawd. So I start to write that, then I realize I also need to overload operator-=. More looking online, and I discover that you make a member function for operator-=, then make a non-member function for operator- which uses operator-=. So I get that working, and I can write something like this: Code (Text): Angle a(10.0f); Angle b = a - 20.0f; But wait! I can't write Angle b = 20.0f - a. Aw, jeez. More looking online, and I see there's a different way to write the operator- overload which allows a numeric literal to be used on the left hand side. (The Angle class constructor kindly conjures up an Angle object from the literal.) OK, now we're cooking with gas. Let's try b = 20.0f + a. That doesn't work, because there's no operator+ defined. Wonderful. So then I declare a conversion function to go from Angle to float, so the 'a' gets converted to a float, does a regular floating point add, then the constructor turns it back into an Angle object. Oh, but now my operator- overload doesn't work, because it doesn't know whether to use the normal subtract or my overloaded subtract. But this can be handled by making the constructor for Angle 'explicit'. But that breaks the add and subtract functions. So then I need to do stuff like b = Angle(20.0f) - a and b = Angle(20.0f + a) because otherwise it doesn't use the Angle constructor to make an Angle object from a numeric literal. And this is supposed to be easier than a one-line C function? What a load of crap. I haven't decided which way to go with this yet. With the class and the overloading and the conversion and the explicit, it's not clear to the user what is actually going on and which versions of which functions are being used. Do my co-workers really want to trust that I haven't made some mistake in defining this? The good news is I'll be leaving in a couple months and someone else will have to deal with this. I can't believe anyone actually thinks C++ is a good idea. 60 years of high-level language development and we end up with C++?