Внешний вид копирующих конструкторов / деструкторов - пример

Question

Моя другая тема вопроса (для справки. Не нужно было отвечать на этот вопрос. Тем более для других читателей, которые не знают, почему вызывается выходная строка 6): Передача по ссылке - почему вызывается этот деструктор?

Пожалуйста, помогите мне (и другим) лучше понять, когда конструкторы копирования вызываются, изучив код (и мои комментарии, которые показывают мое понимание) ниже.

Я использую Visual Studio 2015в качестве ссылки на мой компилятор.

Я не думаю, что у меня есть способ подтвердить себя относительно правильности моих рассуждений о том, почему эти конструкторы вызваны, поэтому я и являюсьспрашиваю здесь о StackOverflow для вашего ввода.

Я специально задаю вопросы по строкам 7-18 (я чувствую себя достаточно уверенно в своих рассуждениях по строкам 1-6, но не стесняйтесь поправлять меня, если я ошибаюсь).

Чтобы быть точным: Если мои рассуждения о том, почему эти конструкторы-деструкторы появляются для строки 7-18, неверны, то какова правильная причина?Сын, почему эти конструкторы / деструкторы вызываются?

struct X:

struct X { // simple test class
   int val;

   void out(const std::string& s, int nv)
   {
      std::cerr << this << "–>" << s << ": " << val << " (" << nv << ")\n";
   }

   X() { 
      out("X()", 0); 
      val = 0; 
   } // default constructor

   X(int v) { 
      val = v; 
      out("X(int)", v); 
   }

   X(const X& x) {
      val = x.val; 
      out("X(X&) ", x.val); 
   } // copy constructor

   X& operator=(const X& a) // copy assignment
   {
      out("X::operator=()", a.val); 
      val = a.val; 
      return *this;
   }
   ~X() { 
      out("~X()", 0); 
   } // destructor
};

X glob(2); // a global variable

      // Output Line 1: X(int): 2 (2)
      // Reasoning: from X(int v) function

X copy(X a) { 
   return a; 
}

X copy2(X a) { 
   X aa = a; 
   return aa; 
}

main функция:

int main()
{
   X loc{ 4 }; // local variable 

      // Output Line 2: X(int): 4 (4)
      // Reasoning: from X(int v) function

   X loc2{ loc }; // copy construction 

      // Output Line 3: X(X&) : 4 (4)
      // Reasoning: from X(const X& x) function

   loc = X{ 5 }; // copy assignment 

      // Output Line 4: X(int): 5 (5)
      // Reasoning: from X(int v) function

      // Output Line 5: X::operator=(): 4 (5)
      // Reasoning: from the '=' operator overload

      // Output Line 6: ~X(): 5 (0)
      // Reasoning: X { 5 } is not an object. gets terminated at ';'

   loc2 = copy(loc); // call by value and return 

      // Output Line 7: X(X&): 5 (5)
      // Reasoning: from making a copy of X { 5 } for loc

      // Output Line 8: X(X&): 5 (5)
      // Reasoning: from making a copy of "loc" in parameter

      // Output Line 9: ~X(): 5 (0)
      // Reasoning: after copy made in (7) leaves function

      // Output Line 10: X::operator=(): 4 (5)
      // Reasoning: from the '=' operator overload

      // Output Line 11: ~X(): 5 (0)
      // Reasoning: same reason as output (6) above

   loc2 = copy2(loc);

      // Output Line 12: X(X&): 5 (5)
      // Reasoning: from making a copy of X { 5 } for loc

      // Output Line 13: X(X&): 5 (5)
      // Reasoning: from making a copy of "loc" in parameter

      // Output Line 14: X(X&): 5 (5)
      // Reasoning: from creating "aa"

      // Output Line 15: ~X(): 5 (0)
      // Reasoning: "loc" copy from (13) destroyed (see line 6 for reason)

      // Output Line 16: ~X(): 5 (0)
      // Reasoning: X { 5 } copy from (12) destroyed (see line 6 for reason)

      // Output Line 17: X::operator=(): 5 (5)
      // Reasoning: from the '=' operator overload

      // Output Line 18: ~X(): 5 (0)
      // Reasoning: after "aa" copy from (14) leaves function 
.
.
.
}