А можно ли дождаться выполнения CreateThread ?

HANDLE CreateThread(
LPSECURITY_ATTRIBUTES   lpThreadAttributes,
SIZE_T                  dwStackSize,
LPTHREAD_START_ROUTINE  lpStartAddress,
__drv_aliasesMem LPVOID lpParameter,
DWORD                   dwCreationFlags,
LPDWORD                 lpThreadId);

void my_function1(int &i)
{
    i++;
}
 
int main()
{
 
    int i = 1;
    int y = 3;
 
    HANDLE handle_thread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE) my_function1, (LPVOID)(&i), NULL, NULL);
 
    cout << handle_thread << endl;
 
    cout << i << endl;
}

WINBASEAPI
_Ret_maybenull_
HANDLE
WINAPI
CreateThread(
    _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
    _In_ SIZE_T dwStackSize,
    _In_ LPTHREAD_START_ROUTINE lpStartAddress,
    _In_opt_ __drv_aliasesMem LPVOID lpParameter,
    _In_ DWORD dwCreationFlags,
    _Out_opt_ LPDWORD lpThreadId
    );

DWORD WINAPI my_function4(LPVOID Param2)
{
    cout <<"Структура:"<< ((string*)Param2)[0] << endl;    // но тут ошибки ведь нет 
    cout << "Структура:" << ((int*)Param2)[1] << endl;    // но тут ошибка, выражение должно иметь тип указателя на объект
 
    return 0;
}
 
 
int main()
{
 
    setlocale(LC_ALL, "Russian");
  
    string i = "1";
    int y = 3;
 
    struct my_struct
    {
        string f1;
        int f2;
    };
 
 
    my_struct Structura;
    Structurka.i = i;
    Structurka.f2 = y;
    
    HANDLE handle_thread2 = CreateThread(NULL, NULL, my_function4, (LPVOID)&Structura, NULL, NULL);
 
 
    WaitForSingleObject(handle_thread2, INFINITE);

template <typename TFunc>
unsigned ThreadProc(void *arg)
{
    std::unique_ptr<TFunc> sp(reinterpret_cast<TFunc *>(arg));
    (*sp)();
    return 0;
}
 
template <typename TFunc, typename... TT>
HANDLE create_thread(TFunc &&func, TT&&... args)
{
    auto fn = [func = std::move(func), ...args = std::move(args)]()
    {
        std::invoke(std::move(func), std::move(args)...);
    };
    using T = decltype(fn);
    std::unique_ptr<T> sp(new T(std::move(fn)));
    HANDLE h = (HANDLE)_beginthreadex(nullptr, 0, ThreadProc<T>, sp.get(), 0, nullptr);
    if (h)
        sp.release();
    return h;
}
 
int main()
{
        std::string s = __FUNCTION__;
        std::cout << s << std::endl;
        auto h = create_thread([&s]()
        {
            s = __FUNCTION__;
        });
 
        ::WaitForSingleObject(h, INFINITE);
        std::cout << s << std::endl;
        ::CloseHandle(h);
         return 0;
}

ULONG_PTR lParam(int arg1, char *arg2, ...)
   return SomeFunction(arg1, &arg2, ...);

CreateProcess(
   ...
   (LPTHREAD_START_ROUTINE)BaseAddr,
   (LPVOID)lParam(arg1, &arg2, ...),
   ...
);

typedef DWORD (WINAPI *PTHREAD_START_ROUTINE)(
    LPVOID lpThreadParameter
    );
typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE;

HANDLE evStop = ::CreateEvent(....);
HANDLE evDataReady = ::CreateEvent(....);
 
DWORD ThreadProc(void *arg)
{
    HANDLE events[] = {evStop, evDataReady, };
    for (;;)
    {
        const auto wait = ::WaitForMultipleObjects(std::size(events), events, FALSE, INFINITE);
        if (wait == WAIT_OBJECT_0)
            break;
 
        if (wait == WAIT_OBJECT_0 + 1)
            ProcessData();
    }
        retrurn 0;
}