std::get<C++11多线程库>(07)：向线程函数传递参数（3）

 /*
 * 实例场景：
 * 2. std::thread 构造函数的第一个参数为成员函数时，参数的传递。
 *    传递方式：std::thread第一个参数为成员函数的函数指针， std::thread 从第二个开始的参数，依次传递给成员函数的参数表
 *      Obj obj;
 *      std::thread t(&Obj::func, &obj, param1);
 *      std::thread t(&Obj::func, &obj, param1, param2, ..., paramn);
 *
 *  * * 分别就参数的几种常见形式进行讨论：
 *
 *      Object obj;
 *      Param param(10);
 *
 *        a) 参数为值类型，    例如 Param。     func形参地址与实参地址不同，发生了: 拷贝构造+移动构造。
 *           std::thread t(&Object::func, &obj, param);
 *
 *        b) 参数为引用类型，  例如 Param &。   func形参地址与实参地址分两种方式而不同  !!!请注意：默认变量类型和自定义类类型的情况并不一样!!!
 *           b-1) 默认方式
 *           std::thread t(&Object::func, &obj, param);  形参地址与实参地址不同， 发生了：拷贝构造。
 *
 *           b-2) std::ref() 方式
 *           std::thread t(&Object::func, &obj, std::ref(param)); 形参地址与实参地址相同， 未发生拷贝构造，未发生移动构造
 *
 *        c) 参数为指针类型，  例如 int *。   func形参地址与实参地址相同，未发生拷贝。
 *          std::thread t(&Object::func, &obj, &param);
 */

 * 问-思考：

 * 2. std::thread 构造函数执行时，不同的参数类型在传递时，都发生了什么事情？比如：值类型，引用类型，指针类型

//! [2] ====================== *实例场景-2=====+=====问-思考-2 *==================
template<typename T>
class luckyBear{
public:
    luckyBear(T t):m_t(t){
        std::cout<<"luckyBear<"<<_typeName()<<"> 构造函数执行..."<<std::endl;
    }
    luckyBear(luckyBear & other):m_t(other.m_t){
        std::cout<<"luckyBear<"<<_typeName()<<"> 拷贝构造函数执行..."<<std::endl;
    }
    luckyBear(luckyBear &&other){
        m_t = std::move(other.m_t);
        std::cout<<"luckyBear<"<<_typeName()<<"> 移动构造函数执行..."<<std::endl;
    }
    ~luckyBear(){
        std::cout<<"luckyBear<"<<_typeName()<<"> 析构函数执行..."<<std::endl;
    }

    void operator=(luckyBear &other){
        m_t = other.m_t;
        std::cout<<"luckyBear<"<<_typeName()<<"> 赋值运算符函数执行..."<<std::endl;
    }

    void operator=(luckyBear &&other){
        m_t = std::move(other.m_t);
        std::cout<<"luckyBear<"<<_typeName()<<"> 移动赋值运算符函数执行..."<<std::endl;
    }

    T value(){
        return m_t;
    }

private:
    std::string _typeName(){
       const std::type_info & _type = typeid(T);
       return _type.name();
    }

private:
    T m_t;
};


template<typename T>
class thread_test : public luckyBear<T>{

public:
    thread_test():luckyBear<T>(0){}
};

typedef luckyBear<int> VType;          //Value type
typedef luckyBear<int>& RType; //Reference type
typedef luckyBear<int>* PType; //Pointer type

class thread_construct{

public:
    void func1(VType v){
        std::cout<<v.value()<<std::endl;
    }

    void func2(RType rv){
        std::cout<<rv.value()<<std::endl;
    }

    void func3(PType pv){
        std::cout<<pv->value()<<std::endl;
    }
};

//! [2-1] 值类型传递： （1次）拷贝构造 + （1次）移动构造

