HANDLE g_hEvent;



UINT THREADFUNC(...)

{

  ...



  while (1)

  {

    if (WaitForSingleObject(g_hEvent, 0) == WAIT_OBJECT_0)

      break;

    ...

  }



  return 0;

}

// crt_BEGTHRD.C

// compile with: /MT /D "_X86_" /c

#include <windows.h>

#include <process.h>    /* _beginthread, _endthread */

#include <stddef.h>

#include <stdlib.h>

#include <conio.h>



void Bounce( void *ch );

void CheckKey( void *dummy );



/* GetRandom returns a random integer between min and max. */

#define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))



BOOL repeat = TRUE;     /* Global repeat flag and video variable */

HANDLE hStdOut;         /* Handle for console window */

CONSOLE_SCREEN_BUFFER_INFO csbi;    /* Console information structure */



int main()

{

    CHAR    ch = 'A';



    hStdOut = GetStdHandle( STD_OUTPUT_HANDLE );



    /* Get display screen's text row and column information. */

   GetConsoleScreenBufferInfo( hStdOut, &csbi );



    /* Launch CheckKey thread to check for terminating keystroke. */

    _beginthread( CheckKey, 0, NULL );



    /* Loop until CheckKey terminates program. */

    while( repeat )

    {

        /* On first loops, launch character threads. */

        _beginthread( Bounce, 0, (void *) (ch++)  );



        /* Wait one second between loops. */

        Sleep( 1000L );

    }

}



/* CheckKey - Thread to wait for a keystroke, then clear repeat flag. */

void CheckKey( void *dummy )

{

    _getch();

    repeat = 0;    /* _endthread implied */



}



/* Bounce - Thread to create and and control a colored letter that moves

 * around on the screen.

 *

 * Params: ch - the letter to be moved

 */

void Bounce( void *ch )

{

    /* Generate letter and color attribute from thread argument. */

    char    blankcell = 0x20;

    char    blockcell = (char) ch;

    BOOL    first = TRUE;

   COORD   oldcoord, newcoord;

   DWORD   result;





    /* Seed random number generator and get initial location. */

    srand( _threadid );

    newcoord.X = GetRandom( 0, csbi.dwSize.X - 1 );

    newcoord.Y = GetRandom( 0, csbi.dwSize.Y - 1 );

    while( repeat )

    {

        /* Pause between loops. */

        Sleep( 100L );



        /* Blank out our old position on the screen, and draw new letter. */

        if( first )

            first = FALSE;

        else

         WriteConsoleOutputCharacter( hStdOut, &blankcell, 1, oldcoord, &result );

         WriteConsoleOutputCharacter( hStdOut, &blockcell, 1, newcoord, &result );



        /* Increment the coordinate for next placement of the block. */

        oldcoord.X = newcoord.X;

        oldcoord.Y = newcoord.Y;

        newcoord.X += GetRandom( -1, 1 );

        newcoord.Y += GetRandom( -1, 1 );



        /* Correct placement (and beep) if about to go off the screen. */

        if( newcoord.X < 0 )

            newcoord.X = 1;

        else if( newcoord.X == csbi.dwSize.X )

            newcoord.X = csbi.dwSize.X - 2;

        else if( newcoord.Y < 0 )

            newcoord.Y = 1;

        else if( newcoord.Y == csbi.dwSize.Y )

            newcoord.Y = csbi.dwSize.Y - 2;



        /* If not at a screen border, continue, otherwise beep. */

        else

            continue;

        Beep( ((char) ch - 'A') * 100, 175 );

    }

    /* _endthread given to terminate */

    _endthread();

}

// crt_begthrdex.cpp

// compile with: /MT

#include <windows.h>

#include <stdio.h>

#include <process.h>



unsigned Counter; 

unsigned __stdcall SecondThreadFunc( void* pArguments )

{

    printf( "In second thread...\n" );



    while ( Counter < 1000000 )

        Counter++;



    _endthreadex( 0 );

    return 0;

} 



int main()

{ 

    HANDLE hThread;

    unsigned threadID;



    printf( "Creating second thread...\n" );



    // Create the second thread.

    hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc, NULL, 0, &threadID );



    // Wait until second thread terminates. If you comment out the line

    // below, Counter will not be correct because the thread has not

    // terminated, and Counter most likely has not been incremented to

    // 1000000 yet.

    WaitForSingleObject( hThread, INFINITE );

    printf( "Counter should be 1000000; it is-> %d\n", Counter );

    // Destroy the thread object.

    CloseHandle( hThread );

}

#include <Windows.h>

#include <process.h>

#include <iostream>

#include <list>

using namespace std;



class CMyClass

{

public:

	CMyClass()

	{

		cout<<"Default constructor"<<endl;

	}

	CMyClass(const CMyClass& obj)

	{

		cout<<"Copy constructor"<<endl;

	}

	~CMyClass()

	{

		cout<<"Destructor"<<endl;

	}

};

void ThreadFunc(LPVOID lParam)

{

	CMyClass myobj;

//	_endthread();

}

void main()

{

	_beginthread(ThreadFunc,0,NULL);

	char c;

	cin>>c;

}

#include <Windows.h>

#include <process.h>

#include <iostream>

#include <list>

using namespace std;



class CMyClass

{

public:

    CMyClass()

    {

        cout<<"Default constructor"<<endl;

    }

    CMyClass(const CMyClass& obj)

    {

        cout<<"Copy constructor"<<endl;

    }

    ~CMyClass()

    {

        cout<<"Destructor"<<endl;

    }

};

void ThreadFunc(LPVOID lParam)

{

    if(lParam==NULL)

    {

       return;

    }

    CMyClass myobj;

//    _endthread();

}

void main()

{

    _beginthread(ThreadFunc,0,NULL);

    char c;

    cin>>c;

}