1 #include <QCoreApplication>
  2 #include <iostream>
  3 #include <vector>
  4 #include <assert.h>
  5 
  6 #define Has_Move
  7 /*
  8  * 话题：右值引用+移动语义+函数模板
  9  * 一、右值引用
 10  * 1. C++的引用允许你为已经存在的对象创建一个新的名字。对新引用所做的访问和修改操作，都会影响它的原型。
 11  * 2. C++11之前只有左值引用。
 12  *    lvalue这个词来自于C语言，指的是可以放在赋值表达式左边的事物——在栈上或堆上分配的命名对象，或者其他对象成员——有明确的内存地址；
 13  *    rvalue这个词也来源于C语言，指的是可以出现在赋值表达式右侧的对象——例如，文字常量和临时变量。因此，左值引用只能被绑定在左值上，而不是右值。
 14  *
 15  * 3. 右值不可以赋值给左值引用， 例如： int &i = 27;
 16  * 4. 右值可以赋值给左值的const引用， 例如：int const& i = 27; 也可以右值赋值给 const的左值引用 const int &i = 27;
 17  * 5. C++11标准介绍了右值引用(rvalue reference)，这种方式只能绑定右值，不能绑定左值。 例如：int&& i = 27;
 18  * 6. 有个有趣的现象： 右值引用可以赋值给左值的const引用，也可以赋值给 const的左值引用，但是反过来赋值不可以。
 19  *
 20  * 二、移动语义
 21  * 7. C++11新添语义——移动语义(move semantics)。
 22  * 8. 右值通常都是临时的。
 23  *    例如：函数返回值； 常量做参数传递；
 24  * 9. 当传递一个右值时，不会发生对象的拷贝， 而是一种“移动”，或者说是一种“窃取”。
 25  *    直接把对象从原来的所有者那里“窃取”过来，并且对象的所有状态不会发生改变。没有拷贝的发生，会节省很多的内存分配，性能更好。
 26  *    例如：需要传递一个 std::vector<int>，值传递时，需要分配同等大小的内存空间。
 27  * 10. C++标准库不会将一个对象显式的转移到另一个对象中，除非该对象将销毁的时候，或被赋值的时候(拷贝和移动的操作很相似)。
 28  *    参考：问-思考：2
 29  *
 30  * 三、右值引用与函数模板
 31  * 11. 当右值引用作为函数模板的参数时，实参既可以是左值，也可以是右值。
 32  *     因右值引用形如：T&& t，在实参像形参匹配的过程中， 有可能匹配为 TT & t(TT=T&), 也可能匹配为 TT t(TT=T&&)。
 33  *     因此会有这样的总结：如果函数模板的参数是右值引用，
 34  *          当实参为左值时， 模板会把实参类型当作左值引用，即 TT & t(TT=T&)；
 35  *          当实参为右值时， 模板会把实参类型当作普通数据使用。 即 TT t(TT=T&&)
 36  *
 37  *
 38  * 12. 很显然，左值移动 和 右值移动 可以作为函数重载。
 39  *    构造函数和移动构造函数就能说明这一点。
 40  *
 41  * 13. 实践中移动能保证类中的所有状态保持不变，表现良好
 42  *
 43  * 实例场景：
 44  * 1. 函数返回一个局部变量。
 45  *    使用移动语义， 不再需要将局部变量拷贝一个副本给返回值。
 46  *    std::string, std::vector<> 都是具备移动构造函数和移动赋值运算符的，就是为了避免拷贝大量数据。
 47  *
 48  *
 49  * 问-思考：
 50  * 1. 移动前后，两个变量的地址相同吗？
 51  *    答：不相同。
 52  * 2. 一个类同时具备拷贝拷贝构造函数和移动构造函数时， 什么情况下会调用拷贝构造？ 而什么情况下会调用移动构造呢？
 53  *    答：对于函数结束前返回临时对象的情况。
 54  *       若定义了移动构造函数，则不论返回时是否显示使用移动语义，都将调用移动构造函数；
 55  *       若未显示定义移动构造函数， 则不论返回时是否显示使用移动语义，都将调用普通的构造函数。
 56  *
 57  *       对于局部对象构造局部对象的情况。
 58  *       若定义了移动构造函数，则显示使用 std::move 时，调用移动构造函数，未显示使用 std::move 则调用普通的构造函数。
 59  *       若未定义移动构造函数，则不论是否使用 std::move， 都将调用普通的构造函数。
 60 */
 61 
 62 //! [实例场景] -1
 63 int func(){
 64     int a = 10;
 65     return std::move(a);
 66 }
 67 
 68 std::string func_1(){
 69     std::string _s = "abcdefg";
 70     return std::move(_s);
 71 }
 72 
 73 std::vector<int> func_2(){
 74     std::vector<int> _v = {1, 2, 3, 4, 5};
 75     return std::move(_v);
 76 }
 77 
 78 std::vector<std::string> func_3(){
 79     std::vector<std::string> _vs = {"abc", "def", "ghi"};
 80     return std::move(_vs);
 81 }
 82 //! [实例场景]
 83 
 84 
 85 //! [问-思考] -1
 86 std::string think_1(){
 87     std::string _s = "abcdefg";
 88     std::cout<<"In think_1 "<<_s<<" address is "<<&_s<<std::endl;
 89     return std::move(_s);
 90 }
 91 std::string& think_1_1(){ //返回引用编译能通过，运行会崩溃。 问-接龙：为什么移动构造函数不会崩溃
 92     std::string _s = "abcdefg";
 93     std::cout<<"In think_1_1 "<<_s<<" address is "<<&_s<<std::endl;
 94     return std::move(_s);
 95 }
 96 //! [问-思考]
 97 
 98 //! [问-思考] -2
 99 class MyClass{
100 public:
101     MyClass(){}
102     MyClass(MyClass & ){
103         std::cout<<"invoke MyClass(MyClass & other)"<<std::endl;
104     }
105 #ifdef Has_Move
106     MyClass(MyClass &&){
107         std::cout<<"invoke MyClass(MyClass &&other)"<<std::endl;
108     }
109 #endif
110 };
111 MyClass think_2(){
112     std::cout<<"In think_2"<<std::endl;
113 
114     MyClass obj;
115     return obj;             //可能调用移动构造
116 }
117 MyClass think_2_1(){
118     std::cout<<"In think_2_1"<<std::endl;
119 
120     MyClass obj;
121     return std::move(obj);  //可能调用移动构造
122 }
123 
124 MyClass& think_2_2(){//返回引用编译能通过，运行会崩溃。
125     std::cout<<"In think_2_2"<<std::endl;
126 
127     MyClass obj;
128     return std::move(obj);
129 }
130 //! [问-思考]
131 
132 class MyArray{
133 public:
134     MyArray(char str[], int len):_str(new char[1000]){
135         std::cout<<"len "<<len<<std::endl;
136         std::copy(str, str+len, _str);
137     }
138     MyArray(MyArray & other):_str(new char[1000]){
139         std::cout<<"Invoke MyArray(MyArray & other)"<<std::endl;
140         std::copy(other._str, other._str+1000, _str);
141     }
142     MyArray(MyArray &&other):_str(other._str){
143         std::cout<<"Invoke MyArray(MyArray &&other)"<<std::endl;
144         other._str=0;
145     }
146 
147     ~MyArray(){
148         delete[] _str;
149     }
150     void print(){
151         std::cout<<_str<<std::endl;
152     }
153 
154 private:
155     char * _str;
156 };
157 
158 int main(int argc, char *argv[])
159 {
160     QCoreApplication a(argc, argv);
161 
162     //! [话题] -6
163     //int& _iref = 27;   //error: C2440："初始化"：无法从"int"转换为"int&"
164     const int & _ciref = 27;
165     int const& _icref = 27;
166     std::cout<<"_ciref="<<_ciref<<std::endl;
167     std::cout<<"_icref="<<_icref<<std::endl;
168 
169     int && _irref = 27;
170     //int && _irref1 = _ciref; //error: C2440："初始化"：无法从"const int"转换为"int&&"
171     //int && _irref2 = _icref; //error: C2440："初始化"：无法从"const int"转换为"int&&"
172     const int & _ciref1 = _irref;  //! 特别注意 可以从 int&& 到 const int
173     int const & _icref1 = _irref;  //! 特别注意 可以从 int&& 到 int const
174     std::cout<<"_ciref1="<<_ciref<<std::endl;
175     std::cout<<"_icref1="<<_icref<<std::endl;
176 
177     std::cout<<"-----------------"<<std::endl<<std::endl;
178     //int const & 和 const int & 这两种类型相同吗？
179     //auto _type1 = typeid(_ciref);
180     //auto _type2 = typeid(_icref);
181     const std::type_info& _type1 = typeid(_ciref);
182     const std::type_info& _type2 = typeid(_icref);
183     std::cout<<"const int & _ciref, _ciref type is "<<_type1.name()<<std::endl; //两种都是 int 类型，有点扑朔迷离
184     std::cout<<"int const& _icref, _icref type is "<<_type2.name()<<std::endl;  //两种都是 int 类型，有点扑朔迷离
185     //! [话题]
186 
187     std::cout<<"-----------------"<<std::endl<<std::endl;
188 
189     //! [实例场景] -1
190     std::cout<<func()<<std::endl;
191 
192     std::cout<<func_1()<<std::endl;
193 
194     std::vector<int> _v = func_2();
195     //std::copy(_v.begin(), _v.end(), &std::cout);  //error info: C2697 二进制 "="：没有找到接受"int"类型的右操作数的运算符(或没有可接受的转换)
196     for (auto v : _v)
197         std::cout<<v;
198     std::cout<<std::endl;
199 
200     std::vector<std::string> _vs = func_3();
201     //std::copy(_vs.begin(), _vs.end(), &std::cout);  //error info: C2697 二进制 “=”：没有找到接受
202                                                     //std::basic_string<char, std::char_traits<char>, std::allocator<char>>
203                                                     //类型的右操作数的运算符（或没有可接受的转换）
204     for (auto s : _vs)
205         std::cout<<s;
206     std::cout<<std::endl;
207     //! [实例场景]
208 
209     std::cout<<"-----------------"<<std::endl<<std::endl;
210 
211     //! [问-思考] -1
212     std::string _s1 = think_1();
213     std::cout<<_s1<<" address is "<<&_s1<<std::endl;
214 
215     //std::string _s1_1 = think_1_1();  //崩溃了
216     //std::string _s1_1(think_1_1());   //崩溃了
217     //std::cout<<_s1_1<<" address is "<<&_s1_1<<std::endl;
218 
219     //! [问-思考]
220 
221     //! [问-思考] -2
222     think_2();
223     think_2_1();
224     //think_2_2();
225 
226     MyClass _obj;
227     MyClass _obj1(_obj);            //普通普通构造
228     MyClass _obj2(std::move(_obj)); //可能调用移动构造
229     //! [问-思考]
230 
231 
232     std::cout<<"-----------------"<<std::endl<<std::endl;
233 
234     char _str[8] = "abcdefg";
235     MyArray *_myStr = new MyArray(_str, sizeof(_str));
236     _myStr->print();
237 
238     MyArray *_myStrL = new MyArray(*_myStr);
239     _myStrL->print();
240     //delete _myStr; _myStr = 0;
241     delete _myStrL; _myStrL = 0;
242 
243     MyArray * _myStrR = new MyArray(std::move(*_myStr));
244     _myStrR->print();
245     delete _myStr; _myStr = 0;
246     delete _myStrR; _myStrR = 0;
247     //assert(1 == 2); 异常 条件不成立时异常
248     std::cout<<std::endl<<"------finish---"<<std::endl;
249     return a.exec();
250 }