额外的析构函数调用的原因？

Question

给出以下简单类：

#include <iostream>

class Foo{
    int a, b;
    public:
        Foo(int _a = 0, int _b = 0) : a(_a), b(_b) { 
            std::cout << "Foo(int, int)" << "\n"; 
        }

        Foo(const Foo& foo) : a(foo.a), b(foo.b) { 
            std::cout << "Foo(const Foo&)" << "\n"; 
        }

        Foo& operator=(const Foo& other) { 
            std::cout << "operator=(const Foo&)" << "\n"; 
            if(this != &other){
                a = other.a; 
                b = other.b;
            }
            return *this; 
        }

        ~Foo() { 
            std::cout << "~Foo()" << "\n"; 
        }

        Foo operator+(const Foo& other){
            std::cout << "foo.operator+(const Foo&)" << "\n";
            return Foo(a + other.a, b + other.b);
        }
};

还有主要的：

int main(){
    Foo f1, f2(1, 2), f3;
    std::cout << "-----------" << "\n";
    f3 = f1 + f2;                          // (*)
    std::cout << "-----------" << "\n";
    return 0;
}

我使用-std=c++11 编译，出于演示目的还使用-fno-elide-constructors 标志。输出内容为：

Foo(int, int)
Foo(int, int)
Foo(int, int)
-----------
foo.operator+(const Foo&) // (1)
Foo(int, int)             // (2)
Foo(const Foo&)           // (3)
~Foo()                    // (4)
operator=(const Foo&)     // (5)
~Foo()                    // (6)
-----------
~Foo()
~Foo()
~Foo()

据我正确理解，f3 = f1 + f2; (*) 行发生以下情况：

1. 显然，f1.operator+(f2) 被调用。
2. 创建了一个新的（临时）对象。让我们用T来表示它。
3. 由于operator+() 函数不返回引用，我们调用复制构造函数来构造T2 的T 的副本。我们返回T2。
4. 调用析构函数来删除临时对象T。
5. 我们调用复制赋值运算符将T2的所有成员分配给f3。

我的问题：我真的不明白 (6) 的目的是什么。为什么要额外调用析构函数，即我在这里遗漏了什么？

Answer 1

我在这里错过了什么？

T2的破坏。

调用了3+2个构造函数，也调用了3+2个析构函数！