I stumbled into this code for swapping two integers without using a temporary variable or the use of bitwise operators.
int main(){ int a=2,b=3; printf("a=%d,b=%d",a,b); a=(a+b)-(b=a); printf("\na=%d,b=%d",a,b); return 0; }
But I think this code has undefined behavior in the swap statement a = (a+b) - (b=a);
as it does not contain any sequence points to determine the order of evaluation.
My question is: Is this an acceptable solution to swap two integers?
The idea is to get a sum in one of the two given numbers. The numbers can then be swapped using the sum and subtraction from the sum.
Example: Suppose, there are two numbers 25 and 23. X= 25 (First number), Y= 23 (second number) Swapping Logic: X = X + Y = 25 +23 = 48 Y = X - Y = 48 - 23 = 25 X = X -Y = 48 - 25 = 23 and the numbers are swapped as X =23 and Y =25.
Using swap(): C++ library function. b = (a + b) – (a = b); a += b – (b = a);
No. This is not acceptable. This code invokes Undefined behavior. This is because of the operation on b
is not defined. In the expression
a=(a+b)-(b=a);
it is not certain whether b
gets modified first or its value gets used in the expression (a+b
) because of the lack of the sequence point.
See what standard syas:
If a side effect on a scalar object is unsequenced relative to either a different side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined. If there are multiple allowable orderings of the subexpressions of an expression, the behavior is undefined if such an unsequenced side effect occurs in any of the orderings.84)1.
Read C-faq- 3.8 and this answer for more detailed explanation of sequence point and undefined behavior.
1. Emphasis is mine.
My Question is - Is this an acceptable solution to swap two integers?
Acceptable to who? If you're asking if it is acceptable to me, that would not get past any code review I was in, believe me.
why is a=(a+b)-(b=a) a bad choice for swapping two integers?
For the following reasons:
1) As you note, there is no guarantee in C that it actually does that. It could do anything.
2) Suppose for the sake of argument that it really does swap two integers, as it does in C#. (C# guarantees that side effects happen left-to-right.) The code would still be unacceptable because it is completely not obvious what its meaning is! Code shouldn't be a bunch of clever tricks. Write code for the person coming after you who has to read and understand it.
3) Again, suppose that it works. The code is still unacceptable because this is just plain false:
I stumbled into this code for swapping two integers without using a Temporary variable or the use of bit-wise operators.
That's simply false. This trick uses a temporary variable to store the computation of a+b
. The variable is generated by the compiler on your behalf and not given a name, but it's there. If the goal is to eliminate temporaries, this makes it worse, not better! And why would you want to eliminate temporaries in the first place? They're cheap!
4) This only works for integers. Lots of things need to be swapped other than integers.
In short, spend your time concentrating on writing code that is obviously correct, rather than trying to come up with clever tricks that actually make things worse.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With