не может объяснить поведение компилятора

Question

Рассмотрят этот простой код:

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; 
} 

Это выходы:

Перед приращением: 1
разрушающего 2
после приращения: 2
разрушающего 2

Почему значение a еще 1 перед уничтожением?

Answer 1

В методе operator ++ вы создаете временный объект A, который затем уничтожается, когда вы возвращаете его из функции. Должна быть и другая копия строительства и уничтожения, но RVO elides этот.

Когда вы добавляете журнал в конструктор, вы также увидите, что происходит дальше. Я также позволил себе изменить printf на cout, для более стильного стиля C++ ish.

#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; 
} 

выход:

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

Вы можете также прочитать о канонических реализациях операторов перегрузки:

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

оператор ++ перегрузка должна выглядеть следующим образом:

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 
    } 
}; 

Answer 2

Это довольно просто:

a = ++a; 

Во-первых, создается новый временный A объект, который держит value из 2 (value + 1 = 2), этот объект перемещается/копируется в a, а затем уничтожен (который является первым destroying 2 принт вы смотрите). Теперь созданный компилятором конструктор move/copy просто выполняет memcopy членов, value в этом случае. value был 2 при присвоении темпа объекта, и таким образом avalue будет 2 тоже. Поэтому последние две цифры printf2 ничего удивительного.

Answer 3

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; 
} 

В принципе вы можете объявить оператор Преинкремент здесь постоянны для ясности

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

Но ожидаемое поведение является:

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