C++线程传参详解

最新推荐文章于 2024-07-27 21:23:43 发布
最新推荐文章于 2024-07-27 21:23:43 发布
阅读量1.7k 收藏
点赞数
分类专栏： c++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wade1010/article/details/128621135
版权 
#include <iostream>
#include <thread>
using namespace std;

// void myprint(const int &argi, char *pch)
// void myprint(const int argi, char *pch)
void myprint(const int argi, const string &pch) // 发生隐式转换
{
    cout << argi << endl; // 分析认为:argi并不是外部i的引用,实际是值传递,则认为即使th执行了detach,那么子线程中用i值仍然是安全的
    // cout << pch << endl;  // 指针在detach子线程时,绝对是会有问题的
    cout << pch.c_str() << endl; // 指针在detach子线程时,绝对是会有问题的
}

int main()
{
    // 一: 创建临时对象作为线程参数
    //(1.1)要避免的陷阱(解释1)
    int i = 1;
    int &ri = i;
    char ch[] = "hello world";
    // 因为是引用 i和&ri的地址是一样的
    thread th(myprint, ri, ch); // 形参是指针 数组名也是指针,指向同一地址
    // th.join();
    th.detach(); // 使用detach的时候,不推荐用引用,绝对不能用指针
    cout << "end main" << endl;
    return 0;
}

上面代码运行时正常的,看似没有问题,

但是传参的时候,ch到底是什么时候转成string的,

如果main函数执行完,你再转成string,那也就是有问题的,因为这时候ch已经被系统回收了,再转的结果就是不可预料

事实上存在,ch都被回收了(main函数执行完了),系统才用ch去转string的可能性

经过查资料,最终应该改成

thread th(myprint, ri, string(ch));//临时构造一个string对象作为实参传递,不用发生隐式转换

那么如何确定string(ch)确实是在main函数结束前执行的呢?

下面通过一个自定义类来验证

#include <iostream>
#include <thread>
using namespace std;

class A
{
public:
    int m_i;
    A(int a) : m_i(a) { cout << "构造函数执行" << endl; }
    A(const A &a) : m_i(a.m_i) { cout << "拷贝构造函数执行" << endl; }
    // A(A &&a) : m_i(a.m_i) { cout << "移动函数执行" << endl; }
    ~A() { cout << "析构函数执行" << endl; }
};

void myprint(const int argi, const A &a)
{
    cout << &a << endl;
}

int main()
{
    int i = 1;
    int j = 10;
    // thread th(myprint, i, j);    // 传j,调用构造函数A(int a) 将一个数字转为A对象,执行程序的时候,构造函数没来得及执行,说明构造是在子线程中完成
    thread th(myprint, i, A(j)); // 匿名对象,构造函数是在主线程中完成,然后调用拷贝构造生成一个副本,这个副本才是按照引用传递给myprint的实参,这个也是在主线程中完成的
    // thread th(myprint, i, A(j)); //在创建线程的同事构造临时对象的方法传递参数是可行的
    th.detach();
    // th.join();
    cout << "end main" << endl;
    return 0;
}

/*
thread的参数是右值引用,上例中A没有移动构造,传参的时候找不到移动构造,就会找拷贝构造
 */

再测试下

#include <iostream>
#include <thread>
using namespace std;

class A
{
public:
    int m_i;
    A(int a) : m_i(a) { cout << "构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    A(const A &a) : m_i(a.m_i) { cout << "拷贝构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    // A(A &&a) : m_i(a.m_i) { cout << "移动函数执行" << endl; }
    ~A() { cout << "析构函数执行,thread_id:" << this_thread::get_id() << endl; }
};

void myprint(const A &a)
{
    cout << &a << ' ' << this_thread::get_id() << endl;
}

int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    int j = 10;
    // thread th(myprint, A(j));
    thread th(myprint, j);
    th.join();
    // th.detach();
    cout << "end main" << endl;
    return 0;
}

两种情况

1:使用 thread th(myprint, A(j));

主线程id:1

构造函数执行,thread_id:1

拷贝构造函数执行,thread_id:1

析构函数执行,thread_id:1

0x1b601f026a8 2

析构函数执行,thread_id:2

end main

2:使用 thread th(myprint, j);

主线程id:1

构造函数执行,thread_id:2

0x68b65ffb2c 2

析构函数执行,thread_id:2

end main

再进行测试，把myprint改成非引用

#include <iostream>
#include <thread>
using namespace std;

class A
{
public:
    int m_i;
    A(int a) : m_i(a) { cout << "构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    A(const A &a) : m_i(a.m_i) { cout << "拷贝构造函数执行,thread_id:" << this_thread::get_id() << ",&a=" << &a << ",&this:" << this << endl; }
    // A(A &&a) : m_i(a.m_i) { cout << "移动函数执行" << endl; }
    ~A() { cout << "析构函数执行,thread_id:" << this_thread::get_id() << endl; }
};

void myprint(const A &a)
{
    cout << &a << ' ' << this_thread::get_id() << endl;
}

int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    int j = 10;
    thread th(myprint, A(j));
    // thread th(myprint, j);
    th.join();
    cout << "end main" << endl;
    return 0;
}