//分析
/*
  1-从局部变量到线程的独立空间中，发生了拷贝构造；
  2-从线程的独立空间到线程入口函数，发生了移动构造；
  3-形参和实参地址不同；
*/
int main(int argc, char *argv[]){

    VType vt(10);

    thread_construct _c;
    std::thread _t1(&thread_construct::func1, &_c, vt);

    _t1.join();
    std::cout<<"...lucky bear..."<<std::endl;
    return 0;

}
//打印输出：
/*
    luckyBear<int> 构造函数执行...
    luckyBear<int> 拷贝构造函数执行...
    luckyBear<int> 移动构造函数执行...
    10
    luckyBear<int> 析构函数执行...
    luckyBear<int> 析构函数执行...
    ...lucky bear...
    luckyBear<int> 析构函数执行...
*/
//! [2-1]

//! [2-2-1] 引用类型传递--默认方式： （1次）拷贝构造

//分析
/*
    1. 从局部变量到线程的独立空间中，发生了拷贝构造， “默认参数要拷贝到线程独立内存中，即使参数是引用的形式”；
    2. 从线程的独立空间到线程入口函数，属于常规的给引用参数传值， 引用即别名，不开辟新空间；
    3. 形参和实参地址不同；
*/
int main(int argc, char *argv[]){

    VType vt(10);

    thread_construct _c;
    std::thread _t1(&thread_construct::func2, &_c, vt);   //默认方式

    _t1.join();
    std::cout<<"...lucky bear..."<<std::endl;
    return 0;
}
//打印输出：
/*
luckyBear<int> 构造函数执行...
luckyBear<int> 拷贝构造函数执行...
10
luckyBear<int> 析构函数执行...
...lucky bear...
luckyBear<int> 析构函数执行...
*/
//! [2-2-1]

//! [2-2-2] 引用类型传递--std::ref()方式：   不发生拷贝构造，不发生移动构造

//分析
/*
    1. 从局部变量到线程的独立空间中，属于常规的给引用参数传值， 引用即别名，不开辟新空间；
    2. 从线程的独立空间到线程入口函数，属于常规的给引用参数传值， 引用即别名，不开辟新空间；
    3. 形参和实参地址相同；
    4. std::ref() 方式传递引用类型参数，可以做到线程内对参数的修改会作用到线程外部的实参变量，反过来也是一样。
*/
int main(int argc, char *argv[]){

    VType vt(10);

    thread_construct _c;
    std::thread _t1(&thread_construct::func2, &_c, std::ref(vt));  //std::ref() 方式

    _t1.join();
    std::cout<<"...lucky bear..."<<std::endl;
    return 0;
}
//打印输出：
/*
luckyBear<int> 构造函数执行...
10
...lucky bear...
luckyBear<int> 析构函数执行...
*/
//! [2-2-2]

//! [2-3-1] 指针类型传递--默认方式：   不发生拷贝构造，不发生移动构造

//分析
/*
    1. 从局部变量到线程的独立空间中，属于常规的给指针参数传值， 多个指针指向同一地址空间，不开辟新空间；
    2. 从线程的独立空间到线程入口函数，属于常规的给指针参数传值， 多个指针指向同一地址空间，不开辟新空间；
    3. 形参和实参地址相同；
    4. 默认方式方式传递指针类型参数，可以做到线程内对参数的修改会作用到线程外部的实参变量，反过来也是一样。
*/
int main(int argc, char *argv[]){

    VType vt(10);

    thread_construct _c;
    std::thread _t1(&thread_construct::func3, &_c, &vt);  //默认方式

    _t1.join();
    std::cout<<"...lucky bear..."<<std::endl;
    return 0;
}
//打印输出：
/*
luckyBear<int> 构造函数执行...
10
...lucky bear...
luckyBear<int> 析构函数执行...
*/
//! [2-3-1]

//! [2-3-2] 指针类型传递--std::ref()方式：   不可以这样使用，编译报错

//分析
/*
*/
int main(int argc, char *argv[]){

    VType vt(10);

    thread_construct _c;

    //error info: C2893：未能使函数模板(unkown-type std::invoke(_Callable &&, _Types &&...)专用化
    //std::thread _t1(&thread_construct::func3, &_c,std::ref(vt));  //std::ref() 方式

    //_t1.join();
    std::cout<<"...lucky bear..."<<std::endl;
    return 0;
}
//打印输出：
/*
*/
//! [2-3-2]
//! [2]

std::get<C++11多线程库>(07)：向线程函数传递参数（4）

原创文章， 转载请注明出处！