Swapping two integer numbers with no temporary variable

This is valid C++. You can also write

a ^= b ^= a ^= b;

as

a ^= (b ^= (a ^= b));

or

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

In C++, an assignment always returns the result. So in general,

i = 1
use(i);

can always be replaced with

use(i = 1);

where use is some expression using i singly (i.e. not something like i*i).

A reason not to write it that way though is that it is somewhat harder to read. It's usually easier to read multiple statements rather than try to crowd everything into one expression. It's very rare these days for source code size to matter, and it is generally better to optimize for ease of reading rather than speed of writing. In practice, you will find that you read code more often than you write it.

Note: as rolfl noted, this trivial application is unnecessary. I'm ignoring that and assuming that you have a reason to implement it this way. The only question that I'm addressing is how it should be written.

The fastest way to do this would be

int main()
{
    int a = 20;
    int b = 66;

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

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

Of course, that relies on the fact that you never use the variables again. However, a good compiler might well compile the std::swap version into the same code as that. It's unlikely that even a good compiler will compile out a ^= b ^= a ^= b; even though in this example it is just as unnecessary.

This is not valid C++, unless you consider code that allows a conforming compiler to wipe your hard drive, conjure nasal demons and make your cat pregnant to be valid C++.

This statement

a ^= b ^= a ^= b;

invokes undefined behavior. Pre-C++11, it modifies a twice without an intervening sequence point, which causes undefined behavior. Post-C++11, the rules are more complex, but the result is the same. I'm not really inclined to write a full analysis since the subject has been beaten to death multiple times on StackOverflow, but it is essentially identical to the analysis for i += ++i + 1; in this SO answer.

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

This would be valid C++, and the well-known XOR swap trick. However, it generally is not a performance improvement, and decreases the readability of your code.

Assuming that a+b is less than the maximum size of an integer on your system, why not try a simpler solution?

a = a + b 
b = a - b
a = a - b

For example

Initial
a = 2
b = 4

a = a + b
a = 2 + 4
a = 6

b = a - b
b = 6 - 4
b = 2

a = a - b
a = 6 - 2
a = 4

Final
a = 4
b = 2