C / C++ / MFC

<br />
CFile cFile;<br />
CString strFileContents;<br />
<br />
cFile.Open(m_strFileName, CFile::modeRead | CFile::shareExclusive);<br />
cFile.Read(&strFileContents, cFile.GetLength());<br />
cFile.Close();<br />

<code>template<class T>
class CSimpleArray
{
      T* m_aT;
      ...

	class Wrapper
	{
	public:
		Wrapper(T& _t) : t(_t)
		{
		}
		template <class _Ty>
		void *operator new(size_t, _Ty* p)
		{
			return p;
		}
		T t;
	};
	void SetAtIndex(int nIndex, T& t)
	{

		new(&m_aT[nIndex]) Wrapper(t);
	}
   ...
}</code>   

UINT CSerial::ReadPortThread(LPVOID lpvParam)
{
	CSerial *pSerial = (CSerial*)lpvParam;
        int bytesin;
	// Since we'll be waiting on multiple events, we'll use a handle
	// array, and create events for each element in the array. For now,
	// I'm only using "quit" and "rxchar" events.

	// Set up the threads loop events. i.e. events that will return
	// execution to the thread. Note that the CSerial Object houses the
	// event handles since it must assert the "quit thread" event (hReadEvents[0]
	pSerial->hReadEvents[0] = CreateEvent(NULL, true, false, NULL);
	
	// Create the rxchar event, and assign it to hReadEvents[1]
	pSerial->hReadEvents[1] = CreateEvent(NULL, true, true, NULL);
	
	// Set the hEvent element of the CSerial objects overlapped
	// structure equal to hReadEvents[1].
	pSerial->OverlappedRead.hEvent=pSerial->hReadEvents[1];

	// Set up the comm event mask to respond to received chars.
	// When we issue the WaitCommEvent, the receive comm port will assert the
	// OverlappedRead.hEvent event when it receives a char.
	SetCommMask(pSerial->m_hIDComDev,EV_RXCHAR);

	DWORD evt;

    DWORD dwHandleSignaled;
	SetLastError(0);  // debug
	while (true)
	{
		// Since this is an overlapped file, this function will return
		// immediately. Later, when a character is received, the comm
		// port will assert the OverlappedRead.hEvent event.
	    if (!WaitCommEvent(pSerial->m_hIDComDev,&evt, &pSerial->OverlappedRead))
		{
			if (ERROR_IO_PENDING!=GetLastError())
			{
			    TRACE("WaitCommEvent failed, exiting Read Thread\n");
			    return 0;
			}
			// We're waiting. Use WaitFor... and wait for the event
		}
		if (!ResetEvent(pSerial->OverlappedRead.hEvent))
		{
			TRACE("ResetEvent failed, exiting Read Thread\n");
			return 0;
		}
		dwHandleSignaled=WaitForMultipleObjects(2,
			   pSerial->hReadEvents,
			   FALSE,
			   INFINITE);
        // Which event occured?
        switch(dwHandleSignaled)
        {
            case WAIT_OBJECT_0 + 1:
				{// Chars are in the rcv port
                    if ( (bytesin=pSerial->ReadDataWaiting()) > 0)
					{
			            char buff[500];
						DWORD BytesRead;
			            // Get the data from the serial port
						TRACE("Before ReadFile ");
						pSerial->TraceLastError(GetLastError());
						SetLastError(0);
						ReadFile(pSerial->m_hIDComDev,
							     buff,bytesin,&BytesRead,
								 &pSerial->OverlappedRead);
						TRACE("After ReadFile ");
						pSerial->TraceLastError(GetLastError());
/* debug
			            //pSerial->ReadData(buff,bytesin);

			            // copy the data to the msg buffer
						CSerPortMsg *msg = new CSerPortMsg;
			            msg->SetBuffer(buff,bytesin);

			            // Call the virtual function the user will over-ride
			            // to handle this message.
			            pSerial->ReadThreadDataIn(msg);
*/
					}
					break;
				}
			case WAIT_OBJECT_0:
				{// Time to quit
					PurgeComm(pSerial->m_hIDComDev,PURGE_RXABORT | PURGE_RXCLEAR);
					return 0;
				}
		}
	}
}