std::get<C++11多线程库>(05)： 右值引用--移动语义--函数模板

#include <QCoreApplication>
#include <iostream>
#include <vector>
#include <assert.h>

#define Has_Move
/*
 * 话题：右值引用+移动语义+函数模板
 * 一、右值引用
 * 1. C++的引用允许你为已经存在的对象创建一个新的名字。对新引用所做的访问和修改操作，都会影响它的原型。
 * 2. C++11之前只有左值引用。
 *    lvalue这个词来自于C语言，指的是可以放在赋值表达式左边的事物——在栈上或堆上分配的命名对象，或者其他对象成员——有明确的内存地址；
 *    rvalue这个词也来源于C语言，指的是可以出现在赋值表达式右侧的对象——例如，文字常量和临时变量。因此，左值引用只能被绑定在左值上，而不是右值。
 *
 * 3. 右值不可以赋值给左值引用， 例如： int &i = 27;
 * 4. 右值可以赋值给左值的const引用， 例如：int const& i = 27; 也可以右值赋值给 const的左值引用 const int &i = 27;
 * 5. C++11标准介绍了右值引用(rvalue reference)，这种方式只能绑定右值，不能绑定左值。 例如：int&& i = 27;
 * 6. 有个有趣的现象： 右值引用可以赋值给左值的const引用，也可以赋值给 const的左值引用，但是反过来赋值不可以。
 *
 * 二、移动语义
 * 7. C++11新添语义——移动语义(move semantics)。
 * 8. 右值通常都是临时的。
 *    例如：函数返回值； 常量做参数传递；
 * 9. 当传递一个右值时，不会发生对象的拷贝， 而是一种“移动”，或者说是一种“窃取”。
 *    直接把对象从原来的所有者那里“窃取”过来，并且对象的所有状态不会发生改变。没有拷贝的发生，会节省很多的内存分配，性能更好。
 *    例如：需要传递一个 std::vector<int>，值传递时，需要分配同等大小的内存空间。
 * 10. C++标准库不会将一个对象显式的转移到另一个对象中，除非该对象将销毁的时候，或被赋值的时候(拷贝和移动的操作很相似)。
 *    参考：问-思考：2
 *
 * 三、右值引用与函数模板
 * 11. 当右值引用作为函数模板的参数时，实参既可以是左值，也可以是右值。
 *     因右值引用形如：T&& t，在实参像形参匹配的过程中， 有可能匹配为 TT & t(TT=T&), 也可能匹配为 TT t(TT=T&&)。
 *     因此会有这样的总结：如果函数模板的参数是右值引用，
 *          当实参为左值时， 模板会把实参类型当作左值引用，即 TT & t(TT=T&)；
 *          当实参为右值时， 模板会把实参类型当作普通数据使用。 即 TT t(TT=T&&)
 *
 *
 * 12. 很显然，左值移动 和 右值移动 可以作为函数重载。
 *    构造函数和移动构造函数就能说明这一点。
 *
 * 13. 实践中移动能保证类中的所有状态保持不变，表现良好
 *
 * 实例场景：
 * 1. 函数返回一个局部变量。
 *    使用移动语义， 不再需要将局部变量拷贝一个副本给返回值。
 *    std::string, std::vector<> 都是具备移动构造函数和移动赋值运算符的，就是为了避免拷贝大量数据。
 *
 *
 * 问-思考：
 * 1. 移动前后，两个变量的地址相同吗？
 *    答：不相同。
 * 2. 一个类同时具备拷贝拷贝构造函数和移动构造函数时， 什么情况下会调用拷贝构造？ 而什么情况下会调用移动构造呢？
 *    答：对于函数结束前返回临时对象的情况。
 *       若定义了移动构造函数，则不论返回时是否显示使用移动语义，都将调用移动构造函数；
 *       若未显示定义移动构造函数， 则不论返回时是否显示使用移动语义，都将调用普通的构造函数。
 *
 *       对于局部对象构造局部对象的情况。
 *       若定义了移动构造函数，则显示使用 std::move 时，调用移动构造函数，未显示使用 std::move 则调用普通的构造函数。
 *       若未定义移动构造函数，则不论是否使用 std::move， 都将调用普通的构造函数。
*/

//! [实例场景] -1
int func(){
    int a = 10;
    return std::move(a);
}

std::string func_1(){
    std::string _s = "abcdefg";
    return std::move(_s);
}

std::vector<int> func_2(){
    std::vector<int> _v = {1, 2, 3, 4, 5};
    return std::move(_v);
}

std::vector<std::string> func_3(){
    std::vector<std::string> _vs = {"abc", "def", "ghi"};
    return std::move(_vs);
}
//! [实例场景]


//! [问-思考] -1
std::string think_1(){
    std::string _s = "abcdefg";
    std::cout<<"In think_1 "<<_s<<" address is "<<&_s<<std::endl;
    return std::move(_s);
}
std::string& think_1_1(){ //返回引用编译能通过，运行会崩溃。 问-接龙：为什么移动构造函数不会崩溃
    std::string _s = "abcdefg";
    std::cout<<"In think_1_1 "<<_s<<" address is "<<&_s<<std::endl;
    return std::move(_s);
}
//! [问-思考]

