实现了一个写LOG类

//  tracelog.h: interface for the CTraceLog class.
//
/**/ ///////////////////////////////////////////////////////////////////// /

#if  !defined(TRACELOG_H__B46BAA60_61F0_4CEC_8DEE_E8CC9EF26BA8__INCLUDED_)
#define  TRACELOG_H__B46BAA60_61F0_4CEC_8DEE_E8CC9EF26BA8__INCLUDED_

#if  _MSC_VER > 1000
#pragma once
#endif   //  _MSC_VER > 1000
#pragma warning(disable: 4786 )
#include  < windows.h >
#include  < process.h >
#include  < vector >
#include  < string >

#pragma warning(disable: 4786 )

#include  < stdio.h >

class  CTraceLog  
{
public :
    CTraceLog()
     {
        m_hSemaphore  =  NULL;
        m_hThread     =  NULL;
        m_bEndThread  =   false ;
    }

     virtual   ~ CTraceLog()
     {

    }

     bool  init()
     {
         if ( m_hSemaphore  !=  NULL )
             return   false ;

        m_hSemaphore  =  ::CreateSemaphore(NULL,  0 ,  0xFFFF , NULL);

         //  If the function fails, the return value is NULL.
         if ( m_hSemaphore  ==  NULL )
             return   false ;
        
         //  the function returns a handle to the existing object and GetLastError returns ERROR_ALREADY_EXISTS.
         if  ( ::GetLastError()  ==  ERROR_ALREADY_EXISTS )
             return   false ;

        ::InitializeCriticalSection( & m_CriticalSection);

         if  ( m_hThread  !=  NULL )
             return   false ;

        unsigned  int  nThreadId  =   0 ;
        m_hThread  =  (HANDLE)_beginthreadex(NULL,  0 , _ThreadProc, ( void * ) this ,  0 ,  & nThreadId);

         if ( m_hThread  ==   0  )
             return   false ;

         return   true ;
    }

     bool  uninit()
     {
        m_bEndThread  =   true ;
        ::ReleaseSemaphore(m_hSemaphore,  1 , NULL);

        DWORD dwRet  =  ::WaitForSingleObject(m_hThread, INFINITE);

         if  ( dwRet  ==  WAIT_FAILED )
             return   false ;

        ::CloseHandle(m_hSemaphore);
        m_hSemaphore  =  NULL;

        ::DeleteCriticalSection( & m_CriticalSection);

         return   true ;
    }

     void  log( const   char *  pszBuf)
     {
        ::EnterCriticalSection( & m_CriticalSection);
        
        m_Log.push_back(pszBuf);
        ::ReleaseSemaphore(m_hSemaphore,  1 , NULL);

        ::LeaveCriticalSection( & m_CriticalSection);            
    }


protected :

     virtual   void  _logFile( const   char *  pszBuf)  =   0 ;

     static  unsigned __stdcall _ThreadProc( void *  pVoid)
     {
        CTraceLog *  pThis  =  (CTraceLog * )pVoid;

         while ( true )
         {
            DWORD dwRet  =  ::WaitForSingleObject(pThis -> m_hSemaphore, INFINITE);

             if  ( dwRet  ==  WAIT_FAILED )
                 break ;

            std::vector < std:: string >  m_LogCopy;
            
            ::EnterCriticalSection( & pThis -> m_CriticalSection);
            m_LogCopy.resize(pThis -> m_Log.size());
            std::copy(pThis -> m_Log.begin(), pThis -> m_Log.end(), m_LogCopy.begin());
            pThis -> m_Log.clear();
            ::LeaveCriticalSection( & pThis -> m_CriticalSection);

            std::vector < std:: string > ::iterator iter_t;

             for  ( iter_t  =  m_LogCopy.begin(); iter_t  !=  m_LogCopy.end(); iter_t ++  )
                pThis -> _logFile(iter_t -> c_str());
                        
             if  ( pThis -> m_bEndThread )
                 break ;

        } //  while(true)

         return   0 ;
    }
        
private :
    std::vector < std:: string >  m_Log;           //  Log 信息队列
    HANDLE                   m_hSemaphore;       //  信号量
    CRITICAL_SECTION         m_CriticalSection;  //  队列访问互斥量
    HANDLE                   m_hThread;          //  线程 Handle
     bool                      m_bEndThread;       //  结束线程标志
} ;



#endif   //  !defined(TRACELOG_H__B46BAA60_61F0_4CEC_8DEE_E8CC9EF26BA8__INCLUDED_)