C++线程传参详解

最新推荐文章于 2025-06-23 15:22:44 发布
原创 最新推荐文章于 2025-06-23 15:22:44 发布 · 1.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #学习 #开发语言 

#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;
}

【6】c++多线程技术之线程的参数传递
以道御术
04-13 473
在C++中，向线程传递参数的方式主要有两种：一种是通过函数参数，另一种是通过类成员。
C++：多线程中的小白（3）线程传参详解
m0_37957160的博客
12-09 911
（1）传递临时对象作为线程参数 （2）传递类对象智能指针作为线程参数 （3）用成员函数指针做线程函数 在实际工作中我们要创建的线程可能不止一个，比如说我们要创建10个，编号从0到9，这10个线程会根据自己的编号确定自己要干的事情，这个线程如何知道自己的编号呢，这个就需要我们给线程传递参数（比如我们传递0123456789这10个数，那么线程就通过接收的这个参数就知道自己的编号了。）。 void myprint(const int &i,char *pmybuf) { cout&lt
C++ thread线程函数传参原理剖析
大秦坑王的专栏
03-18 4837
通过C++ Thread类库源码剖析thread线程函数传参原理
C++ 不同线程之间传值
m0_57249200的博客
06-23 329
不同线程之间传值，常见有以下的方式，避免用。
C++的并发世界（四）——线程传参
图像学习之旅
04-02 436
在线程引用中需要使用ref函数引用参数。③传递的指针变量的生命周期小于线程。②多线程共享访问一块空间。
C++11/14 线程调用类对象和线程传参的方法
12-31
线程调用类对象 在前面的示例中，我们为线程任务使用了通常的函数。实际上，我们可以使用任何可调用对象或者lambda函数，如下调用类对象的例子： #include <iostream> #include <thread> class MyFunctor { public: void operator()() { std::cout << functor\n; } }; int main() { MyFunctor fnctor; std::thread t(fnctor); std::cout << main thread\n; t.join();
C++新特性（六）多线程（1）线程启动、结束，创建线程、join，detach，线程传参详解
weixin_42445051的博客
02-10 1808
1，整个程序从main函数开始执行主线程，而我们自己创建的线程，同样是由一个我们自己定义的函数开始执行。 2，整个进程是否执行完毕的标志是主线程是否执行完，如果主线程执行完毕了,就代表整个进程执行完毕了;此时，一般情况下:如果其他子线程还没有执行完毕，那么这些子线程也会被操作系统强行终止。所以，一般情况下，我们得到一个结论:如果大家想保持子线程的运行状态的话，那么要让主线程一直保持运行，当然这种规定也有例外，以后会讲到。 3，头文件#include<thread> 4，一个超级简单的多线程例子演
C++11并发与多线程笔记（3）线程传参详解，detach()大坑，成员函数做线程函数
Lakers
08-16 1953
C++11并发与多线程笔记（3）线程传参详解，detach()大坑，成员函数做线程函数
线程传参详解，detach()大坑，成员函数做线程函数
Scarlett的博客
02-20 1547
一、传递临时对象作为线程参数 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++ 学习之 多线程（二） thread的参数传递
weixin_45074185的博客
02-18 5222
c++ 学习之 多线程（二） thread的参数传递 前言 上一篇文章中讲了thread的四种构造函数，接下来给大家讲一讲thread的参数传递。 正文 1.初始化构造函数 利用初始化构造函数创建对象，第一个位置必须要传入一个可调用对象。c++ 中的可调用对象大概有这么几种：普通函数 ，类成员函数，类静态函数，仿函数，函数指针，lambda表达式，std::function。 （1）普通函数 用普...
线程间通信方式2：参数传递方式
01-11
线程间通信方式2：参数传递方式。通过3类线程的创建方法，演示了给线程传递方式的方式，包括;单参数、多参数和类3类。
C++笔记之初始化线程的所有方法以及多线程传参的方式比较
小勇博客
06-17 959
【代码】C++笔记之初始化线程的所有方法。
[多线程] C++11 thread对象的join()和detach()的区别 & thread没有join()导致进程崩溃
zlllc的博客
01-10 997
之前写代码的时候，忘记写join()，结果进程崩溃了。这篇文章记录一下join()的必要性。
c++线程传参
heeheeai的博客
07-22 1215
是 C++11 引入的，用于在 std::bind 或者 std::async 中引用成员函数或者非成员函数。这些函数主要在多线程中使用，目的是在函数调用中保持对象的引用，而不是复制对象。例如，在多线程中，如果想在另一个线程中调用一个对象的成员函数，并且这个对象不是常量的，可以使用。这意味着将通过const引用传递对象，不能在被调用的函数中修改这个对象。对象，可以将这个对象传递给 std::bind 或 std::async，或者在其他需要函数调用的地方使用。在这个例子中，定义了一个函数。
C++多线程传参详解
mingwu96的博客
02-20 7689
目录 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
C++并发与多线程学习(2)：线程传参
qq_40194724的博客
09-07 284
C++多线程传参的三种方式 传入普通参数 传入引用 传入指针(不使用，因为如果主线程的资源被释放，那么子线程将会发生错误) 1. 传入普通的参数 普通参数传入线程是进行一份拷贝。对于类对象会调用拷贝构造函数。 void threadFunction(int x, string str) { cout << &x <<endl; cout << "x is " << x << " and str is " << st.
【学习笔记】C++并发与多线程笔记二：线程传参
Rain_Mic的博客
03-22 1776
本文接上文 【学习笔记】C++并发与多线程笔记一 的内容，主要包含线程传参详解，detach()的坑以及成员函数做线程函数。
C++中线程的创建及传参
百里鹤的专栏
12-05 1027
CreateThread()的使用 DWORD WINAPI displayText1(LPVOID param){    CString textTmp1;    CString strOut;    textTmp1="线程运行：";    CThreadTestDlg* pDlg = (CThreadTestDlg*)param;    int i
C++11向线程函数传递参数
Keep Moving~
04-20 9388
template< class Function, class... Args > explicit thread( Function&& f, Args&&... args ); 这个是std::thread构造函数之一，其中f是可调用对象，args是传递给f的参数。 默认传递给f的是按值复制，若需要传递引用参数给线程函数，则必须包装它（例如用 s...
方法传参
最新发布
07-29
<think>首先，用户的问题是关于编程中方法传参的机制：如何正确传递参数。我需要根据系统级指令和用户可见层的要求来回答。 关键指令： - 所有行内数学表达式使用$...$格式。 - 独立公式使用$$...$$格式并单独成段。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾自然地添加引用标识，如[^1]。 - 回答结构清晰，帮助用户逐步解决问题。 - 保证回答真实可靠。 参考的引用内容： - 引用[1]：Python参数传递机制，值传递和引用传递。 - 引用[2]：不同语言参数传递机制的对比。 - 引用[3]：Java传参机制，值传递和引用传递。 - 引用[4]：Python函数参数传递机制及高级应用。 - 引用[5]：TransmittableThreadLocal的使用，解决线程池参数传递问题。 用户的问题聚焦于方法传参的机制，所以我需要解释编程中参数传递的基本概念，并结合不同语言如Python、Java等。 结构化回答： 1. **介绍参数传递的基本概念**：解释什么是参数传递，值传递和引用传递的区别。 2. **详细解释值传递和引用传递**：用例子说明。 3. **语言特定机制**：讨论Python、Java等常见语言的参数传递方式。 4. **高级应用**：如Python中的打包和解包参数。 5. **正确传递参数的技巧**：如何避免常见错误。 6. **生成相关问题**：在末尾添加相关问题。 使用引用：在回答中，当引用特定段落时，添加引用标识。例如，如果提到Python的值传递，引用[^1]。 数学表达式：由于问题是关于编程的，可能不需要数学表达式，但如果涉及，确保正确格式。例如，如果讨论算法复杂度，可以用$O(n)$。 现在，构建回答大纲： - **开头**：简要介绍参数传递的重要性。 - **主体**： - 解释值传递和引用传递。 - 举例说明（如Python中的行为）。 - 讨论不同语言的差异。 - 高级技巧如Python的*args和**kwargs。 - 如何正确传递参数，避免陷阱。 - **结尾**：总结关键点，生成相关问题。 生成相关问题： - 基于主题，如参数传递的优化、常见错误、语言特定细节等。 确保中文回答。 最终回答结构： - 清晰分段。 - 在适当位置添加引用。 - 末尾添加相关问题。</think>### 编程中方法参数传递机制详解 在编程中，方法（或函数）的参数传递机制是核心概念之一，它决定了如何将数据从调用方传递给函数。参数传递机制主要分为两种：**值传递**和**引用传递**。理解这些机制有助于避免常见错误，如意外修改数据或性能问题。下面我将逐步解释其原理、语言差异、正确传递参数的方法，并结合实际示例说明。 #### 1. **参数传递的基本机制** 参数传递的核心是数据如何被复制或共享： - **值传递（Pass-by-Value）**：调用函数时，传递的是变量的**副本**。函数内部对参数的修改不会影响原始变量。这适用于基本数据类型（如整数、浮点数），因为操作副本更安全。例如，在Python中，基本类型的传递是值传递： ```python def modify_value(x): x = x + 10 # 修改副本，不影响原始变量 return x num = 5 result = modify_value(num) print(num) # 输出: 5（原始值不变） ``` 这里，`num`的值被复制给`x`，函数内的操作不影响`num`[^1]。 - **引用传递（Pass-by-Reference）**：传递的是变量的**内存地址**（引用）。函数内部对参数的修改直接影响原始变量。这常用于对象类型（如列表、字典），因为直接操作内存更高效。例如，在Python中，列表的传递是引用传递： ```python def modify_list(lst): lst.append(10) # 修改引用指向的对象，影响原始列表 my_list = [1, 2, 3] modify_list(my_list) print(my_list) # 输出: [1, 2, 3, 10]（原始列表被修改） ``` 在这个例子中，`my_list`的引用被传递给`lst`，函数内的操作直接改变原始数据[^1]。 值传递和引用传递的区别在于：值传递保护原始数据，但可能增加复制开销；引用传递高效，但需谨慎避免副作用（如意外修改）。正确选择取决于数据类型和需求。 #### 2. **不同编程语言的参数传递机制** 不同语言实现参数传递的方式各异，以下是常见语言的对比： - **Python**：所有参数传递本质上是**值传递**，但传递的是对象的引用（即引用值传递）。对于不可变对象（如整数、字符串），行为像值传递；对于可变对象（如列表、字典），行为像引用传递。Python还支持高级参数处理，如打包和解包： - **打包**：使用`*args`将位置参数打包为元组，`**kwargs`将关键字参数打包为字典。 - **解包**：在函数调用时，使用`*`和`**`将可迭代对象解构为单独参数。 例如： ```python def example(a, *args, **kwargs): print(a) # 输出: 1 print(args) # 输出: (2, 3)（打包的位置参数） print(kwargs) # 输出: {'b': 4}（打包的关键字参数） example(1, 2, 3, b=4) # 解包调用 ``` 这种方式使代码更灵活，但需注意引用传递的风险[^4]。 - **Java**：严格区分值传递和引用传递： - 基本数据类型（如`int`, `float`）使用值传递：传递副本，修改不影响原始值。 - 对象类型（如`String`, `List`）使用引用值传递：传递对象引用的副本，函数内修改对象属性会影响原始对象，但重新赋值引用不会。 例如： ```java void modifyObject(StringBuilder sb) { sb.append(" World"); // 修改对象属性，影响原始对象 sb = new StringBuilder("New"); // 重新赋值引用，不影响原始对象 } public static void main(String[] args) { StringBuilder str = new StringBuilder("Hello"); modifyObject(str); System.out.println(str); // 输出: "Hello World"（属性被修改） } ``` 这里，`sb`的引用副本被传递，修改对象内容有效，但改变引用本身无效[^3]。 - **JavaScript**：类似Python，基本类型值传递，对象类型引用传递。例如，数字传递副本，对象传递引用。 - **C++**：支持显式值传递（`void func(int x)`）和引用传递（`void func(int &x)`），开发者需手动指定。 总结上表对比： | 语言 | 基本数据类型传递 | 对象类型传递 | |------------|------------------|--------------------| | Python | 值传递（引用值） | 引用传递（引用值） | | Java | 值传递 | 引用值传递 | | C++ | 值传递/引用传递 | 值传递/引用传递 | | JavaScript | 值传递 | 引用传递 | [^2] 关键点：大多数语言（如Python、Java）采用“引用值传递”对象，即传递引用的副本，而非原始引用本身。这平衡了效率和安全性。 #### 3. **如何正确传递参数：最佳实践** 正确传递参数可避免错误并提升代码质量： - **选择合适机制**： - 使用值传递保护原始数据（如函数不应修改输入时）。 - 使用引用传递优化性能（如传递大型对象时）。 - **避免常见陷阱**： - **意外修改**：在函数内操作可变对象时，先创建副本（如Python的`lst.copy()`）。 - **线程安全**：在多线程环境中，使用线程局部存储（如Java的`TransmittableThreadLocal`）安全传递参数。例如： ```java TransmittableThreadLocal<String> threadLocal = new TransmittableThreadLocal<>(); threadLocal.set("Main Value"); // 线程池任务可继承threadLocal值，避免参数丢失 ``` 这解决了线程池中的参数传递问题[^5]。 - **默认参数**：在Python中，避免使用可变对象作为默认值（如`def func(lst=[])`），因为它是共享引用。 - **高级技巧**： - **参数解包**：在Python中，利用`*`和`**`简化函数调用： ```python params = (1, 2) kwargs = {'c': 3} def sum(a, b, c): return a + b + c result = sum(*params, **kwargs) # 输出: 6 ``` 这使代码更简洁[^4]。 - **不可变设计**：优先使用不可变对象（如Python元组），减少副作用风险。 #### 4. **总结与建议** 参数传递机制的核心是理解数据复制与共享的平衡：值传递确保安全，引用传递提升效率。在Python中，所有传递都是引用值传递；在Java中，基本类型值传递，对象引用值传递。正确传递参数的关键是： - 明确数据类型（基本或对象）。 - 在需要时创建副本。 - 利用语言特性（如Python打包/解包）。 - 测试边界情况（如多线程环境）。 通过掌握这些机制，您可以编写更可靠、高效的代码。如果您有具体语言或场景的疑问，欢迎进一步讨论。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值