C++——调用优化

原始代码

 #include<iostream>
 using namespace std;
 class Test {
 public:
     //以参数列表形式对数据成员进行初始化
     Test(int d = ) :data(d)
     {
         cout << "Create Test Object:" << this << endl;
     }
     Test(const Test &t)
     {
         cout << "Copy Create Test Object:" << this << endl;
         this->data = t.data;
     }
     Test& operator=(const Test &t)
     {
         cout << "Assign:" << this << "=" << &t << endl;
         if (this != &t)
         {
             this->data = t.data;
         }
         return *this;
     }
     ~Test()
     {
         cout << "Free Test Object:" << this << endl;
     }
     int GetData()
     {
         return data;
     }
 private:
     int data;
 };

 Test fun(Test t)
 {
     int value = t.GetData();
     Test tmp(value);
     return tmp;
 }

 int main(int argc, char **argv)
 {
     Test t1();
     Test t2 ;
     t2 = fun(t1);
     return ;
 }

有结果观察可知，fun函数里面，tmp这个临时对象被创建的意义仅仅是为了调用拷贝构造函数初始化一个临时对象。初始化临时对象完毕后就被析构了。

代码优化，创建无名临时对象

 #include<iostream>
 using namespace std;
 class Test {
 public:
     //以参数列表形式对数据成员进行初始化
     Test(int d = ) :data(d)
     {
         cout << "Create Test Object:" << this << endl;
     }
     Test(const Test &t)
     {
         cout << "Copy Create Test Object:" << this << endl;
         this->data = t.data;
     }
     Test& operator=(const Test &t)
     {
         cout << "Assign:" << this << "=" << &t << endl;
         if (this != &t)
         {
             this->data = t.data;
         }
         return *this;
     }
     ~Test()
     {
         cout << "Free Test Object:" << this << endl;
     }
     int GetData()
     {
         return data;
     }
 private:
     int data;
 };

 Test fun(Test t)
 {
     int value = t.GetData();
     return Test(value);//创建无名临时对象
 }

 int main(int argc, char **argv)
 {
     Test t1();
     Test t2 ;
     t2 = fun(t1);
     return ;
 }

fun函数return返回那里没有再调用拷贝构造函数

代码继续优化，fun函数参数改为传引用

 #include<iostream>
 using namespace std;
 class Test {
 public:
     //以参数列表形式对数据成员进行初始化
     Test(int d = ) :data(d)
     {
         cout << "Create Test Object:" << this << endl;
     }
     Test(const Test &t)
     {
         cout << "Copy Create Test Object:" << this << endl;
         this->data = t.data;
     }
     Test& operator=(const Test &t)
     {
         cout << "Assign:" << this << "=" << &t << endl;
         if (this != &t)
         {
             this->data = t.data;
         }
         return *this;
     }
     ~Test()
     {
         cout << "Free Test Object:" << this << endl;
     }
     int GetData()
     {
         return data;
     }
 private:
     int data;
 };

 Test fun(Test &t)
 {
     int value = t.GetData();
     return Test(value);//创建无名临时对象
 }

 int main(int argc, char **argv)
 {
     Test t1();
     Test t2 ;
     t2 = fun(t1);
     return ;
 }

在继续优化，fun函数返回引用

 #include<iostream>
 using namespace std;
 class Test {
 public:
     //以参数列表形式对数据成员进行初始化
     Test(int d = ) :data(d)
     {
         cout << "Create Test Object:" << this << endl;
     }
     Test(const Test &t)
     {
         cout << "Copy Create Test Object:" << this << endl;
         this->data = t.data;
     }
     Test& operator=(const Test &t)
     {
         cout << "Assign:" << this << "=" << &t << endl;
         if (this != &t)
         {
             this->data = t.data;
         }
         return *this;
     }
     ~Test()
     {
         cout << "Free Test Object:" << this << endl;
     }
     int GetData()
     {
         return data;
     }
 private:
     int data;
 };

 Test& fun(Test &t)
 {
     int value = t.GetData();
     return Test(value);//创建无名临时对象
 }

 int main(int argc, char **argv)
 {
     Test t1();
     Test t2 ;
     t2 = fun(t1);
     return ;
 }

这段代码在VS2017下编译不过，分析原因如下

return Test(value);//创建无名临时对象

无名临时对象出了函数就被释放了，t2 = fun(t1);调用赋值函数，是将一个已被析构的对象赋值给具体对象t2。

函数返回值能否写成引用，要看所引用的对象是否是局部对象，如果出了函数对象被析构了就不要引用。

代码继续优化

 #include<iostream>
 using namespace std;
 class Test {
 public:
     //以参数列表形式对数据成员进行初始化
     Test(int d = ) :data(d)
     {
         cout << "Create Test Object:" << this << endl;
     }
     Test(const Test &t)
     {
         cout << "Copy Create Test Object:" << this << endl;
         this->data = t.data;
     }
     Test& operator=(const Test &t)
     {
         cout << "Assign:" << this << "=" << &t << endl;
         if (this != &t)
         {
             this->data = t.data;
         }
         return *this;
     }
     ~Test()
     {
         cout << "Free Test Object:" << this << endl;
     }
     int GetData()
     {
         return data;
     }
 private:
     int data;
 };

 Test fun(Test &t)
 {
     int value = t.GetData();
     return Test(value);//创建无名临时对象
 }

 int main(int argc, char **argv)
 {
     Test t1();
     Test t2 = fun(t1);
     return ;
 }