Hi all,
Can any one tell the difference between the following.
a++
a+=1
Both will do the same operation.I want to know that any one of these have a advantage than the other.
Printable View
Hi all,
Can any one tell the difference between the following.
a++
a+=1
Both will do the same operation.I want to know that any one of these have a advantage than the other.
While ++a and a++ mean the same thing when they form statements independently, they behave differently when they are used in expressions on the RHS of an assignment statement.
For eg.
a=5;
y=++a;
In this case the value of y would be 6. But in this case
a=5;
y=a++;
here y would be 5 but a would be 6
On the other hand a+=1 is shorthand form of a=a+1.
Thank you BEN10.But already I know what you explained.I want to know whether both of these statement have some difference in the case of speed or not.
They are two different kinds of operators. ++ is a unary operator (whether x++ or ++x). += is an assignment operator. I doubt there is much difference in speed but I don't know. The potential use value is slightly different:
Code:x += y++;
I'd say that it depends on compiler optimisations.
I'm guessing that ++x would be translated by most compilers into the assembly 'INC' (increment) instruction mnemonic, which may or may not be faster than 'ADD'.
If a compiler optimises any code with a 'x + 1' to the increment instruction then there would be no difference.
Same goes for decrementing.
Note that this is just speculation. I don't know if any of this is what actually happens.
Assignment operators evaluate the l-value only once, which is an important thing to watch out for if it contains any side effects.
Eg.
array[i++] += 1;
will do the right thing.
Either of these attempts leads to all sorts of trouble.
array[i++] = array[i] + 1;
array[i++] = array[i++] + 1;
Doing it correctly the long way is hard work.
array[i] = array[i] + 1;
i = i + 1;
There would certainly be a big performance difference if you had
array[someFuncReturningIndex()] += 1;
because the function would only be called once.
@Salem: good use of fonts :p
Just an FYI,
I read about the origin of "C", and how the compiler favored the reigning hardware platform of that time - PDP family of minis. So the post-increments and similar had a reason for being part of the language. There were native machine instructions of that ilk: access-then-increment. I haven't encountered any micro processors which had similar instructions but then again, the desired effect can be achieved with two instructions at most.
Both VAX (32-bit version of PDP-11 really) and 68000 have post-increment and pre-decrement versions of it's instruction set. I'm fairly sure that ARM's instructions also matches the C language fairly well with it's STR/LDR instructions when setting the P and W bits to one of the instruction.Quote:
Originally Posted by nonoob
--
Mats
Thank you! I stand corrected. I forgot about Motorolas. Never could wrap my head around 6800, 68000 addressing, registers, but probably the assembly syntax turned me off most of all. I'm a Zilog/Intel guy myself. :)
x++ doesn't mean that the increment value is 1, it can be anything, so the use of something like "INC" is a very special case.Quote:
Originally Posted by DeadPlanet
Stephane.
It doesn't? How do you set it to increment by something else?Quote:
x++ doesn't mean that the increment value is 1, it can be anything
>> x++ doesn't mean that the increment value is 1, it can be anything, so the use of something like "INC" is a very special case.
Well, the only other case is in pointer arithmetic, where the increment means "advance sizeof(type) bytes from this offset". Besides that, though, I can't think of any other possible forms.
Back to the original question... even in the case of pointer arithmetic a++ and a+=1 would still be equivalent. If a compiler generates markedly different machine code which varies in execution times, then shame on it!
Yes Sebastiani, I was referring to pointer arithmetic which I think it is important to mention, since the ++ operator comes from the PDP 11 autoincrement mode : (Rn)+ (see Department of Computer Science - PDP-11 - Don S. Bidulock).
Often the question asked is "which is faster, x++ or x += 1 ?". In that case it's important to remember that "1" can be any other value (since an incrementer != adder).
a++ is a unary operator a+=1 is a binary operator.Quote:
Originally Posted by karthigayan
Example:
unary: a++ it has only one operant.
binary: a+b it had two operant "a" and "b".
I don't know if theres a difference between x++ and x += 1, but there is a difference between the post and pre-increment operators. ++x is actually faster than x++ since the latter requires the original values of x to be stored in a temporary variable and then returned. This is not so much a problem with primitives like int etc since the compiler will optimize it anyway.
Note that C does not allow user defined operator overloading.Quote:
Originally Posted by rocketman03
I read a while ago that, for modern x86 processors, "add some_register, 1" is actually faster than "inc some_register". As a result, GCC will never generate the "inc" instruction, at least if you tell it to optimize for any modern processor.