C 线程采用插座参数

要在线程中运行的代码需要在您传递给CreateThread()的Sender()函数内。因此，这将是您的所有插座调用（WSAStartup()和WSACleanup()除外，只能称呼一次）。

类似的东西：

DWORD WINAPI Sender( LPVOID lpParam)
{ 
    // Make sure there is a console to receive output results. 
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    if( hStdout == INVALID_HANDLE_VALUE )
        return 1;
    HOSTENT* Host = gethostbyname("smtp.com");
    if (!Host)
    {
        cout << "Unable to resolve smtp.com" << endl;
        return 1;
    }
    //Creates the socket object named "soc(Connection"
    SOCKET socConnection = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socConnection == INVALID_SOCKET)
    {
        cout << "Socket Failed" << endl;
        return 1;
    }
    SOCKADDR_IN Addr = {0};
    Addr.sin_family = AF_INET;
    Addr.sin_addr = * (in_addr*) Host->h_addr_list[0];
    Addr.sin_port = htons(25);
    if (connect(socConnection, (SOCKADDR*)&Addr, sizeof(Addr)) == SOCKET_ERROR)
    {
        cout << "Connection Failed" << endl;
        closesocket(socConnection);
        return 1;
    }
    ...
    closesocket(socConnection);
    return 0; 
} 
int main()
{
    WSADATA wsaData; // Creates wsaData object
    WSAStartup(MAKEWORD(2, 2), &wsaData); //Initializes Winsock
    DWORD dwThreadId;
    HANDLE hThread = CreateThread( 
        NULL,                   // default security attributes
        0,                      // use default stack size  
        &Sender,                // thread function name
        NULL,                   // argument to thread function 
        0,                      // use default creation flags 
        &dwThreadId);
    ...
    WaitForSingleObject(hThread, INFINITE);
    DWORD ExitCode = 0;
    GetExitCodeThread(hThread, &ExitCode);
    CloseHandle(hThread);
    if (ExitCode != 0)
    {
        ...
    }
    ...
    WSACleanup();
    return 0;
}

，以及如何将线程封装到类中，以获取真正面向对象的和更可重复使用的代码：

#include <windows.h>
#include <stdio.h>
#include <assert.h>
class CThread
{
public:
    void Start()
    {
        assert(!m_Handle);
        DWORD thread_id;
        m_Handle = ::CreateThread(NULL, 0, StaticThreadProc, this, 0, &thread_id);
        // this should be a fatal error/exit instead of a simple assert...
        assert(m_Handle);
    }
    void Join()
    {
        assert(m_Handle);
        ::WaitForSingleObject(m_Handle, INFINITE);
    }
protected:
    virtual void Execute() = 0;
    CThread() : m_Handle(NULL) {}
    ~CThread()
    {
        if (m_Handle)
        {
            Join();
            ::CloseHandle(m_Handle);
            m_Handle = NULL;
        }
    }
private:
    static DWORD WINAPI StaticThreadProc(LPVOID param)
    {
        CThread* thread = reinterpret_cast<CThread*>(param);
        thread->Execute();
        return 0;
    }
private:
    HANDLE m_Handle;
};
class CMyThread : public CThread
{
public:
    CMyThread()
    {
        m_Sock = NULL;
        m_Whatever = 0;
        m_OtherParam = 0;
        m_Result = 0;
    }
    // Use this to initialize the parameters for your thread before starting it...
    // You could initialize from your constructor too if you wouldn't store your
    // threads in an array by value...
    void Init(SOCKET sock, int whatever_parameter_you_need, int other_param)
    {
        m_Sock = sock;
        m_Whatever = whatever_parameter_you_need;
        m_OtherParam = other_param;
    }
    int GetResult() const
    {
        return m_Result;
    }
protected:
    virtual void Execute() override
    {
        // Use m_Sock, m_Whatever, m_OtherParam ....
        // Fill out m_Result before returning from the Execute() method of the thread.
        // You can also create the socket inside the thread if you want,
        // noone forces you to pass it here as an init parameter.
        m_Result = 5;
    }
private:
    SOCKET m_Sock;
    int m_Whatever;
    int m_OtherParam;
    int m_Result;
};

int main()
{
    // TODO: network init (WSAStartup)
    const int NUM_THREADS = 3;
    CMyThread threads[NUM_THREADS];
    // 1. Initializing threads with incoming parameters to work with
    for (int i=0; i<NUM_THREADS; ++i)
    {
        //threads[i].Init(...)
    }
    // 2. Starting threads
    for (int i=0; i<NUM_THREADS; ++i)
        threads[i].Start();
    // 3. Waiting for threads to finish...
    for (int i=0; i<NUM_THREADS; ++i)
        threads[i].Join();
    // 4. Processing results if needed
    int result0 = threads[0].GetResult();
    printf("%dn", result0);
    // TODO: Network Cleanup (WSACleanup)
    return 0;
}