spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

    MSG msg;
    while(GetMessage (&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

C-/C++-Quelltext

while(bedingung)
{
    // ...

}

C-/C++-Quelltext

// klassenmember

WinsockServer *pWinsockServer;

// -------------------------------------------------------------------

// Name:    frmServer_ServerThreadProc()

// Desc:    Thread procedure for the winsock server.

// -------------------------------------------------------------------

DWORD WINAPI frmServer::frmServer_ServerThreadProc (LPVOID lpPAram)
{
    int i = GetCurrentThreadId();

    
    while(1)
    {
        pWinsockServer->process();
    }
    

    return i;
} // frmServer_ServerThreadProc()

C-/C++-Quelltext

// -------------------------------------------------------------------

// Name:    Create()

// Desc:    Creates a new thread.

// -------------------------------------------------------------------

template<typename T>
int Thread::Create(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, T* instance, LPVOID lpParameter, DWORD dwCreationFlags)
{
        // define function pointer

    DWORD (WINAPI *ThreadProc) (LPVOID) = &instance->frmServer_ThreadProc;

    if((m_hThreadHandle = CreateThread(lpThreadAttributes, dwStackSize, ThreadProc, lpParameter, dwCreationFlags, &m_dwThreadID)) == NULL)
        return THREAD_CREATING_ERROR;

    return THREAD_OK;
} // Create()



// functor: (einfach irgendwas)


template<typename T>
void functor(T object)
{
    object->process();
} 



// aufruf


Thread.Create(a, b, instanz, functor, e);

C-/C++-Quelltext

#include <windows.h>
#include <tchar.h>
#include <strsafe.h>

#define MAX_THREADS 3
#define BUF_SIZE 255

typedef struct MyData {
    int val1;
    int val2;
} MYDATA, *PMYDATA;

DWORD WINAPI MyThread( LPVOID lpParam ) 
{ 
    HANDLE hStdout;
    PMYDATA pData;

    TCHAR msgBuf[BUF_SIZE];
    size_t cchStringSize;
    DWORD dwChars;

    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    if( hStdout == INVALID_HANDLE_VALUE )
        return 1;

    // Cast the parameter to the correct data type.


    pData = (PMYDATA)lpParam;

    // Print the parameter values using thread-safe functions.


    StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"), 
        pData->val1, pData->val2); 
    StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);
    WriteConsole(hStdout, msgBuf, cchStringSize, &dwChars, NULL);

    return 0; 
} 
 
int _tmain()
{
    PMYDATA pData;
    DWORD dwThreadId[MAX_THREADS];
    HANDLE hThread[MAX_THREADS]; 
    int i;

    // Create MAX_THREADS worker threads.


    for( i=0; i<MAX_THREADS; i++ )
    {
        // Allocate memory for thread data.


        pData = (PMYDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                sizeof(MYDATA));

        if( pData == NULL )
            ExitProcess(2);

        // Generate unique data for each thread.


        pData->val1 = i;
        pData->val2 = i+100;

        hThread[i] = CreateThread( 
            NULL,              // default security attributes

            0,                 // use default stack size  

            MyThread,          // thread function 

            pData,             // argument to thread function 

            0,                 // use default creation flags 

            &dwThreadId[i]);   // returns the thread identifier 



        // Check the return value for success.

        // If failure, close existing thread handles, 

        // free memory allocation, and exit. 


        if (hThread[i] == NULL) 
        {
           for(i=0; i<MAX_THREADS; i++)
           {
              if (hThread[i] != NULL)
              {
                 CloseHandle(hThread[i]);
              }
           }
           HeapFree(GetProcessHeap(), 0, pData);
           ExitProcess(i);
         }
    }

    // Wait until all threads have terminated.


    WaitForMultipleObjects(MAX_THREADS, hThread, TRUE, INFINITE);

    // Close all thread handles and free memory allocation.


    for(i=0; i<MAX_THREADS; i++)
    {
        CloseHandle(hThread[i]);
    }
    HeapFree(GetProcessHeap(), 0, pData);

    return 0;
}