Today’s lab was simple on paper:
Swap two variables.
I’ll be honest… when I saw the assignment, I thought,
“Alright… this is basic.”
int a = 5;int b = 10; int temp = a;
a = b;
b = temp;
Done.
But then I tried to shortcut it.
a = b;
b = a;
And it immediately broke. That’s when it clicked. The problem isn’t the swap.
It’s understanding what’s happening in memory at every step.
When I overwrite <code>a</code>, its original value is gone. There’s no rewind button. Programming is brutally literal like that it does exactly what you say, not what you mean.
That’s when the “temporary variable” stopped feeling like beginner fluff and started feeling necessary.
Then I went down the rabbit hole.
Arithmetic swap:
a = a + b;
b = a - b;
a = a - b;
Cool trick… until you realize overflow is a real thing.
XOR swap:
a = a ^ b;
b = a ^ b;
a = a ^ b;
Even cooler trick… but now I’m staring at it thinking,
“If I came back to this in six months, would I even remember what I was doing?”
And then there’s:
<code>std::swap(a, b);</code>
Clean. Clear. Done.
So now I’m asking myself something bigger:
If <code>std::swap()</code> exists… why are we still learning manual swaps?
And I think the answer is this:
It’s not about swapping variables.
It’s about learning how state changes.
<ul>
<li>You can’t overwrite data without consequences.</li>
<li>Order of operations matters.</li>
<li>Memory doesn’t “remember” what you intended.</li>
<li>Clever code isn’t always good code.</li>
</ul>
This tiny lab forced me to slow down and think about what each line actually does. And honestly, that’s what C++ keeps doing to me. It doesn’t let you be sloppy.
So here’s what I’m curious about:
In real production code, do you ever manually swap values anymore or is it always <code>std::swap()</code>?
And second question:
Is XOR swap basically a relic at this point, or does it still have a practical use somewhere?
Looking forward to hearing how you all see this.

John Liter

A beginner C++ programmer reflects on a variable-swapping exercise that turned into a deeper lesson about memory, state mutation, and code clarity. Starting with the naive broken approach, the post walks through the temporary variable method, arithmetic swap, XOR swap, and finally std::swap(), concluding that learning manual swaps teaches how state changes in memory rather than just how to use a library function. The post ends with open questions about whether XOR swap still has practical uses and whether production code ever uses manual swaps.

I Thought Swapping Variables Was Too Easy… I Was Wrong

If your going to use AI atleast use a codeblock when doing copy and pasting so your formatting isn’t broken.

Outside of leetcode style puzzles I can’t remember ever needing to swap variables - in over 40 years of being a developer.
I came from C (mostly java and rust these days) so would be using the temp variable method unless in a language that provides a convenient swap().
The XOR and arithmetic are neat tricks, but unless you know them, the intent of the code is not clear. Write code for readability first, not cleverness.

this is something tought in First semester Programming to explain Call by reference…i hope this ain’t news to anyone.