Operator overloading has been traditionally overused, especially in C++ (shift operators for iostreams, C++ iterators). Java was the peak of the push-back again

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.