Increment Operator Results

[heisenbug]

Hi,

I'm currently enrolled in programming fundamentals for computer science class at the local community college.

Testing out what the results would be if I use a++ and ++a where a is a variable of integer data type initialized to 0.

#include <iostream>
using namespace std;

int main()
{

int a = 0;

cout << "a++ = " << a++ <<endl;
cout << "++a = " << ++a <<endl;
cin.get();

return 0;

}

When I run the program, I get different results.
a++ prints out 0 and ++a prints out 1.

If both a++ and ++a increment the value of variable a by 1, why are the results different? Can someone point me in the right direction?

Thank you

[std10093]

Welcome to the forum. Nice first post by the way. Thee only thing I would advice you, is to copy paste your output as code and note that this is my output. You see, the images take more space, than the output.

Your code is equivalent to this code: (post-fix case)

#include <iostream>
using namespace std;
 
int main()
{
 
     int a = 0;

     cout << "a++ = " << a <<endl;
     a = a + 1; // We increment 'a' after we "execute" the cout
     cin.get();
 
     return 0;
 
}

while the pre-fix case would something like this:

#include <iostream>
using namespace std;
 
int main()
{
 
int a = 0;
 
a = a + 1; // We increment 'a' before we "execute" the cout
cout << "++a = " << a <<endl;
cin.get();
 
return 0;
 
}

So, in pre-fix case, the operations of addition will be executed before the line of code, that this increment operator lies into, gets executed.

On the other hand, post-fix case will execute the line of code and the operation of addition by one will be executed.

However, try not to cause undefined behavior with them. If you keep it simple, you will not.

[Elysia]

To elaborate, do not modify the same variable twice in the same statement (or line). a++ + ++a is undefined behaviour.
Postfix and prefix operators are also good when used in simple expressions, such as when they're alone on the right hand side of an operator (eg b = a++). But if you have a more complex expression, beware. The order of evaluation of subexpressions is undefined, so ++a + ++b, while okay, does not say if a will be incremented first and then b, or the other way around. It can have unintended consequences.
Welcome to the world of C++.

[iMalc]

If you run that whole program as shown, it will print out a++ = 0 and then ++a = 2.

Why?
Because it prints the value of a, then increments a, then it increments a, and finally prints out a again.

[heisenbug]

Hi,

Thank you std10093, Elysia and iMalc for your time and explanations.

It is my mistake not to give a clear explanation of what I was asking for and may be a bad code example I gave.

#include <iostream>
using namespace std;

int main()
(    

int x;
int y;


x = 5;
y = x++;
cout << "The value of y with post increment operator: " <<y <<endl;
cout <<"The value of x: " << x <<endl;

x = 5;
y = ++x;
cout << "The value of y with pre increment operator: " << y <<endl;
cout << "The value of x: " << x <<endl;

cin.get();    
return 0;
    
}

Here is my output:

The value of y with post increment operator: 5
The value of x: 6
The value of y with pre increment operator: 6
The value of x: 6

My question is,

Why in the case of a post increment operation, the initial value of x was assigned to y and then x got incremented by 1.
Whereas in the case of pre increment operation, the value of x got incremented by 1 first and then the assignment took place.

From doing google searches, someone said that

++x increments and produces as expression result x as an lvalue while,
x++ increments and produces as expression result the original value of x.

Obviously at this point I don't know what an lvalue is.

The instructor taught us that expressions on the right hand side are evaluated first and then the result is assigned to the variable on the left hand side. Following this logic, then I would think in the case of x++, it should expand to an expression x + 1, get evaluated and only then the result should be assigned to y.

Is my understanding incorrect?

Thank you.

[oogabooga]

The ultimate effect of both forms of increment operator is to add one to the variable. But the value returned by the expressions are different. In the pre-increment, the expression's value is the variable's value after the increment. In the post-increment, the expression's value is the variable's value before the increment.

Here's an example of implementing the increment operators in a class. Note that for the post-increment, we need to save the old value, add one to the variable, and then return the old value.

#include <iostream>

class A
{
    int m_n;

public:

    A(int n) : m_n(n)
    {
    }

    A operator++()       // pre-increment operator:  ++a
    {
        ++m_n;
        return *this;
    }

    A operator++(int)    // post-increment operator:  a++
    {                    // (The unnamed int parameter is a
                         // "kludge" to indicate post-increment.)
        A ret(*this);
        ++m_n;
        return ret;
    }

    friend std::ostream& operator<<(std::ostream& os, A a);
};

// operator<< overload so object can be printed with cout
std::ostream& operator<<(std::ostream& os, A a)
{
    return os << a.m_n;
}

int main()
{
    A a1(0);
    std::cout << a1++ << '\n';   // prints 0

    A a2(0);
    std::cout << ++a2 << '\n';   // prints 1

    return 0;
}

[iMalc]

Why in the case of a post increment operation, the initial value of x was assigned to y and then x got incremented by 1.
Whereas in the case of pre increment operation, the value of x got incremented by 1 first and then the assignment took place.

Because that is precisely what the intended difference between pre and post-increment is.

[heisenbug]

Hi,

oogabooga: Thank you. The code example you provided is above and beyond my current knowledge.

iMalc: Thank you.

The official curriculum book the school is following is called,
C++ Programming From Problem Analysis to Program Design by D.S. Malik.
We are currently reading chapters 2 & 3.

Thank you & Have a great weekend.