关于移动构造的几个小问题

Jeff_

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. // interface
   
5. class Useless
   
6. {
   
7. private:
   
8.     int n;          // number of elements
   
9.     char * pc;      // pointer to data
   
10.     static int ct;  // number of objects
    
11.     void ShowObject() const;
    
12. public:
    
13.     Useless();
    
14.     explicit Useless(int k);
    
15.     Useless(int k, char ch);
    
16.     Useless(const Useless & f); // regular copy constructor
    
17.     Useless(Useless && f);      // move constructor
    
18.     ~Useless();
    
19.     Useless operator+(const Useless & f)const;
    
20. // need operator=() in copy and move versions
    
21.     void ShowData() const;
    
22. };
    
23. 
    
24. // implementation
    
25. int Useless::ct = 0;
    
26. 
    
27. Useless::Useless()
    
28. {
    
29.     ++ct;
    
30.     n = 0;
    
31.     pc = nullptr;
    
32.     cout << "default constructor called; number of objects: " << ct << endl;
    
33.     ShowObject();
    
34. }
    
35. 
    
36. Useless::Useless(int k) : n(k)
    
37. {
    
38.     ++ct;
    
39.     cout << "int constructor called; number of objects: " << ct << endl;
    
40.     pc = new char[n];
    
41.     ShowObject();
    
42. }
    
43. 
    
44. Useless::Useless(int k, char ch) : n(k)
    
45. {
    
46.     ++ct;
    
47.     cout << "int, char constructor called; number of objects: " << ct << endl;
    
48.     pc = new char[n];
    
49.     for (int i = 0; i < n; i++)
    
50.         pc[i] = ch;
    
51.     ShowObject();
    
52. }
    
53. 
    
54. Useless::Useless(const Useless & f): n(f.n)
    
55. {
    
56.     ++ct;
    
57.     cout << "copy const called; number of objects: " << ct << endl;
    
58.     pc = new char[n];
    
59.     for (int i = 0; i < n; i++)
    
60.         pc[i] = f.pc[i];
    
61.     ShowObject();
    
62. }
    
63. 
    
64. Useless::Useless(Useless && f): n(f.n)
    
65. {
    
66.     ++ct;
    
67.     cout << "move constructor called; number of objects: " << ct << endl;
    
68.     pc = f.pc;       // steal address
    
69.     f.pc = nullptr;  // give old object nothing in return
    
70.     f.n = 0;
    
71.     ShowObject();
    
72. }
    
73. 
    
74. Useless::~Useless()
    
75. {
    
76.     cout << "destructor called; objects left: " << --ct << endl;
    
77.     cout << "deleted object:\n";
    
78.     ShowObject();
    
79.     delete [] pc;
    
80. }
    
81. 
    
82. Useless Useless::operator+(const Useless & f)const
    
83. {
    
84.     cout << "Entering operator+()\n";
    
85.     Useless temp = Useless(n + f.n);
    
86.     for (int i = 0; i < n; i++)
    
87.         temp.pc[i] = pc[i];
    
88.    for (int i = n; i < temp.n; i++)
    
89.         temp.pc[i] = f.pc[i - n];
    
90.     cout << "temp object:\n";
    
91.     cout << "Leaving operator+()\n";
    
92.     return temp;
    
93. }
    
94. 
    
95. void Useless::ShowObject() const
    
96. {
    
97.     cout << "Number of elements: " << n;
    
98.     cout << " Data address: " << (void *) pc << endl;
    
99. }
    
100. 
     
101. void Useless::ShowData() const
     
102. {
     
103.     if (n == 0)
     
104.         cout << "(object empty)";
     
105.     else
     
106.         for (int i = 0; i < n; i++)
     
107.             cout << pc[i];
     
108.     cout << endl;
     
109. }
     
110. 
     
111. // application
     
112. int main()
     
113. {
     
114.     {
     
115.         Useless one(10, 'x');
     
116.         Useless two = one;          // calls copy constructor
     
117.         Useless three(20, 'o');
     
118.         //Useless four(one + three);  // calls operator+(), move constructor
     
119.                 Useless four = one + three;
     
120.         cout << "object one: ";
     
121.         one.ShowData();
     
122.         cout << "object two: ";
     
123.         two.ShowData();
     
124.         cout << "object three: ";
     
125.         three.ShowData();
     
126.         cout << "object four: ";
     
127.         four.ShowData();
     
128.     }
     
129.     // cin.get();
     
130. }

复制代码

这里Useless four(one + three);  调用移动构造，我自己运行了下，是先进行+法的重载，可是加法的重载还是创建了临时对象temp，然后返回temp时调用移动构造。

问题： 1.移动构造的好处不就是可以省去中间临时对象的复制与析构吗，那这里同样创建了中间临时对象的意义是什么？
           2.既然这里中间已经创建了临时对象，这个临时对象不是应该调用的复制构造吗？为什么这个temp对象还是会继续调用移动构造？

Syc

1、移动构造的好处确实是省去中间临时对象的再次创建，但是 Useless four(one + three); 创建的临时对象跟移动构造没有关系，而是调用 Useless operator+(const Useless & f) const; 函数创建的，因为其返回值就是个新的对象，所以肯定会创建个临时对象；

2、因为第一步创建的是一个临时对象，所以才会调用移动构造，如果不是一个临时对象可能就直接调用拷贝构造了，明白了吗？

具体可以看看这篇文章，感觉讲解的挺好！

C++拷贝构造、移动构造与返回值优化
https://blog.csdn.net/andylau00j/article/details/79725305

zuiwuchang

移動構造 不會省去 臨時對象的 創建 而是 減小 臨時對象的 構造 成本 以 std::string 爲例子

1. //string 的 move 簽名
   
2. string(std::string&& r)

复制代码

r 是一個右值 代表 沒有人會在使用了 所以 新建的 std::string 直接 將 char * 指針 指向 r 保存的 char* 即可 且告訴 r 析構時 不用 釋放 char* 了 因爲 指針被 新string 接管了
(stl 容器 通常都提供了 swap 函數 可以 將 內部保存的 指針/引用管理權 交換出來 你可以用一個 空的 容器 與其交互 來達到 移交控制權的 功能)
而且 爲什麼 是 && 而不是 const && 就是 因爲 r 是 可寫的 你需要 在move 構造中 將它的 資源 移交出來 而不是 copy 一份 資源

在 copy 構造時 則是 申請了 一塊 和 r 保存的 char* 同樣 大小的新 指針 並使用 strcopy 之類的 函數 將 r 的字符串 內容 copy到 新指針中

所以 對於自己實現的 class 要使用 move 帶來的好處 需要 其 管理的 資源 能夠被 移交 並實現 move 語義來 移交資源