defining operator + , = and +=

Question

I once read the following statement from a C++ notes,

In C++, defining operator + and = does not give the right meaning to +=. This language-design bug is fixed in C#

I would like to know what exactly does this statement want to say? Is that related to operator overload?

Answer 1

I prefer C++ operator overloading mechanism. It definitely not a design bug according to me.

+ , = and += are three different operators. If you want to use += you need to overload += . Overloading + and = won't make += work.

I would like to add that in E1 += E2 E1 gets evaluated only once as far as C++ is concerned. I don't know the exact rules in C#.

Answer 2

It says, that in C# if you have overloaded operator + C# automatically will emulate operator += as combination of + and = ( a=a+b is equal to a+=b ). In C++ it's not implemented, but it's not a bug. In C++ + and = doesn't give you += because mostly += works faster than +, because there is no need to create one more object.

That's why mostly operator + is writen using += operator. Consider fallowing code:

class foo
{
public:
   foo& operator+=(const foo& rhs)
   {
   //.......
   }
};
const foo operator+(const foo& lhs,const foo& rhs)
{
   foo temp = lhs;
   return temp+= rhs;
}

Answer 3

It means that in C++ if you defined your own operator + and operator = for your class, that still does not mean that your class will automatically support the += operator. If you want the += operator to work for your class, you have to define the += explicitly and separately.

In C#, if I understood it correctly, defining operators + and = for your class will also mean that you'll be able to use operator += with your class. The += will be "emulated" through combination of operator + and operator = . Eg expression a += b will be interpreted as a = a + b .

It doesn't work that way in C++. If you don't define the += explicitly, a += b will result in compiler error, even if you have + and = defined.

Answer 4

C# does not allow operator overloading = since it does not allow direct pointer management. Its behavior is fixed based on whether it is reference or value type. For the same reason you cannot overload += . It's meaning will always be doing the sum and assignment. You can only therefore decide what the meaning for + is to your datastructure.