Как передать данные из одного потока в другой?

void read() {
    std::ifstream stream("C:\\Users\\..  ..txt");
    //  тело ф-ции
 
        while (!stream.eof()) {
            //тело цикла
            }
 
        }
        
void obrabotka() {
    //тело функции
 
}
 
int main() {
 
    thread func_read(readFile);
thread func_obr(obrabotka);
 
    func_read.join();
 
    cout << endl;
    system("pause");
 
    
    return 0;
 
}

std::mutex mtx;
std::condition_variable cv;
std::queue<std::string> buf;
 
void read()
{
  // ...
  std::unique_lock<std::mutex> lck(mtx);
  buf.push("hello");
  cv.notify_one();
  //...
}
 
void process()
{
  while (true)
  {
    std::string data;
    {
      std::unique_lock<std::mutex> lck(mtx);
      while (buf.empty())
      {
        cv.wait(lck);
      }
 
      data = buf.top();
      buf.pop();
    }
 
    // process data
  }
}

#include "stdafx.h"
#include <stdlib.h>
#include <locale.h>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>
 
#define TEXT_MAX_SIZE       1024
#define READ_THREAD_ID      1
#define TRANSFORM_THREAD_ID 2
#define WRITE_THREAD_ID     3
#define INVALID_THREAD_ID  -1
 
int g_iActiveThread = 0;
char g_chText[TEXT_MAX_SIZE];
std::mutex g_mutex;
std::condition_variable g_variable;
 
void ThreadRead();
void ThreadTransform();
void ThreadWrite();
 
bool GrantAccess(int iThreadID);
void DelegateAccess(int iThreadID);
 
int main()
{
    std::thread t1 = std::thread(ThreadWrite);
    std::thread t2 = std::thread(ThreadTransform);
    std::thread t3 = std::thread(ThreadRead);
 
    DelegateAccess(READ_THREAD_ID);
 
    t1.join();
    t2.join();
    t3.join();
 
    getchar();
 
    return 0;
}
 
void ThreadRead()
{
    char* pLines[] =
    {
        "Мороз и солнце; день чудесный!",
        "Еще ты дремлешь, друг прелестный -",
        "Пора, красавица, проснись:",
        "Открой сомкнуты негой взоры",
        "Навстречу северной Авроры,",
        "Звездою севера явись!"
    };
 
    size_t uLine = 0;
 
    while (GrantAccess(READ_THREAD_ID))
    {
        size_t uLineCount = sizeof(pLines)/sizeof(pLines[0]);
 
        if (uLine < uLineCount)
        {
            strcpy(g_chText, pLines[uLine++]);
 
            DelegateAccess(TRANSFORM_THREAD_ID);
        }
        else
        {
            DelegateAccess(INVALID_THREAD_ID);
        }
    }
}
 
void ThreadTransform()
{
    while (GrantAccess(TRANSFORM_THREAD_ID))
    {
        size_t uLineSize = strlen(g_chText);
        for (size_t i = 0; i < uLineSize / 2; i++)
        {
            char temp = g_chText[uLineSize - i - 1];
            g_chText[uLineSize - i - 1] = g_chText[i];
            g_chText[i] = temp;
        }
 
        DelegateAccess(WRITE_THREAD_ID);
    }
}
 
void ThreadWrite()
{
    setlocale(LC_ALL, "RU");
 
    while (GrantAccess(WRITE_THREAD_ID))
    {
        printf("%s\r\n", g_chText);
 
        DelegateAccess(READ_THREAD_ID);
    }
}
 
bool GrantAccess(int iThreadID)
{
    std::unique_lock<std::mutex> _lck(g_mutex);
 
    while (g_iActiveThread != INVALID_THREAD_ID)
    {
        if (g_iActiveThread == iThreadID)
            return true;
 
        g_variable.wait(_lck);
    }
 
    return false;
}
 
void DelegateAccess(int iThreadID)
{
    std::unique_lock<std::mutex> _lck(g_mutex);
    
    g_iActiveThread = iThreadID;
    g_variable.notify_all();
}
 
// вариант синхронизации без использования специальных объеков
//bool GrantAccess(int iThreadID)
//{
//    while (g_iActiveThread != INVALID_THREAD_ID)
//    {
//        if (g_iActiveThread == iThreadID)
//            return true;
//
//        std::this_thread::sleep_for(std::chrono::milliseconds(1));
//    }
//
//    return false;
//}
//
//void DelegateAccess(int iThreadID)
//{
//    g_iActiveThread = iThreadID;
//}