C++ 在C++；

就我所见，可以使用指向结构的指针。但我想知道，有没有比这更有效、更优雅的方法呢？至少在使用结构时，不容易看到函数使用的参数是什么

---

感谢您提供有见地的答案。

这里有一个使用WIN32 API的小示例：

#include <windows.h>
#include <stdio.h>

struct PARAMS
{
    int i;
    char* msg;
};

DWORD WINAPI myThread(void* parameter)
{
    PARAMS* params = (PARAMS*)parameter;
    printf("Received parameters: i = %d, msg = '%s'\n", params->i, params->msg);
    return 0;
}

int main(int argc, char* argv[])
{
    char msg[] = "Hi there.";
    PARAMS params;
    params.i = 1;
    params.msg = msg;

    HANDLE threadHandle = CreateThread(NULL, 0, myThread, &params, 0, NULL);
    WaitForSingleObject(threadHandle, INFINITE);

    return 0;
}

#包括
#包括
结构参数
{
int i；
char*msg；
};
DWORD WINAPI myThread（void*参数）
{
PARAMS*PARAMS=（PARAMS*）参数；
printf（“收到的参数：i=%d，msg='%s'\n'，params->i，params->msg”）；
返回0；
}
int main（int argc，char*argv[]）
{
char msg[]=“你好。”；
PARAMS PARAMS；
参数i=1；
params.msg=msg；
HANDLE-threadHandle=CreateThread（NULL，0，myThread，¶ms，0，NULL）；
WaitForSingleObject（线程句柄，无限）；
返回0；
}

您会说，“很难看到函数使用的参数是什么”。这要看情况而定。如果你认为它不够“优雅”，你至少应该留下一些有用的评论。如果您正在使用良好的命名并尝试编写代码，即自文档，那么使用结构就可以了

下面是一个包装CreateThread的示例，这样使用您的代码的程序员就不必知道您正在使用某种结构：

#include <windows.h>
#include <stdio.h>

class MyWrapper
{
private:
    struct PARAMS
    {
        int i;
        char* msg;
    };

    static DWORD WINAPI myThread(void* parameter)
    {
        PARAMS* params = (PARAMS*)parameter;
        printf("Received parameters: i = %d, msg = '%s'\n", params->i, params->msg);
        delete params;
        return 0;
    }

public:
    HANDLE createThread(int i, char* msg)
    {
        PARAMS* params = new PARAMS;
        params->i = i;
        params->msg = msg;

        return CreateThread(NULL, 0, MyWrapper::myThread, params, 0, NULL);
    }
};

int main(int argc, char* argv[])
{
    MyWrapper mw;
    char msg[] = "Hi there.";

    HANDLE threadHandle = mw.createThread(1, msg);
    WaitForSingleObject(threadHandle, INFINITE);

    return 0;
}

#包括
#包括
类MyWrapper
{
私人：
结构参数
{
int i；
char*msg；
};
静态DWORD WINAPI myThread（void*参数）
{
PARAMS*PARAMS=（PARAMS*）参数；
printf（“收到的参数：i=%d，msg='%s'\n'，params->i，params->msg”）；
删除参数；
返回0；
}
公众：
句柄createThread（inti，char*msg）
{
参数*参数=新参数；
参数->i=i；
参数->味精=味精；
返回CreateThread（NULL，0，MyWrapper:：myThread，params，0，NULL）；
}
};
int main（int argc，char*argv[]）
{
mw；
char msg[]=“你好。”；
HANDLE threadHandle=mw.createThread（1，msg）；
WaitForSingleObject（线程句柄，无限）；
返回0；
}

下面是一个使用WIN32 API的小示例：

#include <windows.h>
#include <stdio.h>

struct PARAMS
{
    int i;
    char* msg;
};

DWORD WINAPI myThread(void* parameter)
{
    PARAMS* params = (PARAMS*)parameter;
    printf("Received parameters: i = %d, msg = '%s'\n", params->i, params->msg);
    return 0;
}

int main(int argc, char* argv[])
{
    char msg[] = "Hi there.";
    PARAMS params;
    params.i = 1;
    params.msg = msg;

    HANDLE threadHandle = CreateThread(NULL, 0, myThread, &params, 0, NULL);
    WaitForSingleObject(threadHandle, INFINITE);

    return 0;
}

#包括
#包括
结构参数
{
int i；
char*msg；
};
DWORD WINAPI myThread（void*参数）
{
PARAMS*PARAMS=（PARAMS*）参数；
printf（“收到的参数：i=%d，msg='%s'\n'，params->i，params->msg”）；
返回0；
}
int main（int argc，char*argv[]）
{
char msg[]=“你好。”；
PARAMS PARAMS；
参数i=1；
params.msg=msg；
HANDLE-threadHandle=CreateThread（NULL，0，myThread，¶ms，0，NULL）；
WaitForSingleObject（线程句柄，无限）；
返回0；
}

您会说，“很难看到函数使用的参数是什么”。这要看情况而定。如果你认为它不够“优雅”，你至少应该留下一些有用的评论。如果您正在使用良好的命名并尝试编写代码，即自文档，那么使用结构就可以了

