创建线程时传递参数给线程

在C++中，可以使用 std::thread 来创建和管理线程，同时可以通过几种方式将参数传递给线程函数。这些方法包括使用值传递、引用传递和指针传递。下面将对这些方法进行详细讲解并给出相应的代码示例。

**1.**值传递参数

当你创建线程并希望传递参数时，可以直接将参数作为 std::thread 构造函数的参数传递。这会将参数的副本传递给线程。

示例代码：使用值传递参数

cpp 复制代码

#include <iostream>
#include <thread>

void thread_function(int value) {
    std::cout << "Thread received value: " << value << std::endl;
}

int main() {
    int value_to_pass = 10;
    std::thread t(thread_function, value_to_pass); // 传递参数
    t.join(); // 等待线程完成
    return 0;
}

**2.**引用传递参数

如果希望传递参数的引用，以避免复制开销，可以使用 std::ref() 来包装参数。这对于大型对象特别有用。

示例代码：使用引用传递参数

cpp 复制代码

#include <iostream>
#include <thread>
#include <vector>
#include <functional> // 为 std::ref 使用

void thread_function(std::vector<int>& vec) {
    vec.push_back(5); // 修改传入的向量
    std::cout << "Thread modified vector to include 5." << std::endl;
}

int main() {
    std::vector<int> vec;
    std::thread t(thread_function, std::ref(vec)); // 传递引用
    t.join(); // 等待线程完成

    std::cout << "Vector size after thread: " << vec.size() << std::endl; // 输出：1
    return 0;
}

**3.**传递结构体或类对象

可以通过传递结构体或类对象的方式将多个参数传递给线程。这个过程与使用值传递或引用传递相结合，可以根据需要进行操作。

示例代码：传递结构体作为参数

cpp 复制代码

#include <iostream>
#include <thread>

struct ThreadData {
    int id;
    std::string message;
};


void thread_function(ThreadData data) {
    std::cout << "Thread " << data.id << ": " << data.message << std::endl;
}

int main() {
    ThreadData data = {1, "Hello from thread!"};
    std::thread t(thread_function, data); // 传递结构体
    t.join(); // 等待线程完成
    return 0;
}

**4.**线程接受多个参数

通过将多个参数传递给线程，可以直接在创建 std::thread 时指定多个参数。

示例代码：传递多个参数

cpp 复制代码

#include <iostream>
#include <thread>

void thread_function(int a, double b) {
    std::cout << "Thread received integer: " << a << " and double: " << b << std::endl;
}

int main() {
    std::thread t(thread_function, 42, 3.14); // 传递多个参数
    t.join(); // 等待线程完成
    return 0;
}

总结

通过以上示例，我们展示了在C++中创建线程及传递参数的不同方式：

值传递：直接传递参数的副本。
引用传递：使用 std::ref() 传递对象的引用，避免复制。
结构体或类对象：将多个参数封装到一个结构体中进行传递。
多个参数传递：在创建线程时可以直接传递多个参数。

这种灵活性使得在多线程编程中能够更好地管理数据和资源。根据具体的应用场景，可以选择合适的参数传递方式。

在C++中，除了使用常规的函数作为线程的入口点外，我们还可以使用 lambda表达式和类的成员函数。这两种方式可以使代码更加灵活和简洁。下面将提供示例代码，展示如何使用这两种形式创建线程并传递参数。

1. 使用Lambda表达式

Lambda 表达式可以直接在创建线程时定义，非常适合进行简短的任务。在 lambda 中，可以捕获外部变量并将其用于线程中。

示例代码：使用Lambda表达式

cpp 复制代码

#include <iostream>
#include <thread>

int main() {
    int value = 42;

    // 创建线程时使用 lambda 表达式
    std::thread t([value]() {
        std::cout << "Thread is running, received value: " << value << std::endl;
    });

    t.join(); // 等待线程完成
    return 0;
}

2. 使用类的成员函数

如果你有一个对象，并希望使用该对象的成员函数作为线程的入口，可以使用 std::thread 的构造函数将对象的成员函数与对象本身一同传递。必须确保对象在调用之前保持有效。

示例代码：使用类的成员函数

cpp 复制代码

#include <iostream>
#include <thread>

class MyClass {
public:
    void member_function(int value) {
        std::cout << "Thread running from member function, received value: " << value << std::endl;
    }
};

int main() {
    MyClass obj;
    int value = 100;

    // 创建线程并传递成员函数和对象
    std::thread t(&MyClass::member_function, &obj, value);

    t.join(); // 等待线程完成
    return 0;
}

3. Lambda表达式与复杂参数

Lambda 表达式还可以接受多个参数，并且可以捕获外部变量，例如引用或指针。下面的示例展示了如何捕获引用。

示例代码：Lambda表达式捕获引用

cpp 复制代码

#include <iostream>
#include <thread>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3};

    // 使用 lambda 表达式修改 vector
    std::thread t([&vec]() {
        vec.push_back(4);
        std::cout << "Thread modified vector." << std::endl;
    });

    t.join(); // 等待线程完成

    std::cout << "Vector size after thread: " << vec.size() << std::endl; // 输出：4
    return 0;
}

**4.**成员函数与多个参数

可以通过类的成员函数传递多个参数。在实例化 std::thread 时，将这些参数传递给成员函数。

示例代码：成员函数与多个参数

cpp 复制代码

#include <iostream>
#include <thread>

class MyClass {
public:
    void member_function(int a, double b) {
        std::cout << "Thread from member function, received int: " << a
                  << " and double: " << b << std::endl;
    }
};

int main() {
    MyClass obj;

    // 创建线程并传递成员函数及参数
    std::thread t(&MyClass::member_function, &obj, 42, 3.14);

    t.join(); // 等待线程完成
    return 0;
}

总结

通过以上示例，我们展示了如何使用 lambda表达式和类的成员函数在C++中创建线程并传递参数。

Lambda表达式：能够快速定义匿名函数，并且能够捕获外部变量。适合简单的任务。
类的成员函数：能在对象的上下文中执行功能，可以通过传递对象的指针来调用它们。适用于需要利用对象状态的情况。

这些方式可以使得多线程编程更灵活、更易读，开发者可以根据具体需求选择合适的方式。