C++ Pre vs Post Increment Internals: A Deep Dive into Assembly

Hinzugefügt: 2026-05-20

[00:00:00]Most of us are familiar with I++. That's one of the first things that we learn in programming, whether we're creating a for loop or just learning about integers. It's essentially no different than writing I equals I plus one. But, that's not the only way you can set I to I plus one. You can actually also do plus plus I. The first one is known as a post increment and the second one is known as a pre-increment. While both of these essentially do the same thing of incrementing I by one, the way that they do it in assembly is different. And I++ in some cases actually costs one extra line of assembly. And that's what I want to talk about in this video.

[00:00:35]Suppose you say int A equals I++. When you use the post increment operation, it actually ends up setting A to whatever the current value of I is, and then it increments I. After completing this statement, A will equal four, and then I will equal five. Now, if you do the pre-increment, it's a little bit different in that it will first increment the value of I to five, and then it will set that value to be B.

[00:01:03]After completing this statement, I is going to equal five, and B is going to equal five. There is a difference between what these two things do. I think it would be helpful to look at the assembly that is generated from this code.

[00:01:16]So, I've got the assembly for this code.

[00:01:19]We've stopped right on main. It's setting the I variable to equal four.

[00:01:23]Now, the important thing to look at is these two operations, the post increment and the pre-increment. So, let's go to the next line in the assembly by pressing NI. The reason I set I equal to four like this is so that we can clearly see the number of instructions, the number of assembly instructions, that are generated by this I++ operation, as well as this ++ I operation. Let's just look at how many instructions are generated. We're setting I equal to four here. These 1 2 3 4 5 instructions are going to take place to complete this line of code, which is int a equals i++.

[00:01:58]That's five lines of assembly. And if you look at the next one, which is right here, you're going to notice that in this situation, where we set int b equals ++i during the pre-increment, it's actually four operations of assembly.

[00:02:15]Let's see what's going on. So, we're loading rbp minus four into a register called eax. Then, we're also going to copy the same value into ecx because we have to set the value four to a. That's what the i++ operation dictates. That's essentially the definition of i++. It's a post-increment. You have to increment it after setting the value. So, in order to set the value of four equal to a, we have to create a copy of this into another register. So, we have to store four in ecx, and we have to keep it another copy of it in eax. So, then you're going to realize that we're adding the value one, which is exactly what the post-increment operation is going to do. And that's going to be added into ecx. So, let's go to the next line, right? I'm going to go to the next instruction, next instruction, and next instruction once more. Let's print whatever's in ecx.

[00:03:04]So, in ecx, we've got the value five.

[00:03:07]But what's in eax? In eax, we've got the value four. So, what's essentially happening is that we need to keep the value four because we need to store that value inside of a. So, if we go to the next line here, what we're seeing is that i is getting incremented, right?

[00:03:19]rbp minus 0x8 is what i is supposed to be. And we're putting ecx into that, and we know that ecx contains five. And if I go to the next line, eax contains the value four, and that's what we're going to set to rbp minus 0xc, which I can only presume is going to be the value of a. So, if I go to the next line and pause right before setting i equals four, if I print i, we're going to see that it has the value five. And if I print a, we're going to see that it has a value four. So, essentially, we have to create this extra copy right here.

[00:03:51]Let's go through the pre-increment just for completeness' So, I'm going to go to the next line here. Now that we've set I back to four, let's see how what B is going to be set to. So, notice that there's one less instruction here. We're not doing this move al eax to ecx because we don't need to keep a reference to the previous value of I, right? And here in this case, we needed to say that A is going to equal four, and we need to store that value four somewhere because if we increment four to five, we're going to lose the value four cuz it's not going to be stored in any register. But in this case, in the pre-increment, when int B is set to plus plus I, we need to first increment it and then store it in B. So, when we first increment I, we don't need to keep a copy of whatever I previously was. There's one less instruction right here. We're going to just add one to eax, so we're not going to store it in any sort of extra register. And then if I go to the next line and next line, you're going to see that we are setting the value rbp minus 0x8. This is the location of I on the stack, and rbp minus 0x10 is the location of B, presumably. And we have to set eax to both of them. We don't need to keep a register called ecx. We could just store the same value that was in eax for both of them. Go to the next line, go to the next line, and now let's print B. And if I print B, we should see the value five. If I print I, we should also see the value five. So, in this case, B is equal to five, I is equal to five.

[00:05:13]In this previous example, we were setting the value of A and B. The post-increment actually needed to save a copy of whatever I is before it got incremented so that it could store that value into A. But in this case, the compiler realizes, "Oh, you don't need to store that value." When you're doing I plus plus and plus plus I, you're not actually storing that value anywhere, so we could just get rid of that copy.

[00:05:35]This is the first line setting up in the assembly, and if I go to the next instruction, you're going to see that it only takes three instructions, right? I plus plus is only taking three instructions because it's not doing that extra copy. And same for ++i, they're both just taking three instructions. And we can see it clearly because we can say that okay, RBP - 0x8, that's the value i, putting that into the register EAX, then adding one to whatever's in EAX, and then storing it back into i. So, after completing all these three instructions, i should equal five. So, let's go to the next line, next instruction, next instruction, next instruction. Now, let's print i. Yep, exactly. i is equal to five. And once again, the same thing happens here. It's only three instructions. We're moving the variable i into EAX so that we can add one into it, and then we're going to put that result back into wherever i is on the stack. So, if I do NI three times, I'm going to do one, two, three, and then I'll print the value i, it should be the value six. The compiler knows that i++ is not being set to any value. You don't have to store a copy of it, right? Because you're not saying like, you know, a equals i++ or something, right? So, because of that, the compiler is smart enough to just kind of get rid of it behind the scenes.

[00:06:44]I guess the TLDR is that in some cases you're going to want to use a post-increment because you want to save a copy of the value of i before you increment it. But in other cases, it's not actually going to matter what you do. The generated assembly ends up being the same. And yep, that's what I want to talk about in this video. If you enjoyed it, hit the like button, and consider subscribing for more C++ deep dives just like this. Thanks for watching, and I'll catch you guys next time.