自用的日志类

#pragma once
#include "CriticalSectionWrapper.h"


#define DEBUG_LOG_FILE         _T("iCar24_log.txt")

#define LOG_BUFFER_SIZE    1024

class CDebugWriteLog
{
public:
	CDebugWriteLog(void);
	 ~CDebugWriteLog(void);
	DWORD WriteLog(const wchar_t* wstr, ...);		// 写日志(宽字节版本)
	DWORD WriteLog(const char* str, ...);			// 写日志(多字节版本)

	void WriteLogHex(const char * buf, int len);
	void CloseLog();
	bool SetLogFilePath(TCHAR* szPath);

	bool OpenLog(LPCTSTR szPath);

	bool IsOpen();
private:
	HANDLE m_hLogFile;
	CCriticalSectionWrapper m_csLogLock;
	TCHAR m_szFilePathName[MAX_PATH];
	char buf[LOG_BUFFER_SIZE];
	
};

#include "StdAfx.h"
#include "log.h"
#include <stdio.h>
#include <time.h>

CDebugWriteLog::CDebugWriteLog(void)
{
	m_hLogFile = INVALID_HANDLE_VALUE;
	memset(m_szFilePathName,0,sizeof(TCHAR)*MAX_PATH);
	memset(buf,0,LOG_BUFFER_SIZE);
}

CDebugWriteLog::~CDebugWriteLog(void)
{
}
DWORD CDebugWriteLog::WriteLog(const wchar_t* wstr, ...)
{
	if (!wstr)
		return 0;

	DWORD dwWriteLength = 0;
	va_list arg_ptr;
	va_start(arg_ptr, wstr);
	int wLen = WideCharToMultiByte(CP_ACP,0,wstr,-1,NULL,0,NULL,NULL);
	if (wLen == 0)
	{
		return 0;
	}
	char* pTemp = new char[wLen];
	if (!pTemp)
	{
		return 0;
	}
	memset(pTemp,0,wLen);
	WideCharToMultiByte(CP_ACP,0,wstr,-1,pTemp,wLen,NULL,NULL);
	if (wLen > 0)
	{
		dwWriteLength = WriteLog(pTemp);
	}
	delete []pTemp;
	pTemp = NULL;
	va_end(arg_ptr);
	return dwWriteLength;
}
DWORD CDebugWriteLog::WriteLog(const char* str, ...)
{
	if (!str)
		return 0;

	DWORD dwWriteLength = 0;
	SYSTEMTIME st;
	memset(&st,0,sizeof(SYSTEMTIME));
	GetLocalTime(&st);
	ZeroMemory(buf,LOG_BUFFER_SIZE);
	sprintf(buf,"[%04d-%02d-%02d %02d:%02d:%02d]",st.wYear,st.wMonth,st.wDay,st.wHour, st.wMinute, st.wSecond);
	m_csLogLock.Lock();
	va_list arg_ptr;
	va_start(arg_ptr, str);
	vsprintf( &buf[strlen(buf)],str,arg_ptr);
	strcat_s(buf,sizeof(buf),"\r\n");

	if (IsOpen())
	{
		WriteFile(m_hLogFile,buf,strlen(buf),&dwWriteLength,NULL);
		FlushFileBuffers(m_hLogFile);
	}
	else
	{
		printf("%s",buf);
	}
	va_end(arg_ptr);
	m_csLogLock.Unlock();

	return dwWriteLength;
}
bool CDebugWriteLog::OpenLog(LPCTSTR szPath)
{
	if (IsOpen())
	{
		return true;
	}
	if (!szPath)
	{
		return false;
	}
	wcscpy(m_szFilePathName,szPath);
	TCHAR temp_PATH[MAX_PATH];
	memset(temp_PATH,0,sizeof(TCHAR)*MAX_PATH);

	wcscpy(temp_PATH,szPath);
	wcscat(temp_PATH,DEBUG_LOG_FILE);
	m_hLogFile = CreateFile(temp_PATH,
				  GENERIC_READ|GENERIC_WRITE,
			FILE_SHARE_WRITE|FILE_SHARE_READ,
										NULL,
								 OPEN_ALWAYS,
					   FILE_ATTRIBUTE_NORMAL,
										  0);
	if (!IsOpen()&&GetLastError() == 2)
	{
		m_hLogFile = CreateFile(temp_PATH,
			GENERIC_READ|GENERIC_WRITE,
			FILE_SHARE_WRITE|FILE_SHARE_READ,
			NULL,
			OPEN_EXISTING,
			FILE_ATTRIBUTE_NORMAL,
			0);
	}
	if (IsOpen())
	{
		SetFilePointer(m_hLogFile, 0, NULL, FILE_END);
	}
	return IsOpen();
}
void CDebugWriteLog::CloseLog()
{
	if (IsOpen())
	{
		CloseHandle(m_hLogFile);
		m_hLogFile = INVALID_HANDLE_VALUE;
	}
}
bool CDebugWriteLog::SetLogFilePath(TCHAR *szPath)
{
	if (!szPath)
	{
		return false;
	}
	if (IsOpen())
	{
		CloseLog();
	}
	memset(m_szFilePathName,0,MAX_PATH);
	wcscpy_s(m_szFilePathName, _countof(m_szFilePathName), szPath);
	return OpenLog(szPath);
}

char strLog[4096];
void CDebugWriteLog::WriteLogHex(const char * buf, int len) 
{
	
	memset(strLog, 0, 4096);
	for(int i=0; i<len; i++)
	{
		char tmsg[4];
		int tvalue = (unsigned char)buf[i];
		sprintf(tmsg,"%02X ",tvalue);
		strcat(strLog, tmsg);
	}
	WriteLog(strLog);
}
bool CDebugWriteLog::IsOpen()
{
	return m_hLogFile != INVALID_HANDLE_VALUE;
}

临界区锁类

#pragma once

class CCriticalSectionWrapper
{
public:
	CCriticalSectionWrapper(void);
	~CCriticalSectionWrapper(void);
	void Lock();
	void Unlock();
protected:
	CRITICAL_SECTION m_criticalSection;
	BOOL m_bInitialized;
};

#include "StdAfx.h"
#include "CriticalSectionWrapper.h"

CCriticalSectionWrapper::CCriticalSectionWrapper(void)
{
	m_bInitialized = TRUE;
	InitializeCriticalSection(&m_criticalSection);
}

CCriticalSectionWrapper::~CCriticalSectionWrapper(void)
{
	if (m_bInitialized)
	{
		DeleteCriticalSection(&m_criticalSection);
		m_bInitialized = FALSE;
	}
}
void CCriticalSectionWrapper::Lock()
{
	if (m_bInitialized)
	{
		EnterCriticalSection(&m_criticalSection);
	}
}
void CCriticalSectionWrapper::Unlock()
{
	if (m_bInitialized)
	{
		LeaveCriticalSection(&m_criticalSection);
	}
}