临时对象

直接上代码：

#include <iostream>
 using namespace std;
 
 class B
 {
 public:
     B()
     {
         cout << "default constructor " << endl;
     }
     ~B()
     {
         cout << "destructed" << data << endl;
     }
     B(int i) : data(i)
     {
         cout << "constructed by parameter" << data << endl;
     }
 private:
     int data;
 };
 
 B play ()
 {
    B b(1);
    return b;   // 按值返回
 }
 
 void play2(B b)  // 按值传参
 {
 }

 void main()
 {
     B t1 = play();

     play2(t1);
 }

 输出：

constructed by parameter1
destructed1
destructed1
destructed1
请按任意键继续. . .

a.按值返回和b.按值传参的位置都会产生一个临时对象。a、b是产生临时对象的两种情况。

问题来了：

   假如有如下代码，那么结果会是什么呢？

#include <iostream>
 using namespace std;
 
 class B
 {
 public:
     B()
     {
         cout << "default constructor " << endl;
     }
     ~B()
     {
         cout << "destructed" << data << endl;
     }
     B(int i) : data(i)
     {
         cout << "constructed by parameter" << data << endl;
     }
 private:
     int data;
 };
 
 B play( B  b) // 按值传参
 {
     return b;  // 按值返回
 }
 void main()
 {
     B t1 = play();

     play2(t1);
 }

输出：

constructed by parameter5
destructed5
destructed5
请按任意键继续. . .

可能会问，不是应该有3次析构吗？ 怎么只有两次。

这里是编译器对临时对象做了处理，如果参数和返回值是同一对象，那么只产生传参时候的一次临时对象。[自己理解得，不一定正确]

解决临时对象的方法：

使用引用。

#include <iostream>
 using namespace std;
 
 class B
 {
 public:
     B()
     {
         cout << "default constructor " << endl;
     }
     ~B()
     {
         cout << "destructed" << data << endl;
     }
     B(int i) : data(i)
     {
         cout << "constructed by parameter" << data << endl;
     }
 private:
     int data;
 };
 
 B play( B  &b) // 按值传参
 {
     return b;  // 按值返回
 }
 void main()
 {
     B t2(5);
     B t1 = play(t2);

 }