>"Mostly we decided it was a bad idea."

We who? From where I stand people are fine with operator overloading where it makes sense and C++ is far from being the only language with this feature.

Problem comes when shitty programmers get orgasmic about some language feature and try to use it everywhere to everyone's detriment.

People don't appreciate how much of an impact C++ had on C#. People consider it a Java clone, but the first version had many features to support a large segment of C++ (COM) developers that Microsoft wanted to move to .NET. This brought a visible performance hubbub at the time which was often instigated by the folks more comfortable with C++, manual memory management, etc.

I thought we just decided C++ was a bad idea? :) (shhh, nobody tell the games guys)

Operator overloading has been traditionally overused, especially in C++ (shift operators for iostreams, C++ iterators). Java was the peak of the push-back against that. C# has operator overloading, but forbids many things that were possible in C++:

  * `operator=` and `operator ,`
  * `operator new` and `operator delete`
  * `operator +=` overloaded differently from `operator +`
  * `operator &&` and `operator ||` overloading works differently in C#, so that it preserves the short-circuiting behavior
  * `operator ++` only can be overloaded once in C#, with the compiler automatically handling the difference between pre- and post-increment

But more crucially, the C# standard library uses operator overloading only for types like `decimal` and `BigInteger`. C# programmers can go years without ever overloading an operator, while still profiting from it whenever they use `BigInteger`. It's very different from the C++ culture where

  * everyone needs to learn about how to overload `operator=` (for memory management)
  * the standard library encourage abuses of operator overloading such as shift operators for iostreams

It should be unsurprising novice programmers abuse operator overloading when the C++ language teaches them exactly that.

Except C++ didn't learn that operator overloading is bad. C++ learned that operator overloading for everything was bad.

The language kind of put itself into a corner when what C# calls `MoveNext` is called `++` (with two variants of course) and what C# calls `Current` is called `*`. Taking what mathematically worked for iterating an array and taking it piecemeal to define your syntax is the kind of operator overloading that is a bad idea.

Python has operator overloading now. (And as far as I know, always has.) Avoiding operator overloading was one of several weird, idiosyncratic decisions Java made.

Operator overloading in a language in which memory management is all manual would be more challenging. That doesn't really tell us about its suitability in a language with automatic memory management. We've had about 20 years of C# with operator overloading, and it's been totally fine.