将设计模式运用于游戏设计：将日志做成单件

在游戏程序中日志显得非常重要，例如在调试AI的时候需要连续跟踪AI状态的变化，在非正常的函数返回点记录状态信息等等。但是这一系列的log如果没有统一管理那么将变得很混乱，而且在多线程的情况下有可能会出现同步问题。为此专门用单件的模式制作了一个日志类，希望能派的上用场。不多说了，直接贴代码，原理很简单，关键地方有注释。

log.h

#include  < windows.h >
#include  < fstream >

class  CSynObj
{
public :
    CSynObj()
    {
        InitializeCriticalSection( & m_cs);
    }
   
     ~ CSynObj()
    {
        DeleteCriticalSection( & m_cs);
    }

    void  Lock()
   {
       EnterCriticalSection( & m_cs);    
   }

    void  UnLock()
   {
       LeaveCriticalSection( & m_cs);
       
   }

private :
    CRITICAL_SECTION m_cs;
};

class  CLock        
{
public :
    CLock(CSynObj &  synchobject)
        :refSynchObject(synchobject)
    {
        refSynchObject.Lock();
    }

     virtual   ~ CLock()
    {
        refSynchObject.UnLock();
    }

protected :
    CSynObj &  refSynchObject;
};

enum  LOG_TARGET_E
{
    LOG_TARGET_SCREEN     =   1 ,
    LOG_TARGET_FILE         =   2 ,
};


class  CLog
{
private :

     ~ CLog();

    CLog();

    CLog( const  CLog &  rhs) {}

    CLog &   operator   =  ( const  CLog &  rhs) {}

     static  CLog *     m_pLog;

     static  CSynObj    m_Lock;

    std::ofstream    m_OutFile;

     void  GetSysTime(SYSTEMTIME *  lpSysTime);

     void  FormatAllTime( const  SYSTEMTIME &  refSysTime, std:: string &  strOut);

public :

     void     Write( char *  pMsg,  int  nTarget);

     static  CLog *     GetInstance();

     //  摧毁singleton的入口
     static   void  DestroyInstance();
};

__inline  void  DEBUG_MSG(LPSTR filename,  int  lineno, LPSTR linedesc, DWORD dwErrCode,  int  nOutPutTarget  =  LOG_TARGET_SCREEN | LOG_TARGET_FILE)
{
     char  cTemp[ 256 ];
    sprintf( cTemp,  " %lu error on %d line in %s file: %s " , dwErrCode, lineno, filename, linedesc );
    CLog *  pLog  =  CLog::GetInstance();
    pLog -> Write( cTemp, nOutPutTarget );
}

 log.cpp

#include  < iostream >
#include  < log.h >

CLog *  CLog::m_pLog  =  NULL;
CSynObj    CLog::m_Lock;

CLog:: ~ CLog()
{
    m_OutFile.close();
}

CLog::CLog()
{
    m_OutFile.open(  " Log.txt " , std::ios::app );
    atexit( CLog::DestroyInstance );
}

void  CLog::GetSysTime(SYSTEMTIME *  lpSysTime)
{
     // 获得系统时间
    FILETIME CurFileTime;
    ::GetSystemTimeAsFileTime( & CurFileTime);
    ::FileTimeToLocalFileTime( & CurFileTime,  & CurFileTime);
    ::FileTimeToSystemTime( & CurFileTime, lpSysTime);
}

void  CLog::FormatAllTime( const  SYSTEMTIME &  refSysTime, std:: string &  strOut)
{
     // 系统时间转换成字符串
     char  cBuffer[MAX_PATH * 2 ];
    sprintf(cBuffer, " %d-%02d-%02d %02d:%02d:%02d " ,
        refSysTime.wYear, refSysTime.wMonth, refSysTime.wDay , refSysTime.wHour , refSysTime.wMinute , refSysTime.wSecond);
    strOut  =  cBuffer;
}


void  CLog::Write( char *  pMsg,  int  nTarget)
{
     //  区间锁，在同一时刻只允许一个线程进行写文件或屏幕
    CLock Lock( CLog::m_Lock );
    SYSTEMTIME Systime;
    std:: string  strTime;
    GetSysTime(  & Systime );
    FormatAllTime( Systime, strTime );
     if ( nTarget  &  LOG_TARGET_FILE )
        m_OutFile  <<  strTime.c_str()  <<   " :  "   <<  pMsg  <<  std::endl;
     if ( nTarget  &  LOG_TARGET_SCREEN )
        std::cout  <<  pMsg  <<  std::endl;
}


CLog *  CLog::GetInstance()
{
     //  双次检测的好处
     //  1:防止多线程同时进入new CLog;
     //  2:临界区写在第二次判断，提高了效率
     if (  ! m_pLog )
    {
        CLock Lock( CLog::m_Lock );
         if (  ! m_pLog )
            m_pLog  =   new  CLog;
    }
     return  m_pLog;
}

//  与GetInstance对应,给CLog一个delete的机会
void  CLog::DestroyInstance()
{
    delete m_pLog;
    m_pLog  =  NULL;
}





int  main()
{
    atexit( CLog::DestroyInstance );
    DEBUG_MSG( __FILE__, __LINE__,  " main() " ,  0  );
    getchar();
     return   0 ;
}