passing reference to thread c++

To pass a reference to a thread in C++, you can follow these steps:

Declare a function or a lambda expression that represents the task you want the thread to perform. This function or lambda should take a reference to the object you want to pass and any other necessary arguments.
Create an instance of std::thread and pass the function or lambda as the first parameter. This will create a new thread that will execute the specified task.
To pass the reference to the object, you can use std::ref or std::cref depending on whether you want the thread to have read/write or read-only access to the object. std::ref and std::cref are helper functions that wrap the reference and provide a reference-like object that can be copied.
If necessary, you can also pass additional arguments to the function or lambda by specifying them after the function or lambda parameter.
Join the thread or detach it. If you join the thread, the program will wait for the thread to finish execution before continuing. If you detach the thread, it will continue running independently.
Make sure to handle any exceptions that may be thrown by the thread or the function/lambda. You can use a try-catch block to catch any exceptions and handle them appropriately.

Here's an example that demonstrates passing a reference to a thread in C++:

#include <iostream>
#include <thread>

void task(int& value) {
    // Modify the value passed by reference
    value *= 2;
}

int main() {
    int num = 10;

    // Create a thread and pass the reference to 'num'
    std::thread t(task, std::ref(num));

    // Wait for the thread to finish
    t.join();

    // 'num' has been modified by the thread
    std::cout << "Modified value: " << num << std::endl;

    return 0;
}

In this example, the task function takes a reference to an integer and multiplies it by 2. The std::ref function is used to pass a reference to the num variable to the thread. After joining the thread, the modified value of num is printed to the console.

Note: It's important to ensure that the referenced object is still valid when the thread is executing. If the referenced object goes out of scope or is destroyed before the thread finishes, it can lead to undefined behavior.