1:使用 void myprint(const A &a);

主线程id:1

构造函数执行,thread_id:1

拷贝构造函数执行,thread_id:1,&a=0xef1bdff5f8,&this:0x25f927803a8

析构函数执行,thread_id:1

0x25f927803a8 2

析构函数执行,thread_id:2

end main

2:使用 void myprint(const A a);

主线程id:1

构造函数执行,thread_id:1

拷贝构造函数执行,thread_id:1,&a=0x67a15ff5f8,&this:0x1e00aaa4758

析构函数执行,thread_id:1

拷贝构造函数执行,thread_id:2,&a=0x1e00aaa4758,&this:0x67a1dff88c

0x67a1dff88c 2

析构函数执行,thread_id:2

析构函数执行,thread_id:2

end main

可以看出是拷贝一份到子线程，然后如果myprint的形参是用引用，则直接使用这份拷贝的数据，如果不是引用，是A对象接收，则会将该副本再拷贝一次。

传递类对象、智能指针作为线程参数

std::ref()函数

#include <iostream>
#include <thread>
using namespace std;

class A
{
public:
    mutable int m_i;
    A(int a) : m_i(a) { cout << "构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    A(const A &a) : m_i(a.m_i) { cout << "拷贝构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    // A(A &&a) : m_i(a.m_i) { cout << "移动函数执行" << endl; }
    ~A() { cout << "析构函数执行,thread_id:" << this_thread::get_id() << endl; }
};

void myprint(const A &a)//这里const不能去掉，个人觉得，因主线程中是值传递，这里如果可以修改，也是修改拷贝过来的内容，没有任何意义，所以编译器，要求传值时要const，传引用就不要const了
{
    a.m_i = 1111;
    cout << &a << ' ' << this_thread::get_id() << endl;
}

int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    A a(10);
    thread th(myprint, a);
    th.join();
    // th.detach();
    cout << "end main" << ' ' << a.m_i << endl;
    return 0;
}

主线程id:1
构造函数执行,thread_id:1
拷贝构造函数执行,thread_id:1
0x2f1a22fe9f8 2
析构函数执行,thread_id:2
end main 10
析构函数执行,thread_id:1

上面代码是修改备份中的内容，所以主线程中的a不会被修改。

如果修改，可以使用ref传引用

#include <iostream>
#include <thread>
using namespace std;

class A
{
public:
    int m_i;
    A(int a) : m_i(a) { cout << "构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    A(const A &a) : m_i(a.m_i) { cout << "拷贝构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    // A(A &&a) : m_i(a.m_i) { cout << "移动函数执行" << endl; }
    ~A() { cout << "析构函数执行,thread_id:" << this_thread::get_id() << endl; }
};

void myprint(A &a)
{
    a.m_i = 1111;
    cout << &a << ' ' << this_thread::get_id() << endl;
}

int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    A a(10);
    thread th(myprint, ref(a));
    th.join();
    // th.detach();
    cout << "end main" << ' ' << a.m_i << endl;
    return 0;
}
主线程id:1
构造函数执行,thread_id:1
0xb5d03ff994 2
end main 1111
析构函数执行,thread_id:1

传递智能指针

#include <iostream>
#include <thread>
using namespace std;

class A
{
public:
    int m_i;
    A(int a) : m_i(a) { cout << "构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    A(const A &a) : m_i(a.m_i) { cout << "拷贝构造函数执行,thread_id:" << this_thread::get_id() << endl; }
    // A(A &&a) : m_i(a.m_i) { cout << "移动函数执行" << endl; }
    ~A() { cout << "析构函数执行,thread_id:" << this_thread::get_id() << endl; }
};

void myprint(A &a)
{
    a.m_i = 1111;
    cout << &a << ' ' << this_thread::get_id() << endl;
}

void myprint2(unique_ptr<int> uptr)
{
    cout << this_thread::get_id() << endl;
}

int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    // A a(10);
    // thread th(myprint, ref(a));

    thread th(myprint2, unique_ptr<int>(new int(100)));
    // unique_ptr<int> muptr(new int(100));
    // thread th(myprint2, move(muptr));//unique_ptr已经删除了拷贝构造,所以这里得用move

    th.join();
    // th.detach();
    cout << "end main" << endl;
    return 0;
}

