Swapping two integer numbers with no temporary variable

You make assumptions which may not be true. Why do you believe that

int tmp = a;
a = b;
b = tmp;                                  

actually is compiled down to using an actual variable? It is likely just a register used on the CPU.

Have you inspected it?

Further, why do you assume that:

a ^= b ^= a ^= b;

uses fewer registers than a swap?

Really, what you should do is:

#include <algorithm>
#include <iostream>

int main() {

    int a = 20;
    int b = 66;

    // before swapping
    std::cout << a  << ' ' << b  << '\n';

    // swap
    std::swap(a,b);

    // after swapping
    std::cout << a << ' ' << b << '\n';

}

Which is also a reminder that having the a ^= b ^= a ^= b; 'naked' in your code is not good practice. Something like that should be embedded in a function, not directly in the main method.

Update - assembler output

For the code:

int a = 20;
int b = 66;

int t = a;
a = b;
b = t;

return a;

you get the assembler output:

movl    $20, -12(%rbp)
movl    $66, -8(%rbp)
movl    -12(%rbp), %eax
movl    %eax, -4(%rbp)
movl    -8(%rbp), %eax
movl    %eax, -12(%rbp)
movl    -4(%rbp), %eax
movl    %eax, -8(%rbp)
movl    -12(%rbp), %eax
popq    %rbp

For the code:

int a = 20;
int b = 66;

a ^= b ^= a ^= b;

return a;

you get

movl    $20, -8(%rbp)
movl    $66, -4(%rbp)
movl    -4(%rbp), %eax
xorl    %eax, -8(%rbp)
movl    -8(%rbp), %eax
xorl    %eax, -4(%rbp)
movl    -4(%rbp), %eax
xorl    %eax, -8(%rbp)
movl    -8(%rbp), %eax
popq    %rbp

What does that show?

• It shows that both systems run in 12 instructions, including the copy to the stack (%rbp)
• that both systems use the single register %eax
• both systems use the stack as a temp store for the result (the XOR reuses -8 and -4 offsets in the stack, the tmp uses -12(%rbp)

Net result? Both systems use less than 16 bytes of the stack, they both use 1 register in addition to the stack, and they both have the same number of instructions.

I know which one is more readable....

Of course, with the above code, if I add -O2 to the optimization, I get the assembler:

movl    $66, %eax
ret

which, as you can imagine, is fast.