Safely Passing C-Strings Between Threads

Passing C-style strings between threads safely requires careful consideration due to the nature of shared memory and potential race conditions. Here are some approaches you can use:

Use const Strings

If the string doesn't need to be modified, pass it as a const char*. This ensures that the string won't be accidentally modified by any thread:

1#include <iostream>
2#include <thread>
3
4void printString(const char* str) {
5  std::cout << "Thread received: " << str << '\n';
6}
7
8int main() {
9  const char* message{"Hello, World!"};
10  std::thread t{printString, message};
11  t.join();
12}

1Thread received: Hello, World!

Make a Deep Copy

If you need to modify the string, create a deep copy for each thread:

1#include <iostream>
2#include <thread>
3#include <cstring>
4
5void modifyString(char* str) {
6  strcat_s(str, 100, " Modified");
7  std::cout << "Thread modified: " << str << '\n';
8}
9
10int main() {
11  const char* original{"Hello, World!"};
12  char copy[100];
13  strcpy_s(copy, original);
14
15  std::thread t{modifyString, copy};
16  t.join();
17
18  std::cout << "Original unchanged: " << original;
19}

1Thread modified: Hello, World! Modified
2Original unchanged: Hello, World!

Use Synchronization Primitives

If multiple threads need to access the same string, use synchronization primitives like mutexes:

1#include <iostream>
2#include <thread>
3#include <mutex>
4#include <cstring>
5
6class SharedString {
7  char data[100];
8  std::mutex mtx;
9
10 public:
11  SharedString(const char* initial) {
12    strcpy_s(data, sizeof(data), initial);
13  }
14
15  void append(const char* str) {
16    std::lock_guard<std::mutex> lock{mtx};
17    strcat_s(data, sizeof(data), str);
18  }
19
20  void print() {
21    std::lock_guard<std::mutex> lock{mtx};
22    std::cout << data << '\n';
23  }
24};
25
26int main() {
27  SharedString shared{"Hello"};
28
29  std::thread t1{[&shared] {
30    shared.append(", World");
31  }};
32
33  // Ensure t1 completes before starting t2
34  t1.join();
35
36  std::thread t2{[&shared] {
37    shared.append("!");
38  }};
39
40  t2.join();
41
42  shared.print();
43}

1Hello, World!

Remember, when working with multithreaded applications, it's often safer and easier to use std::string instead of C-style strings. std::string provides thread-safe read operations and can be used with synchronization primitives for write operations.