Перегрузка оператора C ++ и конструктор копирования

Мне трудно понять следующее (в частности, сценарий b): (Предположим, я определил оператор присваивания, оператор сложения и конструктор копирования только для того, чтобы вывести тот факт, что они вызываются)

сценарий a:

Simple a;
Simple b;
Simple c = a + b;

    The output is as follows:
    Simple constructor called
    Simple constructor called
    Simple add operator call
    Simple constructor called
    copy constructor called

- Все в порядке и неплохо

сценарий b ( поведение, которое я не могу понять):

Simple d;
Simple e;
Simple f;
f = d + e;

    Simple constructor called
    Simple constructor called
    Simple constructor called
    Simple add operator called
    Simple constructor called
    copy constructor called
    assignment operator called

У меня возникает вопрос, почему в сценарии b конструктор копирования вызывается прямо перед оператором присваивания? Насколько я понимаю, конструктор копирования будет вызываться только для неинициализированного объекта. Однако в этом сценарии объект f был инициализирован в строке, предшествующей добавлению.

Будем очень признательны за объяснение.

Приносим извинения за то, что не опубликовали исходный код сразу (и за отсутствие отступов - у меня проблемы с копированием в текстовое поле). Вот он во всей его простоте. Я использую Visual Studio 2005. К сожалению, я еще не так хорошо знаком с его работой, поэтому я не могу указать параметры оптимизации, которые передаются компилятору.

class Simple
{
public:
    Simple(void);
Simple operator +(const Simple& z_Simple) const;
Simple& operator =(const Simple& z_Simple);
Simple(const Simple& z_Copy);
int m_Width;
int m_Height;
public:
~Simple(void);
};


#include "Simple.h"
#include <iostream>

using std::cout;
using std::endl;

Simple::Simple(void)
{
this->m_Height = 0;
this->m_Width = 0;
cout << "Simple constructor called" << endl;
}

Simple::Simple(const Simple& z_Copy)
{
cout << "copy constructor called" << endl;
this->m_Height = z_Copy.m_Height;
this->m_Width = z_Copy.m_Width;
}

Simple& Simple::operator =(const Simple &z_Simple)
{
cout << "assignment operator called" << endl;
this->m_Height = z_Simple.m_Height;
this->m_Width = z_Simple.m_Width;   
return *this;
}


Simple Simple::operator +(const Simple &z_Simple) const
{
cout << "Simple add operator called" << endl;
int y_Height = this->m_Height + z_Simple.m_Height;
int y_Width = this->m_Width + z_Simple.m_Width;
Simple y_Ret;
y_Ret.m_Height = y_Height;
y_Ret.m_Width = y_Width;
return y_Ret;
}

Simple::~Simple(void)
{
cout << "destructor called" << endl;
}

Конечно, объяснение Nemo - это то, что мой новичок в C ++ может уловить :)

После изменения уровня оптимизации на / O2 я могу увидеть результат сценария b следующим образом (и то, что я ожидал)

    Simple constructor called
    Simple constructor called
    Simple constructor called
    Simple add operator called
    Simple constructor called
    assignment operator called

Спасибо всем за ваши предложения.