下面是一个包装CreateThread的示例，这样使用您的代码的程序员就不必知道您正在使用某种结构：

#include <windows.h>
#include <stdio.h>

class MyWrapper
{
private:
    struct PARAMS
    {
        int i;
        char* msg;
    };

    static DWORD WINAPI myThread(void* parameter)
    {
        PARAMS* params = (PARAMS*)parameter;
        printf("Received parameters: i = %d, msg = '%s'\n", params->i, params->msg);
        delete params;
        return 0;
    }

public:
    HANDLE createThread(int i, char* msg)
    {
        PARAMS* params = new PARAMS;
        params->i = i;
        params->msg = msg;

        return CreateThread(NULL, 0, MyWrapper::myThread, params, 0, NULL);
    }
};

int main(int argc, char* argv[])
{
    MyWrapper mw;
    char msg[] = "Hi there.";

    HANDLE threadHandle = mw.createThread(1, msg);
    WaitForSingleObject(threadHandle, INFINITE);

    return 0;
}

#包括
#包括
类MyWrapper
{
私人：
结构参数
{
int i；
char*msg；
};
静态DWORD WINAPI myThread（void*参数）
{
PARAMS*PARAMS=（PARAMS*）参数；
printf（“收到的参数：i=%d，msg='%s'\n'，params->i，params->msg”）；
删除参数；
返回0；
}
公众：
句柄createThread（inti，char*msg）
{
参数*参数=新参数；
参数->i=i；
参数->味精=味精；
返回CreateThread（NULL，0，MyWrapper:：myThread，params，0，NULL）；
}
};
int main（int argc，char*argv[]）
{
mw；
char msg[]=“你好。”；
HANDLE threadHandle=mw.createThread（1，msg）；
WaitForSingleObject（线程句柄，无限）；
返回0；
}

如果要在Win32 API中向线程函数传递单个参数，这里有一个小示例

#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>

DWORD WINAPI funHello(void *x)
{
    int c = (int*)x;
    printf("\n Thread No: %d\n",c);
    // Do some work , call some function, etc.
    return 0;
}

int main()
{
    HANDLE  myhandle;
    DWORD threadId;
    int c = 1;
    myhandle = CreateThread(NULL, 0, funHello, (void *)c, 0, &threadId);
    if (myhandle == NULL)
    {
        printf("Create Thread Failed. Error no: %d\n", GetLastError);
    }
    WaitForSingleObject(myhandle, INFINITE);
    printf("\n Main Hello...\n");
    CloseHandle(myhandle);
    return 0;
}

#包括
#包括
#包括
DWORD WINAPI funHello（void*x）
{
int c=（int*）x；
printf（“\n线程号：%d\n”，c）；
//做一些工作，调用一些函数，等等。
返回0；
}
int main（）
{
把手我的把手；
德沃德·特莱德；
int c=1；
myhandle=CreateThread（NULL，0，funhhello，（void*）c，0，&threadId）；
if（myhandle==NULL）
{
printf（“创建线程失败。错误号：%d\n”，GetLastError）；
}
WaitForSingleObject（myhandle，无限）；
printf（“\n Main Hello…\n”）；
关闭手柄（myhandle）；
返回0；
}

如果要在Win32 API中向线程函数传递单个参数，这里有一个小示例

#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>

DWORD WINAPI funHello(void *x)
{
    int c = (int*)x;
    printf("\n Thread No: %d\n",c);
    // Do some work , call some function, etc.
    return 0;
}

int main()
{
    HANDLE  myhandle;
    DWORD threadId;
    int c = 1;
    myhandle = CreateThread(NULL, 0, funHello, (void *)c, 0, &threadId);
    if (myhandle == NULL)
    {
        printf("Create Thread Failed. Error no: %d\n", GetLastError);
    }
    WaitForSingleObject(myhandle, INFINITE);
    printf("\n Main Hello...\n");
    CloseHandle(myhandle);
    return 0;
}

#包括
#包括
#包括
DWORD WINAPI funHello（void*x）
{
int c=（int*）x；
printf（“\n线程号：%d\n”，c）；
//做一些工作，调用一些函数，等等。
返回0；
}
int main（）
{
把手我的把手；
德沃德·特莱德；
int c=1；
myhandle=CreateThread（NULL，0，funhhello，（void*）c，0，&threadId）；
if（myhandle==NULL）
{
printf（“创建线程失败。错误号：%d\n”，GetLastError）；
}
WaitForSingleObject（myhandle，无限）；
printf（“\n Main Hello…\n”）；
关闭手柄（myhandle）；
返回0；
}

您能详细说明一下吗？“将参数传递给另一个线程中的函数”是什么意思？您想做什么？函数定义不在某个线程上，它可以在任何线程上运行；出现线程问题的一个原因是，如果它正在修改一个线程上的数据，而另一个线程也在修改该数据。您可以访问另一个线程正在接触的数据结构，但您必须知道正确访问和修改它所需的确切安全防护措施；最好将功能包装在一个函数中，这样您就不必记住正确的密码