3333333_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++：多线程中的小白（3）线程传参详解
m0_37957160的博客
12-09 817
（1）传递临时对象作为线程参数 （2）传递类对象智能指针作为线程参数 （3）用成员函数指针做线程函数 在实际工作中我们要创建的线程可能不止一个，比如说我们要创建10个，编号从0到9，这10个线程会根据自己的编号确定自己要干的事情，这个线程如何知道自己的编号呢，这个就需要我们给线程传递参数（比如我们传递0123456789这10个数，那么线程就通过接收的这个参数就知道自己的编号了。）。 void myprint(const int &i,char *pmybuf) { cout&lt
C++ thread线程函数传参原理剖析
大秦坑王的专栏
03-18 3412
通过C++ Thread类库源码剖析thread线程函数传参原理
C++多线程传参详解
mingwu96的博客
02-20 7271
目录 1.线程传参的过程 1.1 内置类型的实参 1.1.1参数按值传递 1.1.2如果想按引用传递，则需要调用std::ref 1.2 类类型的实参 1.2.1 传递的是左值对象 1.2.2 传递的是临时对象（即右值对象） 1.2.3 传递的参数需要隐式类型转换 1.2.4 传递的参数是指针 1.3 传入智能指针unique_ptr 1.线程传参的过程 下面是thread的源代码 template< class Function, class... Args &g
1 c++多线程创建和传参
xihuanniNI的博客
06-10 820
c++多线程系列
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
森明帮大于黑虎帮的博客
11-13 3577
C++11多线程第三篇：线程传参详解，detach()大坑，成员函数做线程参数
C++11多线程 多线程传参详解
u012507022的博客
01-05 4798
1.传递临时对象做线程参数 1.1要避免的陷阱1 用detach()时，如果主线程先结束，变量就会被回收；所以用detach()的话，不推荐用引用，同时绝对不能用指针。 1.2要避免的陷阱2 只要临时对象的用临时构造A类对象作为参数传递给线程，那么就一定能够在主线程结束之前，把线程函数的第二个参数构建出来，从而确保即便detach()子线程也安全运行，程序如下： #include&lt...
17.3 C++并发与多线程-线程传参详解、detach坑与成员函数作为线程函数
migu123的专栏
02-02 275
范例演示线程运行的开始和结束，（1）要避免的陷阱1（2）要避免的陷阱2（3）总结 3.2 临时对象作为线程参数继续讲（1）线程idg概念（2）临时对象构造时机抓捕 3.3 传递类对象与智能指针作为线程参数 3.4 用成员函数作为线程入口函数
【学习笔记】C++并发与多线程笔记二：线程传参
Rain_Mic的博客
03-22 1378
本文接上文 【学习笔记】C++并发与多线程笔记一 的内容，主要包含线程传参详解，detach()的坑以及成员函数做线程函数。
C++11并发与多线程笔记（3）线程传参详解，detach()大坑，成员函数做线程函数
Lakers
08-16 1618
C++11并发与多线程笔记（3）线程传参详解，detach()大坑，成员函数做线程函数
线程传参详解，detach()大坑，成员函数做线程函数
Scarlett的博客
02-20 1439
一、传递临时对象作为线程参数 1.1 要避免的陷阱1 #include<iostream> #include<thread> using namespace std; void myprint(const int &i,char* pmybuf) { cout << i << endl; cout << pmybuf << endl; return; } int main() { int mvar = 6; in
C++11/14 线程调用类对象和线程传参的方法
08-26
C++11/14 线程调用类对象和线程传参的方法 C++11/14 中引入了 std::thread 类，允许开发者创建和管理线程。然而，在使用 std::thread 时，需要注意线程调用类对象和线程传参的方法。 线程调用类对象 在 C++11/14 ...
C++多线程获取返回值方法详解
08-19
C++多线程获取返回值方法详解 在C++多线程编程中，获取线程返回值是一个很重要的 topic。在C++11标准中，std::thread对象会忽略顶层函数的返回值，这就使得获取线程返回值变得困难。下面我们将详细介绍两种获取...
C++多线程详解
03-29
在C++编程中，多线程技术是一种强大的工具，它允许程序同时执行多个任务，从而提高了效率和响应性。本文将深入探讨C++中的多线程，并解释如何创建、管理和同步线程，以及讨论相关的重要概念。 首先，C++11引入了...
C++ 线程（串行 并行 同步 异步）详解
08-30
C++ 线程（串行 并行 同步 异步）详解 C++ 线程是指在程序中可以同时执行多个任务的技术，通过线程可以提高程序的执行效率和响应速度。在 C++ 中，线程可以分为串行线程和并行线程两种。 串行线程（Serial Thread...
C++线程同步实例分析
12-31
本文实例分析了C++线程同步问题，分享给大家供大家参考。具体分析如下： 该实例设置全局变量g_bContinue，在主线程中设置全局变量g_bContinue，工作线程检测该全局变量，实现主线程控制工作线程的目的。 打印出的g_...
2024年C++面试题汇总及答案解析
soaring_casia的专栏
07-25 590
唯一的指针，不允许其他指针与他共享指向的对象。比如指针指向的内存被释放了，但是指针没有置nullptr. 多个指针指向同一个内存，当free掉一个指针之后，其他指针就变成了野指针。C++这些年虽然难度大，但是热度仍然不减，在编程排行榜基本上都是前几位，得益于它良好的薪资待遇。SPI协议是一种采用主从模式的串行，全双工，同步通信总线，包括时钟，输入，输出，片选四个信号线，片选信号用于选择slave设备，输入输出的每个bit都需要和时钟沿同步。区别：指针指向一块儿内存，他的内容是所指内存的地址。
C++：文件操作基础
最新发布
2301_79959126的博客
07-27 126
本文介绍了如何用C++实现基本的文件操作，主要讲解了fstream库的几个基础函数。
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 400
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值