C / C++ / MFC

Oh, I don't know why she's
leaving, or where she's gonna go
I guess she's got her reasons but I just don't wanna know
'Cos for 24 years I've been living next door to Alice
24 years just waitin' for a chance
To tell her how I feel and maybe get a second glance
Now I gotta get used to not living next door to Alice

HICON hSmallIcon = ::LoadImage ( AfxGetResourceInstance(), MAKEINTRESOURCE(IDI_NEW_ICON), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR );

HICON hSmallIcon = (HICON) ::LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ICON), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);

Oh, I don't know why she's
leaving, or where she's gonna go
I guess she's got her reasons but I just don't wanna know
'Cos for 24 years I've been living next door to Alice
24 years just waitin' for a chance
To tell her how I feel and maybe get a second glance
Now I gotta get used to not living next door to Alice

DWORD WaitForSingleObject(
  HANDLE hHandle,        // handle to object
  DWORD dwMilliseconds   // time-out interval
);

• Change notification


• Console input


• Event


• Job


• Mutex


• Process


• Semaphore


• Thread


• Waitable timer

BOOL function(int x, int y, float power);

typedef struct FUNCTION_PARAMS
{
  int x;
  int y;
  float power;
}; FUNCTION_PARAMS;

DWORD WINAPI WorkerThreadProc(LPVOID lpParameter)
{
  //Check the input parameters.
  if (!lpParameter)
  {
  //The input parameter was not valid.
    return FALSE;
  }
  //Cast the input parameter to the type that we are interested in to make the programming easier.
  FUNCTION_PARAMS *fp = (FUNCTION_PARAMS*)lpParameter;

  //Use your function however you would like.
  float z = fp.x + f.y * fp.power;
  ...

  //When you are done, return the value that you want, TRUE or FALSE in this case.
  return TRUE;
}

//In the example that I have created there are input parameters to the thread proc, initialize that structure here.
FUNCTION_PARAMS fp;
fp.x = 1;
fp.y = 2;
fp.power = 100.0;

//Create a worker thread.  You will call the worker thread function that you created 
//and initialize the function with the address of your parameters struct.
HANDLE hWorkerThread;
DWORD  dwThreadID;

hWorkerThread = ::CreateThread(NULL, 0, WorkerThreadProc, &fp, &dwThreadID);

//Reset the worker thread handle to a non-signaled state with this function.
::ResetEvent(hThread);

//Wait for the worker thread to finish, or 5 seconds, which ever comes first.
DWORD dwState;
dwState = ::WaitForSingleObject(hWorkerThread, 5000);

//Check the return value to see what happened.
if (WAIT_OBJECT_0 == dwState)
{
  //The thread finished, get the return value from the thread proc.
  DWORD dwExitCode;

  GetExitCodeThread(hWorkerThread, &dwExitCode);
  //Perform what ever action you want with the TRUE / FALSE return value.
  if (TRUE == dwExitCode)
  {
    ...
  }
  else
  {
    ...
  }
}
else
if (WAIT_TIMEOUT == dwState)
{
//The thread has not yet finished, take what ever action you want.
//Do you want to make sure that the worker thread terminated?
...
}

LARGE_INTEGER liFrequency;
LARGE_INTEGER liStart;
LARGE_INTEGER liEnd;

// Get the frequency resolution of your timer.
if (FALSE == QueryPerformanceFrequency (&liFrequency))
{
	MessageBox("Your computer will not support this test.  It does not contain a high resolution timer.", "Error", MB_OK | MB_ICONEXCLAMATION);
	return FALSE;
}

// Get the start reference point
QueryPerformanceCounter(&liStart)

// Perform your code opertions, or the user pauses or whatever ...
...

// Get the current or end reference point
QueryPerformanceCounter(&liEnd)

// Calculate the length in time between the two points.
LARGE_INTEGER liDiff;

double dTime;

liDiff.LowPart = liEnd.LowPart - liStart.LowPart;
// most likely you will only need to worry about the lowpart.
liDiff.HighPart = liEnd.HighPart - liStart.HighPart;

// Scale down the clock ticks to units of time.
dTime = (double)liDiff.LowPart / (double)liFrequency.LowPart;