### 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 www.orkut.com. 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.

Robert Vukovic said…
Here is one liner:

j=(i=(j=i^j)^i)^j;
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…
a^=b^=a^b;

One liner in c++ for swapping 2 values.
ankit s sachan said…

http://programmergallery.com/c-program/c-program-swap-two-numbers.php
manho valentine said…
thansk for sharing
gclub

### 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 two r…

### Inheritance vs std::variant

C++17 added std::variant and std::visit in its repertoire. They are worth a close examination. I've been wondering about whether they are always better than inheritance for modeling sum-types (fancy name for discriminated unions) and if not, under what circumstances they are not. We'll compare the two approaches in this blog post. So here it goes.

Inheritancestd::variantNeed not know all the derived types upfront (open-world assumption)Must know all the cases upfront (closed-world assumption)Dynamic Allocation (usually)No dynamic allocationIntrusive (must inherit from the base class)Non-intrusive (third-party classes can participate)Reference semantics (think how you copy a vector of pointers to base class?)Value semantics (copying is trivial)Algorithm scattered into classesAlgorithm in one placeLanguage supported (Clear errors if pure-virtual is not implemented)Library supported (poor error messages)Creates a first-class abstractionIt’s just a containerKeeps fluent interfaces…

### 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 c…