//! [问-思考] -2
class MyClass{
public:
    MyClass(){}
    MyClass(MyClass & ){
        std::cout<<"invoke MyClass(MyClass & other)"<<std::endl;
    }
#ifdef Has_Move
    MyClass(MyClass &&){
        std::cout<<"invoke MyClass(MyClass &&other)"<<std::endl;
    }
#endif
};
MyClass think_2(){
    std::cout<<"In think_2"<<std::endl;

    MyClass obj;
    return obj;             //可能调用移动构造
}
MyClass think_2_1(){
    std::cout<<"In think_2_1"<<std::endl;

    MyClass obj;
    return std::move(obj);  //可能调用移动构造
}

MyClass& think_2_2(){//返回引用编译能通过，运行会崩溃。
    std::cout<<"In think_2_2"<<std::endl;

    MyClass obj;
    return std::move(obj);
}
//! [问-思考]

class MyArray{
public:
    MyArray(char str[], int len):_str(new char[1000]){
        std::cout<<"len "<<len<<std::endl;
        std::copy(str, str+len, _str);
    }
    MyArray(MyArray & other):_str(new char[1000]){
        std::cout<<"Invoke MyArray(MyArray & other)"<<std::endl;
        std::copy(other._str, other._str+1000, _str);
    }
    MyArray(MyArray &&other):_str(other._str){
        std::cout<<"Invoke MyArray(MyArray &&other)"<<std::endl;
        other._str=0;
    }

    ~MyArray(){
        delete[] _str;
    }
    void print(){
        std::cout<<_str<<std::endl;
    }

private:
    char * _str;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    //! [话题] -6
    //int& _iref = 27;   //error: C2440："初始化"：无法从"int"转换为"int&"
    const int & _ciref = 27;
    int const& _icref = 27;
    std::cout<<"_ciref="<<_ciref<<std::endl;
    std::cout<<"_icref="<<_icref<<std::endl;

    int && _irref = 27;
    //int && _irref1 = _ciref; //error: C2440："初始化"：无法从"const int"转换为"int&&"
    //int && _irref2 = _icref; //error: C2440："初始化"：无法从"const int"转换为"int&&"
    const int & _ciref1 = _irref;  //! 特别注意 可以从 int&& 到 const int
    int const & _icref1 = _irref;  //! 特别注意 可以从 int&& 到 int const
    std::cout<<"_ciref1="<<_ciref<<std::endl;
    std::cout<<"_icref1="<<_icref<<std::endl;

    std::cout<<"-----------------"<<std::endl<<std::endl;
    //int const & 和 const int & 这两种类型相同吗？
    //auto _type1 = typeid(_ciref);
    //auto _type2 = typeid(_icref);
    const std::type_info& _type1 = typeid(_ciref);
    const std::type_info& _type2 = typeid(_icref);
    std::cout<<"const int & _ciref, _ciref type is "<<_type1.name()<<std::endl; //两种都是 int 类型，有点扑朔迷离
    std::cout<<"int const& _icref, _icref type is "<<_type2.name()<<std::endl;  //两种都是 int 类型，有点扑朔迷离
    //! [话题]

    std::cout<<"-----------------"<<std::endl<<std::endl;

    //! [实例场景] -1
    std::cout<<func()<<std::endl;

    std::cout<<func_1()<<std::endl;

    std::vector<int> _v = func_2();
    //std::copy(_v.begin(), _v.end(), &std::cout);  //error info: C2697 二进制 "="：没有找到接受"int"类型的右操作数的运算符(或没有可接受的转换)
    for (auto v : _v)
        std::cout<<v;
    std::cout<<std::endl;

    std::vector<std::string> _vs = func_3();
    //std::copy(_vs.begin(), _vs.end(), &std::cout);  //error info: C2697 二进制 “=”：没有找到接受
                                                    //std::basic_string<char, std::char_traits<char>, std::allocator<char>>
                                                    //类型的右操作数的运算符（或没有可接受的转换）
    for (auto s : _vs)
        std::cout<<s;
    std::cout<<std::endl;
    //! [实例场景]

    std::cout<<"-----------------"<<std::endl<<std::endl;

    //! [问-思考] -1
    std::string _s1 = think_1();
    std::cout<<_s1<<" address is "<<&_s1<<std::endl;

    //std::string _s1_1 = think_1_1();  //崩溃了
    //std::string _s1_1(think_1_1());   //崩溃了
    //std::cout<<_s1_1<<" address is "<<&_s1_1<<std::endl;

    //! [问-思考]

    //! [问-思考] -2
    think_2();
    think_2_1();
    //think_2_2();

    MyClass _obj;
    MyClass _obj1(_obj);            //普通普通构造
    MyClass _obj2(std::move(_obj)); //可能调用移动构造
    //! [问-思考]


    std::cout<<"-----------------"<<std::endl<<std::endl;

    char _str[8] = "abcdefg";
    MyArray *_myStr = new MyArray(_str, sizeof(_str));
    _myStr->print();

    MyArray *_myStrL = new MyArray(*_myStr);
    _myStrL->print();
    //delete _myStr; _myStr = 0;
    delete _myStrL; _myStrL = 0;

    MyArray * _myStrR = new MyArray(std::move(*_myStr));
    _myStrR->print();
    delete _myStr; _myStr = 0;
    delete _myStrR; _myStrR = 0;
    //assert(1 == 2); 异常 条件不成立时异常
    std::cout<<std::endl<<"------finish---"<<std::endl;
    return a.exec();
}