Can't explain compiler's behavior

Question

Consider this simple code:

class A {
public:
    int value;
    A(int value) { this->value = value; }
    ~A() { printf("destroying %d\n", value); }
    A operator ++() { return A(value + 1); }
};

int main() {
    A a(1);
    printf("before increment: %d\n", a.value);
    a = ++a;
    printf("after increment: %d\n", a.value);
    return 0;
}

This outputs:

before increment: 1
destroying 2
after increment: 2
destroying 2

Why is the value of a 1 more before being destroyed?

Your `operator++()` should return a reference (to itself) after incrementing itself, not create a new temporary `A`. As written, this code will confuse the hell out of users of the class. — Jesper Juhl, May 16 '16 at 13:07

LookAheadAtYourTypes · Accepted Answer · 2016-05-15T20:45:48.937

In operator++ method you create temporary A object which is then destroyed when you return it from the function. There should be also another copy construction and destroying, but RVO elides this one.

When you add log to constructor also you will see better what is going on. I also allowed myself to change printf to cout, for more c++ish coding style.

#include <iostream>

class A {
public:
    int value;
    A(int value) {
        std::cout << "creating " << value << std::endl; 
        this->value = value; 
    }
    ~A() { 
        std::cout << "destroying " << value << std::endl; 
    }
    A operator ++() { return A(value + 1); }
};

int main() {
    A a(1);
    std::cout << "before increment: " << a.value << std::endl; 
    a = ++a;
    std::cout << "after increment: " << a.value << std::endl; 

    return 0;
}

output:

creating 1
before increment: 1
creating 2
destroying 2
after increment: 2
destroying 2

You can also read about canonical implementations of operators overloading:

http://en.cppreference.com/w/cpp/language/operators

operator++ overloading should look like this:

struct X
{
    X& operator++() // prefix version
    {
        // actual increment takes place here
        return *this;
    }
    X operator++(int) // postfix version
    {
        X tmp(*this); // copy
        operator++(); // pre-increment
        return tmp;   // return old value
    }
};

good thing you mention the sensible way to implement these operators. BTW if the OP had implemented it this way, the answer would be(if memory servers me right) undefined behavior because of modifying the same object in one expression with `a = ++a;`. — Biruk Abebe, May 15 '16 at 20:56
This expression has three parts: (1) "a" (2) "++a" (3) "assign (2) to (1)". (3) is guaranteed to happen after (1) and (2), so no, there is no undefined behavior here. — LookAheadAtYourTypes, May 17 '16 at 12:35
yes, but if `++a` is implemented in a way that is going to increment itself then the expression would result in undefined behavior. see [this](http://stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points) — Biruk Abebe, May 17 '16 at 13:27

score 2 · Answer 2 · answered May 15 '16 at 20:28

int main() {
    A a(1); // a.value = 1;
    printf("before increment: %d\n", a.value);
    a = ++a; // 1. create temporary object of type A with a.value+1
             // 2. copy temporary object to object a.
             // 3. destroy temporary object.
    printf("after increment: %d\n", a.value);
    return 0;
}

Basically you can declare pre-increment operator here as constant for clarity

A operator ++() const { return A(value + 1); }

But expected behavior is:

A& operator ++() { ++value; return *this; }

score 0 · Answer 3 · answered May 15 '16 at 20:24

It's pretty simple:

a = ++a;

First, a new temporary A object is created that holds a value of 2 (value + 1 = 2), this object is moved/copied to a and then destroyed (which is the first destroying 2 print you see). Now the compiler generated move/copy constructor just does a memcopy of the members, value in this case. value was 2 when assigned to the temp object and thus a's value will be 2 too. Therefore, the final two printf's printing out 2 is nothing surprising.

Can't explain compiler's behavior

3 Answers3