# Thread: Which Operation is Faster "=" or "+=" ?

1. plus if you have come down to the point where you try to optimize such a trivial thing, chances are your doing something horribly wrong somewhere else.

2. Originally Posted by CornedBee
The functions are still the same, just with different parameter names, and will still not compile: now you're trying to assign the result of a*b+c, which is a double, to a pointer to double.

And the only way y=x and y+=x yield the same value is if y is 0. The right side, where your function is, has nothing to do with it.
Sorry, I'm not articulating this very well. Here is some code where += and = will produce the same result in many situations.
Code:
`			y = x;`
and
Code:
`			y += m;`

3. Originally Posted by Shakti
plus if you have come down to the point where you try to optimize such a trivial thing, chances are your doing something horribly wrong somewhere else.
The problem is to understand the difference between various numerical methods.

4. Sorry, I'm not articulating this very well. Here is some code where += and = will produce the same result in many situations.
Code:
`			y = x;`
and
Code:
`			y += m;`
Why do you think that? That would depend entirely on the values of x, y and m. Pick whichever makes sense.

Suppose you wanted to set y (initalized to 0) equal to x. Which would you do?
Code:
`y = x;`
Or
Code:
`y += x;`
I would choose the first, because then both me and others would understand what this code is meant to do.
I can't remember a single instance where I wondered: hm, should I do assignment or addition? - Eh, I'll pick whichever is faster.

5. Sorry tinman, but the point still stands. y = x and y += m do completely different things, so comparing which is faster makes little sense. Use the one that does what you want. If you want to add to y, use +=. If you want to ignore y's current value and assign to it, use =.

The only question that makes sense is this:
Code:
```y = 0;
// x = ?
y = x;```
versus:
Code:
```y = 0;
// x = ?
y += x;```
Those two code snippets do exactly the same thing (assuming normal addition semantics) only because y is 0 and adding x to 0 is the same as assigning x. However, in that case which version you use would depend on which is clearer given the context, not efficiency concerns.

Your question leaves out the y = 0, so it makes little sense. For example, if y is 5 and x is 10 you have this:
Code:
```y = 5;
x = 10;
y = x;
// y is now 10.```
versus:
Code:
```y = 5;
x = 10;
y += x;
// y is now 15.```
See... it doesn't matter which is faster, because they produce different results.

6. Originally Posted by thetinman
Are you sure? Wouldn't
Code:
`y = powf(x,2);`
always be slower than
Code:
`y = x*x;`
on all platforms, OSs, and in all languages?

But this reminded me of the reverse:
Code:
```#define ADDRESS 0x400

struct sType1
{
unsigned char c;
unsigned int  i;
} Object1 = {5,0};

struct sType2
{
unsigned char a;
unsigned char b;
unsigned char d[50];
unsigned int  e;
} Object2;

int foo(void)
{