Skip to main content

Swapping two integers in a one liner

I found some really cool one liner solutions to swap two integers without using a temporary variable. These were posted on "C/C++ Programming Puzzles" community on Some of them are listed here.

1. a+=b-=a=b-a;
2. a/=b=(a=a*b)/b;
3. a^=b^=a^=b; same as a=(b=(a=b^a)^b)^a; (Thanks to Robert Vukovic)
4. b=a+b-(a=b);

Each individually are cool solutions. But all of them have one big problem. These are not portable! C standard says that when a value of an operand is changed in the same expression at some other place, then the result of the expression is undefined. Try running the program on gcc with -Wall option. All the above one liners (which are really cool to begin with!) are plagued by that. So I feel the most portable way to achieve the goal is:

a = a xor b;
b = a xor b;
a = a xor b;
(by Harpreet)

Unfortunately it is not a one liner.


Anonymous said…
Here is one liner:

Anonymous said…
can u pls invite me to the orkut community?
Anonymous said…
Those are all undefined. Look up the phrase "sequence points".
Chris Bigart said…
Too bad using a temporary value will almost always be faster, as well as easier to read.
Sumant said…
I know! This is all for fun!
Anonymous said…
Please note that, apart from being cool, hard to read, and slower than a temporary value, most importantly, these constructs are *unsafe*, too.

Each of them has its own particular point of failure, but it's most obvious in the xor construct.

If a == b then this cool one-liner will put 0 in both a and b. Unless by mere coincidence a == b == 0 holds, this is not what you wanted.

Now, the problem is you cannot guarantee that a == b won't happen (except if they are both compile-time constants, which would make the whole thing absurd).
Errors like this are a real pain to track down. They burn many hours of precious developer time and are entirely unnecessary.

template//typename T\\ inline void swap(T& a, T& b) { T t = a; a = b; b = t; };
will let you swap two values in one line, too (the blog software won't let me write a proper template, but you get it)
Not only will it be faster, but it will also prevent people from throwing sharp things at you when they're asked to help you fix code that will occasionally crash and burn for no obvious reason.
Sumant said…
It is agreed that they are all hard to read, and all one liners completely overlook sequence point rules and therefore could possibly give compiler dependent answers. On gcc, all the XOR one-liners seem to be doing swapping correctly, even for a == b. But they are unsafe anyways. The one with a division, does not work for large integers and zero obviously.

The expanded (3 liner) version of XOR always yields a correct answer irrespective of the compiler used because it does not violate sequence point rules and hence it safe to use (even for a==b).
Anonymous said…
The portable one liner leverage comma operator:

a ^= b, b ^= a, a ^= b;

Built-in comma operator IS a sequence point.
sudeepdino008 said…

One liner in c++ for swapping 2 values.
Anonymous said…
thansk for sharing

Popular Content

Unit Testing C++ Templates and Mock Injection Using Traits

Unit testing your template code comes up from time to time. (You test your templates, right?) Some templates are easy to test. No others. Sometimes it's not clear how to about injecting mock code into the template code that's under test. I've seen several reasons why code injection becomes challenging. Here I've outlined some examples below with roughly increasing code injection difficulty. Template accepts a type argument and an object of the same type by reference in constructor Template accepts a type argument. Makes a copy of the constructor argument or simply does not take one Template accepts a type argument and instantiates multiple interrelated templates without virtual functions Lets start with the easy ones. Template accepts a type argument and an object of the same type by reference in constructor This one appears straight-forward because the unit test simply instantiates the template under test with a mock type. Some assertion might be tested in

Covariance and Contravariance in C++ Standard Library

Covariance and Contravariance are concepts that come up often as you go deeper into generic programming. While designing a language that supports parametric polymorphism (e.g., templates in C++, generics in Java, C#), the language designer has a choice between Invariance, Covariance, and Contravariance when dealing with generic types. C++'s choice is "invariance". Let's look at an example. struct Vehicle {}; struct Car : Vehicle {}; std::vector<Vehicle *> vehicles; std::vector<Car *> cars; vehicles = cars; // Does not compile The above program does not compile because C++ templates are invariant. Of course, each time a C++ template is instantiated, the compiler creates a brand new type that uniquely represents that instantiation. Any other type to the same template creates another unique type that has nothing to do with the earlier one. Any two unrelated user-defined types in C++ can't be assigned to each-other by default. You have to provide a

Multi-dimensional arrays in C++11

What new can be said about multi-dimensional arrays in C++? As it turns out, quite a bit! With the advent of C++11, we get new standard library class std::array. We also get new language features, such as template aliases and variadic templates. So I'll talk about interesting ways in which they come together. It all started with a simple question of how to define a multi-dimensional std::array. It is a great example of deceptively simple things. Are the following the two arrays identical except that one is native and the other one is std::array? int native[3][4]; std::array<std::array<int, 3>, 4> arr; No! They are not. In fact, arr is more like an int[4][3]. Note the difference in the array subscripts. The native array is an array of 3 elements where every element is itself an array of 4 integers. 3 rows and 4 columns. If you want a std::array with the same layout, what you really need is: std::array<std::array<int, 4>, 3> arr; That's quite annoying for