+= Operator in C++

Question

Someone please tell me the difference between the following codes which add two variables of datatype int. I want to know which one is better.

Code A:

sum = sum + value;

Code B:

sum += value;

We usually prefer ++ operator over += 1. Is there any specific reason behind that as well ?

I want to know the difference between the above codes with respect to the conventions or efficiency level. Which one is recommended ?

Answer 1

While the end result of the e.g. someVar++ operator is the same as someVar += 1 there are other things playing in as well.

Lets take a simple statement like

foo = bar++;

It's actually equivalent (but not equal) to

temp = bar;
bar += 1;
foo = temp;

As for the prefix and suffix increment or decrement operators, they have different operator precedence, which will affect things like pointer arithmetic using those operators.

---

As for the difference between

foo += 1;

and

foo = foo + 1;

there's no different for primitive types (like int or float) or pointer types, but there's a very big difference if foo is an object with operator overloading. Then

foo += 1;

is equal to

foo.operator+=(1);

while

foo = foo + 1;

is equal to

temp = foo.operator+(1);
foo.operator=(temp);

Semantically a very big difference. Practically too, especially if any of the operator overload functions have side-effects, or if the copy-constructor or destructor have some side-effects (or you forget the rules of three, five or zero).

Answer 2

One calls operators = and + the later calls operator +=.

operators ++ and += are preferred because of readability - most programmers know what they mean.

On the other hand most modern compilers will generate the same code for += 1 as ++ and +/= as += for builtin types;

But for user defined classs, the actual operators will be called and it's up to the implementer of those classs to make sense of it all. In these cases ++ and += can be optimal.

Answer 3

cout << sum++; Would print out the value of sum before it was incremented. Also, depending on what you are doing, you can overwrite the operators += and +.

Answer 4

When you minimize code, you reduce the chance of an error (a typographical error or a logical error).

By using

sum += value;

you reduce the chance - ever so slightly - of an error while typing

sum = sum + value;

The same with value++;

value += 1;

could be more easily confused with

value += l; where l is a variable....

Its more about consistency that it is about right or wrong, but reducing code is a major bonus for maintainability.

Care must be taken with precendence of operators however, in complex statements.

Answer 5

In the case shown there's no particular reason to prefer one method of incrementing the value over another except perhaps for readability purposes. In this case I think I'd prefer sum += value over sum = sum + value as it's a bit briefer and (I think) clearer, but YMMV on that.

As far as prefering ++ over += 1, (IMO again) ++ is preferable when incrementing a value as part of an expression, e.g. sum += array[index++] - but if the entire point of what's being done is adding one to a value I'd prefer index += 1. But let's face it, a great deal of this is personal preference and spur-of-the-moment choice. I always try to write what I think, at that moment, is the simplest and clearest code possible - but I must admit that when I go back and read some of my own code later I have more "What was I thinkin'?!?" moments than I'd care to admit to. :-)

YMMV.

Best of luck.

Answer 6

Code A and B do the same thing. The advantage to using Code B is that it's quicker to type and easier to read.

As for using the ++ operator over += 1, again it is for readability. Although there is a difference between foo++ and ++foo. The former is read first and then incremented, while the latter is incremented first and then read from.

Answer 7

A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once.

An example cited from Java's +=, -=, *=, /= compound assignment operators

[...] the following code is correct:

short x = 3;
x += 4.6;

and results in x having the value 7 because it is equivalent to:

short x = 3;
x = (short)(x + 4.6);

Answer 8

Its basically the same thing. Its both an operator.

One of it calls = and +. And the other +=..

So if you did value +=5. Value goes up by 5. += is better and more organized. And shortens your code whitch is better and more professional.

Answer 9

There is no difference between the two in terms of functionality. A += B actually means A = A + B. The first one is just a shorter way of writing the second.

Answer 10

They both are same up to that, both can be used for incrementing the value of a variable (stored in it).

x++ will increment the value of x by one (1) every run time.

+= adds right operand to the left operand and stores the result in left operand. Something like following: C += A is just same as C = C + A

The difference between both ++ and += is that the first can increment by one (1) only, while += can be used to increment more than one in just one line.

e.g:

x += 1; // will increment by 1 every run time
x += 4; // will increment by 4 every run time
x += 10; // will increment by 10 every run time