What is the importance of post increment and pre increment in C++?
In: 7
There’s no importance, it’s just programming logic and short hand for
<operation>
c = c + 1;
//c++;
It’s all the same. If you want to pre-increment a variable it’s just doing the
c = c + 1;
<operation>
//++c;
Before the operation.
It really only matter when doing function calls
So
‘ function(c++) ‘
Will get the value of c before it is incremented
And
‘ function(++c) ‘
Will get the value of c after it is incremented
They’re simply there if you need to use the value of the variable before or after you increment it. They’re just short cuts for different operations.
Preincrement and post increment both do two different things in the same line of code: they increment a value and return a calue. The difference is the order in which they do these two things. Preincrementing (++x) increments x and returns the *new* value, while postincremebting (x++) returns the *old* value, then increments it.
As long as you use ++x or x++ on a line by themselves (including the “lines” between semicolons in a for-loop), the end result is more or less the same. Where they get weird is when you use them as part of other expressions. Consider “x = 1; y = x++ + 1;”. After this code, x and y would both equal 2, because the second line uses the old value. If the code were instead “x = 1; y = ++x + 1”, then x would equal 2 but y would equal 3, because you added to the new value.
Some people recommend against using these, because they can be fiddly and hard to understand. Technically, one can argue that C++’s own name is incorrect, because it implies you’re still using the old language evem though you would later go on to improve it. The name should be ++C, because you improved the language and then used your improvements.
Basically both mean add 1 to the number but one first does something with the number and then adds one and the other first adds one and then does the thin with it.
If x has the value of 2 both x++ and ++x will result in x having the value of 3.
However if you use this not just by itself but while doing something else like
A = ++x;
And
A = x++;
will result in x being 3 both times but in he first example A is 2 and in the second A is 3.
On it’s own there is no difference.
x++;
and
++x;
Are the same.
The difference comes when you’re immediately using x.
int x = 1;
int y = x++;
has y being 1.
int x = 1;
int y = ++x;
has y being 2.
That’s what pre and post increment means.
In post increment, you do whatever, and then you increment.
In pre increment, you increment, and then you do whatever.
In addition to what everyone else has said about using pre or post increment in more complex statements and assignments, there *was* also a further reason for using pre increment over post increment in certain circumstances.
When incrementing STL (or other similar) iterators in a loop then pre increment was preferred as it was significantly faster. With more modern compilers this is no longer the case, but you’ll still see a lot of older code, or code written by older programmers, using pre increment for this reason and habit. I myself still always use pre increment even in other languages like C# because I’ve had it drilled into me from > 20 years of programming.
See: https://eklitzke.org/stl-iterators-and-performance-revisited
Latest Answers