一些工具函数_什么工具函数-CSDN博客

本文链接：https://blog.csdn.net/xiangsl/article/details/234714

#if !defined(STDFUNC_H)
#define STDFUNC_H

#include "StdType.h"

//***************************************************************字符串处理函数

/******************************************************************************
//声明:bool IsDgt(const string& szData)
//功能:判断是否是数字字符串
//输入:szData:指定字符串
//输出:无
//返回值:bool:是返回true,否则返回false
******************************************************************************/
bool IsDgt(const string& szData);

/******************************************************************************
//声明:int ToInt(const string& s)
//功能:将输入字符串转为整数
//输入:s:指定字符串
//输出:无
//返回值:int:如果不是整数字符串则返回-1,否则返回对应的整数
******************************************************************************/
int ToInt(const string& s);

/******************************************************************************
//声明:string ToStr(int i)
//功能:将数字转换为整数
//输入:i:指定数字
//输出:无
//返回值:string:与输入数字对应的字符串
******************************************************************************/
string ToStr(int i);

/******************************************************************************
//声明:string FmtInt(int iData, int iLen, char cFillChar='0')
//功能:用填充字符将指定的数字按指定长度格式化为字符串
//输入:iData:指定数字
         iLen:指定长度
   cFillChar:填充字符
//输出:无
//返回值:string:格式字符串
******************************************************************************/
string FmtInt(int iData, int iLen, char cFillChar='0');

/******************************************************************************
//声明:string StrUpper(string szData)
//功能:将输入字符串转为大写输出
//输入:szData:输入字符串
//输出:无
//返回值:string:大写字符串
******************************************************************************/
string StrUpper(string szData);

/******************************************************************************
//声明:string Trim(const string& szData)
//功能:将输入字符串去掉首尾空格后输出
//输入:szData:输入字符串
//输出:无
//返回值:string:不包含首尾空格的字符串
******************************************************************************/
string Trim(const string& szData);

/******************************************************************************
//声明:string TrimLeft(const string& szData)
//功能:将输入字符串去掉首部空格后输出
//输入:szData:输入字符串
//输出:无
//返回值:string:不包含首部空格的字符串
******************************************************************************/
string TrimLeft(const string& szData);

/******************************************************************************
//声明:string TrimLeft(const string& szData)
//功能:将输入字符串去掉尾部空格后输出
//输入:szData:输入字符串
//输出:无
//返回值:string:不包含尾部空格的字符串
******************************************************************************/
string TrimRight(const string& szData);

/******************************************************************************
//声明:string StrUpTrim(const string& szData)
//功能:将输入字符串去掉尾部空格同时大写
//输入:szData:输入字符串
//输出:无
//返回值:string:不包含尾部空格的大写字符串
******************************************************************************/
string StrUpTrim(const string& szData);
/******************************************************************************
//声明:bool StrSplit(const char* pData, CStrLst& lines, const char* pSplit=",")
//功能:用指定的分割符将输入字符串分割成字符串列
//输入:pData:源字符串指针
         pSplit:分割方式(默认用","分割)
//输出:lines:分割后的字符串列结果
//返回值:bool:分割成功true此时输出有效,分割失败false此时输出无效
******************************************************************************/
bool StrSplit(const char* pData, CStrLst& lines, const char* pSplit=",");

/******************************************************************************
//声明:const char* TransFind(const char* pStart, const char* pSplit=",")
//功能:在输入字符串中查找分割符,如果分割符号前有转义字符,则不是分割符
//输入:pStart:源字符串指针
         pSplit:分割方式(默认用","分割)
//输出:无
//返回值:分割符位置
//说明:输入pStart="/," return NULL;
       输入pStart="//," return pStart+2
   输入pStart="/,a," return pStart+3
******************************************************************************/
const char* TransFind(const char* pStart, const char* pSplit=",");

/******************************************************************************
//声明:bool StrSplitTrans(const char* pData, CStrLst& lines, const char* pSplit=",")
//功能:用指定的分割符将输入字符串分割成字符串列(分割符前有转义符,则不是分割符)
//输入:pData:源字符串指针
         pSplit:分割方式(默认用","分割)
//输出:lines:分割后的字符串列结果
//返回值:bool:分割成功true此时输出有效,分割失败false此时输出无效
******************************************************************************/
bool StrSplitTrans(const char* pData, CStrLst& lines, const char* pSplit=",");

/******************************************************************************
//声明:string TimeToNum(SYSTEMTIME& tm,CTimeType type=TM14)
//功能:将指定系统时间指定部分转换为数字字符串
//输入:tm:系统时间
         type:时间类型1:14位,2:6位,3:17位,4:8位
//输出:无
//返回值:string:数字型时间字符串
******************************************************************************/
string TimeToNum(SYSTEMTIME& tm, CTimeType type=TM14);

/******************************************************************************
//声明:string TimeToStr(SYSTEMTIME& tm,CTimeType type=TM14)
//功能:将指定系统时间指定部分转换为字符串
//输入:tm:系统时间
         type:时间类型1:14位,2:6位,3:17位,4:8位
//输出:无
//返回值:string:数字型时间字符串
******************************************************************************/
string TimeToStr(SYSTEMTIME& tm,CTimeType type=TM14);

/******************************************************************************
//声明:string GetSysStrTime(CTimeType type=TM14)
//功能:将系统时间指定部分转换对应的字符串
//输入:type:时间类型1:14位,2:6位,3:17位,4:8位
//输出:无
//返回值:string:数字型时间字符串
******************************************************************************/
string GetSysStrTime(CTimeType type=TM14);

/******************************************************************************
//声明:string GetSysNumTime(CTimeType type=TM14)
//功能:将系统时间指定部分转换对应的数字字符串
//输入:type:时间类型1:14位,2:6位,3:17位,4:8位
//输出:无
//返回值:string:数字型时间字符串
******************************************************************************/
string GetSysNumTime(CTimeType type=TM14);

string GetRandStr();

string GetHex(int data, int len);

int HexToInt(char* pHex);

bool WaitTimer(int second, int msecond=0);

char* GetSelData(const char* pData, int iStart, string& szOut);

//*****************************************************************文件处理函数

/******************************************************************************
//声明:bool ReadFile(const string& szFile, string& szData)
//功能:从文件中读数据
//输入:szFile:文件名
//输出:szData:读入数据
//返回值:bool读成功返回true,否则返回失败
******************************************************************************/
bool ReadFile(const string& szFile, string& szData);

bool ReadFile(const string& szFile, CStrLst& Lines, bool bTrunc=true);

/******************************************************************************
//声明:bool WriteFile(const string& szFile, const string& szData)
//功能:从文件中读数据
//输入:szFile:文件名
         pData:写入数据指针
         iLen:写入数据长度
//输出:无
//返回值:bool写成功返回true,否则返回失败
******************************************************************************/
bool WriteFile(const string& szFile, const char* pData, int iLen);

/******************************************************************************
//声明:bool LoadFile(const string& szFile, CStrLst& Lines)
//功能:从文件中读数据
//输入:szFile:文件名
//输出:Lines:读入数据
//返回值:bool写成功返回true,否则返回失败
******************************************************************************/
bool LoadFile(const string& szFile, CStrLst& Lines);

/******************************************************************************
//声明:bool SaveFile(const string& szFile, const CStrLst& Lines)
//功能:从文件中读数据
//输入:szFile:文件名
Lines:写入数据
//输出:无
//返回值:bool写成功返回true,否则返回失败
******************************************************************************/
bool SaveFile(const string& szFile, const CStrLst& Lines);

/******************************************************************************
//声明:string ExtractFilePath(const string& szFile)
//功能:从全文件名中取路径
//输入:szFile:文件名
//输出:无
//返回值:string:路径
******************************************************************************/
string ExtractFilePath(const string& szFile);

string ExtractFileExt(const string& FileName);

string ExtractFileName(const string& FileName);

string ExtractFileNameNoExt(const string& szFile);

/******************************************************************************
//声明:bool AppendFile(const string& szFile, const char* pData, int iLen)
//功能:将数据添加到文件中，如果文件不存在则创建
//输入:szFile:文件名
         pData:数据指针
   iLen:数据长度
//输出:无
//返回值:如果添加成功返回true,否则返回失败
******************************************************************************/
bool AppendFile(const string& szFile, const char* pData, int iLen);

/******************************************************************************
//声明:bool DirExists(const string& szPath)
//功能:判断目录存在与否,通过取文件的属性来判断
//输入:szPath:目录名
//输出:无
//返回值:如果目录存在返回true,否则返回失败
******************************************************************************/
bool DirExists(const string& szPath);

/******************************************************************************
//声明:bool DirCreate(const string& szPath)
//功能:创建目录
//输入:szPath:目录名
//输出:无
//返回值:如果创建目录成功返回true,否则返回失败
******************************************************************************/
bool DirCreate(const string& szPath);

string CheckPath(const string& szPath);

bool FileExist(const string& szFile);

bool GetFileLst(string szPath, CStrLst &FileLst);

bool BackDir(string szSrc, string szDest);

bool CopyFileLst(CStrLst& FileLst, string szPath);

bool DelFileByExt(string szPath, string szExt="*");

string GetFileTime(const string& szFile, int iTag=2);

bool SetFileTime(const string& szFile, int iTag=3);
//*****************************************************************文件处理函数

#endif //STDFUNC_H

#include "stdfunc.h"

bool IsDgt(const string& szData)
{
for (size_t i=0; i<szData.size(); ++i)
if (!isdigit(szData[i]))
return false;
return true;
}

int ToInt(const string& s)
{
int iRet = -1;
if (s.empty())
return iRet;

for (size_t i=0; i<s.size(); ++i)
  if (!isdigit(s[i]))
   return iRet;

istringstream iss(s);
if (iss >> iRet)
  return iRet;
else
  return iRet;
}

string ToStr(int i)
{
char buf[INTLEN];
memset(buf, 0, sizeof(buf));
sprintf(buf, "%d", i);
return buf;
}

string FmtInt(int iData, int iLen, char cFillChar)
{
char buf[FMTINTLEN];
if (iLen >= FMTINTLEN)
return "";
string sztmp = "%";
sztmp += cFillChar + ToStr(iLen)+"d";
sprintf(buf, sztmp.c_str(), iData);
return buf;
}

string StrUpper(string szData)
{
for (size_t i=0; i<szData.size(); ++i)
szData[i] = toupper(szData[i]);

return szData;
}

string Trim(const string& szData)
{
size_t i = 0;//第一个非空字符的索引
for (; i < szData.size(); ++i)
if (szData[i] != 0x20)
break;

size_t j = szData.size();//最后一个非空字符的索引
for (; j > 0; --j)
if (szData[j-1] != 0x20)
break;

if (j > i)
return string(szData.begin()+i, szData.begin()+j);
else
return "";
}

string TrimLeft(const string& szData)
{
size_t i = 0;
for (; i<szData.size(); ++i)
if (szData[i] != 0x20)
break;
return szData.substr(i);
}

string TrimRight(const string& szData)
{
size_t i = szData.size();
for (; i>0; --i)
if (szData[i-1] != 0x20)
break;
return szData.substr(0, i);
}

string StrUpTrim(const string& szData)
{
return StrUpper(Trim(szData));
}

bool StrSplit(const char* pData, CStrLst& lines, const char* pSplit)
{
if (NULL == pData)
return false;//输入字符串为空直接返回false

int iLen = strlen(pData);
if (0 == iLen) {
lines.push_back("");//长度为0时也认为分割成功
return true;
}

const char* pos = pData;
int iSplitLen = strlen(pSplit);
int iLastPos = 0;

while (NULL != (pos = strstr(pos, pSplit))) {//不能找到分割符，结束循环
  //pData+iLastPos=已分割字符串的结束位置
  //pos-pData-iLastPos=这次分割字符串的结束位置
  lines.push_back(string(pData+iLastPos, pos-pData-iLastPos));
  pos += iSplitLen;//移动iSplitLen个字符，使其指向未分割的字符串
  iLastPos = pos-pData;//已分割字符串的长度
}

//当<的情况,最后一项不为空
//当=的情况,最后一项为空
if (iLastPos <= iLen)
lines.push_back(string(pData+iLastPos, pData+iLen));

return true;
}

bool StrSplitTrans(const char* pData, CStrLst& lines, const char* pSplit)
{
if (NULL == pData)
return false;//输入字符串为空直接返回false

int iLen = strlen(pData);
if (0 == iLen) {
lines.push_back("");//长度为0时也认为分割成功
return true;
}

const char* pos = pData;
int iSplitLen = strlen(pSplit);
int iLastPos = 0;

while (NULL != (pos = TransFind(pos, pSplit))) {
  //pData+iLastPos=已分割字符串的结束位置
  //pos-pData-iLastPos=这次分割字符串的结束位置
  lines.push_back(string(pData+iLastPos, pos-pData-iLastPos));
  pos += iSplitLen;//移动iSplitLen个字符，使其指向未分割的字符串
  iLastPos = pos-pData;//已分割字符串的长度
}

//当<的情况,最后一项不为空
//当=的情况,最后一项为空
if (iLastPos <= iLen)
  lines.push_back(string(pData+iLastPos, pData+iLen));

return true;
}

const char* TransFind(const char* pStart, const char* pSplit)
{
search:
const char* pEnd = strstr(pStart, pSplit);//查找分割符
if (pEnd - pStart >= 1 && (pEnd-1)[0] == TRANSCHAR) {//分割符前有转义字符
  int i = pEnd-pStart-2;//指向转义符前一个字符如:abc//,则指向c
  int iCount = 1;//已有一个转义字符了
  for (; i >= 0; --i) {
   if (TRANSCHAR != pStart[i]) {
    if ((iCount%2) ==0) //如果转义字符为双数则分割符未被转义
     return pEnd;
    pStart = pEnd+1;//否则已被转义了,从当前分割位置向后继续查找
    goto search;
   }else{
    ++iCount;//转义计数增加
   }
  }
  if (-1 == i) {//全是转义符的情况
   if ((iCount%2) ==0) //如果转义字符为双数则分割符未被转义
    return pEnd;
   pStart = pEnd+1;//否则已被转义了,从当前分割位置向后继续查找
   goto search;
  }
}else{
   return pEnd;
}

return NULL;
}

string TimeToNum(SYSTEMTIME& tm,CTimeType type)
{
string szDate, szTime, result;
szDate = FmtInt(tm.wYear, 4, '0') +
    FmtInt(tm.wMonth, 2, '0') +
    FmtInt(tm.wDay, 2, '0');

szTime = FmtInt(tm.wHour, 2, '0') +
    FmtInt(tm.wMinute, 2, '0') +
    FmtInt(tm.wSecond, 2, '0');

result = FmtInt(tm.wMilliseconds, 3, '0');
switch (type)
{
case TM14:
  result = szDate + szTime;
  break;
case TM06:
  result = szTime;
  break;
case TM17:
  result = szDate + szTime + result;
  break;
case TM08:
  result = szDate;
  break;
default:
  result = "";
}
return result;
}

string TimeToStr(SYSTEMTIME& tm,CTimeType type)
{
string szDate, szTime, result;
szDate = FmtInt(tm.wYear, 4, '0') +"-"+
    FmtInt(tm.wMonth, 2, '0') +"-"+
    FmtInt(tm.wDay, 2, '0');

szTime = FmtInt(tm.wHour, 2, '0') +":"+
    FmtInt(tm.wMinute, 2, '0') +":"+
    FmtInt(tm.wSecond, 2, '0');

result = FmtInt(tm.wMilliseconds, 3, '0');
switch(type)
{
case TM14:
  result = szDate + " "+ szTime;
  break;
case TM06:
  result = szTime;
  break;
case TM17:
  result = szDate + " "+ szTime + ":"+ result;
  break;
case TM08:
  result = szDate;
  break;
default:
  result = "";
}
return result;
}

string GetSysStrTime(CTimeType type)
{
SYSTEMTIME tm;
GetLocalTime(&tm);
return TimeToStr(tm, type);
}

string GetSysNumTime(CTimeType type)
{
SYSTEMTIME tm;
GetLocalTime(&tm);
return TimeToNum(tm, type);
}

string GetRandStr()
{
char chRandStr[16]={0};
srand(GetTickCount()%100000);
for(int i= 0; i< 16 ; i++)
{
chRandStr[i]= 'a'+ rand() % 26;
}
return string(chRandStr, chRandStr+16);
}

string GetHex(int data, int len)
{
if (len > 20)
return "";

char buf[20];
memset(buf, 0, sizeof(buf));

string szFormat = "%0";
szFormat += ToStr(len);
szFormat += "x";
sprintf(buf, szFormat.c_str(), data);

return string(buf, buf+len);
}

int HexToInt(char* pHex)
{
if(NULL == pHex)
  return 0;
int iLen= strlen(pHex),i ,iRet= 0;
for(i= 0; i< iLen; i++)
{
  bool bOk = false;
  char c= pHex[iLen- i- 1] ;
  if((c>='a') &&(c<='f'))
  {
   iRet= iRet+ (c-'a' + 10) * pow(16, i);
   bOk = true;
  }
  if((c>='A') &&(c<='F'))
  {
   iRet= iRet+ (c-'A' + 10) * pow(16, i);
   bOk = true;
  }
  if((c>='0')&&(c<='9'))
  {
   iRet= iRet+ (c-'0') * pow(16, i);
   bOk = true;
  }
  if (!bOk)
   return -1;
}
return iRet;
}

//iStart从0开始算
char* GetSelData(const char* pData, int iStart, string& szOut)
{
const char* pos = pData;

if (iStart < 0)
return NULL;

while (iStart-- != 0) {

if (NULL == (pos = strstr(pos, ",")))
return NULL;

pos++;
}

char* pos1 = strstr(pos, ",");

if (NULL == pos1) {

szOut = string(pos, pos + strlen(pos));

return NULL;
}else {

szOut = string(pos, pos1);

return pos1+1;
}
}

bool WaitTimer(int second, int msecond)
{
/*
HANDLE hTimer = CreateWaitableTimer(NULL, false, NULL);

SYSTEMTIME st;
GetLocalTime(&st);
st.wSecond = 61;//这里有个问题，如果超过60就不能超时

FILETIME ftLocal, ftUtc;
SystemTimeToFileTime(&st, &ftLocal);
LocalFileTimeToFileTime(&ftLocal, &ftUtc);

LARGE_INTEGER liUtc;
liUtc.LowPart = ftUtc.dwLowDateTime;
liUtc.HighPart = ftUtc.dwHighDateTime;
//LARGE_INTEGER liUtc;
//liUtc.HighPart = (second/3600);
//liUtc.LowPart = ((second%3600) * 1000 + msecond) * 10000;
//liUtc.QuadPart *=-1;
//liUtc.QuadPart =-1 * (second * 1000 + msecond) * 10000;
SetWaitableTimer(hTimer, &liUtc, 0, NULL, NULL, false);
//这里利用了上面那个错误，进行等待，最终会超时*/
HANDLE hEvent = CreateEvent(NULL, true, false, NULL);
WaitForSingleObjectEx(hEvent, second*1000+msecond, true);//INFINITE
CloseHandle(hEvent);
return true;
}

bool ReadFile(const string& szFile, string& szData)
{
HANDLE hFile = CreateFile(szFile.c_str(),
       GENERIC_READ,
       FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,
       FILE_ATTRIBUTE_NORMAL,0);
if (INVALID_HANDLE_VALUE == hFile)
  return false;

DWORD dwLen=GetFileSize(hFile, NULL);
char* buf = new char[dwLen];

ReadFile(hFile, buf, dwLen, &dwLen, 0);

CloseHandle(hFile);
szData = string(buf, buf+dwLen);
delete []buf;

return true;
}

bool WriteFile(const string& szFile, const char* pData, int iLen)
{
HANDLE hFile = CreateFile(szFile.c_str(),
       GENERIC_WRITE,
       FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,
       FILE_ATTRIBUTE_NORMAL,0);
if (INVALID_HANDLE_VALUE == hFile)
  return false;

    WriteFile(hFile, pData, iLen, (DWORD*)&iLen, 0);
CloseHandle(hFile);

return true;
}

bool ReadFile(const string& szFile, CStrLst& Lines, bool bTrunc)
{
if (szFile.empty())
return false;

int iLoop=0;
HANDLE hFile;
while (true) {

  hFile = CreateFile(szFile.c_str(),
        GENERIC_WRITE|GENERIC_READ,
        0,NULL,OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,0);
  if (INVALID_HANDLE_VALUE == hFile) {
   WaitTimer(0, 50);
   if (++iLoop == 5)
    return false;
   continue;
  }else {
   break;
  }
}

int iFileSize = GetFileSize(hFile, NULL);
char* buf = new char[iFileSize+1];
memset(buf, 0, iFileSize+1);
DWORD NumberOfBytesRead;
ReadFile(hFile, buf, iFileSize, &NumberOfBytesRead, 0);

if (bTrunc) {
SetFilePointer(hFile, 0, 0, FILE_BEGIN);
SetEndOfFile(hFile);
}

CloseHandle(hFile);
StrSplit(string(buf, buf + iFileSize).c_str(), Lines, "/r/n");
delete []buf;

return true;
}

bool LoadFile(const string& szFile, CStrLst& Lines)
{
if (szFile.empty())
return false;

fstream infile(szFile.c_str());

if (!infile)
return false;

string s;

while (getline(infile, s))
  if (!(s=Trim(s)).empty())
   Lines.push_back(s);
infile.close();

return true;
}

bool SaveFile(const string& szFile, const CStrLst& Lines)
{
ofstream outfile(szFile.c_str());
if (!outfile)
return false;

for (int i=0; i<Lines.size(); ++i)
outfile << Lines[i] << endl;
outfile.close();

return true;
}

string ExtractFilePath(const string& szFile)
{
size_t idx = szFile.find_last_of("//:");

if (-1 == idx)
return "";

return string(szFile.begin(), szFile.begin()+idx+1);
}

string ExtractFileExt(const string& szFile)
{
size_t idx = szFile.find_last_of(".");

if (-1 == idx)
return "";

return string(szFile.begin()+idx+1, szFile.end());
}

string ExtractFileName(const string& szFile)
{
size_t idx = szFile.find_last_of("//");

if (-1 == idx)
return "";

return string(szFile.begin() + idx + 1, szFile.end());
}

string ExtractFileNameNoExt(const string& szFile)
{
string tmp = ExtractFileName(szFile);
size_t idx=tmp.find_last_of(".");
if (-1 == idx)
return szFile;
return string(tmp.begin(), tmp.begin()+idx);
}

bool AppendFile(const string& szFile, const char* pData, int iLen)
{
if (NULL == pData)
return false;

HANDLE hFile = CreateFile(szFile.c_str(),
       GENERIC_WRITE|GENERIC_READ,
       FILE_SHARE_READ,NULL,OPEN_ALWAYS,
       FILE_ATTRIBUTE_NORMAL,0);
if (INVALID_HANDLE_VALUE == hFile)
  return false;

SetFilePointer(hFile, 0, 0, FILE_END);
DWORD dw = 0;
WriteFile(hFile, pData, iLen, &dw, 0);
CloseHandle(hFile);

return true;
}

bool DirExists(const string& szPath)
{
DWORD dw = GetFileAttributes(szPath.c_str());
return ((dw != -1) && (FILE_ATTRIBUTE_DIRECTORY && (dw != 0)));
}

bool DirCreate(const string& szPath)
{
if (szPath.empty())
return false;

if (DirExists(szPath))
return true;

string szDir = szPath;
if (PATHSPLITCHAR[0] == szDir[szDir.size()])
szDir.erase(szDir.begin()+szDir.size()-1);//删除路径中最后一个分割符

CStrLst lst;
StrSplit(szDir.c_str(), lst, PATHSPLITCHAR);
if (lst.empty())
return false;

szDir = lst[0];//为盘符
for (size_t i = 1; i < lst.size(); ++i) {
  szDir += PATHSPLITCHAR + lst[i];//逐层创建子目录
  if (!DirExists(szDir) && !CreateDirectory(szDir.c_str(), 0))
   return false;//目录既不存在，又不能创建返回失败
}

return true;
}

bool FileExist(const string& szFile)
{
HANDLE hFile = CreateFile(szFile.c_str(),
       GENERIC_WRITE|GENERIC_READ,
       FILE_SHARE_READ,NULL,OPEN_EXISTING,
       FILE_ATTRIBUTE_NORMAL,0);
if (INVALID_HANDLE_VALUE == hFile)
  return false;

CloseHandle(hFile);

return true;
}

string CheckPath(const string& szPath)
{
if (szPath.size() < 3)
return "";

if ('//' == szPath[szPath.size()-1])
return szPath;
else
return szPath + "//";
}

bool GetFileLst(string szPath, CStrLst &FileLst)
{
szPath = CheckPath(szPath);
string szFind = CheckPath(szPath) + "*.*";

WIN32_FIND_DATA wfd;
memset(&wfd, 0, sizeof(WIN32_FIND_DATA));
HANDLE hFind= FindFirstFile(szFind.c_str(), &wfd);

if (hFind == INVALID_HANDLE_VALUE)
return false;

do {
if('.' == wfd.cFileName[0])
continue;

if (!(FILE_ATTRIBUTE_DIRECTORY & wfd.dwFileAttributes)) {

   SetFileAttributes((szPath + wfd.cFileName).c_str(), FILE_ATTRIBUTE_ARCHIVE);
   FileLst.push_back(wfd.cFileName);
  }
}while(FindNextFile(hFind, &wfd));

FindClose(hFind);

return true;
}

bool BackDir(string szSrc, string szDest)
{
CStrLst FileLst;
GetFileLst(szSrc, FileLst);

szSrc = CheckPath(szSrc);
szDest = CheckPath(szDest);

for (size_t i = 0; i < FileLst.size(); ++i) {

if (!CopyFile((szSrc + FileLst[i]).c_str(), (szDest + FileLst[i]).c_str(), false))
return false;
}

return true;
}

bool CopyFileLst(CStrLst& FileLst, string szPath)
{
string szSrcPath;
string szSrcFile;

szPath = CheckPath(szPath);
DirCreate(szPath);

for (size_t i = 0; i < FileLst.size(); ++i) {

szSrcPath = ExtractFilePath(FileLst[i]);
szSrcFile = ExtractFileName(FileLst[i]);

if (!CopyFile(FileLst[i].c_str(), (szPath + szSrcFile).c_str(), false))
return false;
}

return true;
}

bool DelFileByExt(string szPath, string szExt)
{
CStrLst FileLst;

szPath = CheckPath(szPath);
szExt = StrUpper(szExt);

GetFileLst(szPath, FileLst);

for (size_t i = 0; i < FileLst.size(); ++i) {
if (szExt != "*") {
if (szExt == StrUpper(ExtractFilePath(FileLst[i]))) {

    DeleteFile((szPath + FileLst[i]).c_str());
   }
  }else {

DeleteFile((szPath + FileLst[i]).c_str());
}
}

return true;
}

string GetFileTime(const string& szFile, int iTag)
{
HANDLE hFile = CreateFile(szFile.c_str(),
     GENERIC_READ,
     FILE_SHARE_READ|FILE_SHARE_WRITE,
     0,
     OPEN_EXISTING,
     0,0);
if (INVALID_HANDLE_VALUE == hFile)
  return "";

FILETIME FileTime;

switch(iTag)
{
case 0:
  GetFileTime(hFile, &FileTime, NULL, NULL);
  break;
case 1:
  GetFileTime(hFile, NULL, &FileTime, NULL);
  break;
case 2:
  GetFileTime(hFile, NULL, NULL, &FileTime);
  break;
}

CloseHandle(hFile);

SYSTEMTIME SysTime;

FileTimeToSystemTime(&FileTime, &SysTime);
SystemTimeToTzSpecificLocalTime(NULL, &SysTime, &SysTime);

return TimeToNum(SysTime);
}

bool SetFileTime(const string& szFile, int iTag)
{
HANDLE hFile = CreateFile(szFile.c_str(),
     GENERIC_READ,
     FILE_SHARE_READ|FILE_SHARE_WRITE,
     0,
     OPEN_EXISTING,
     0,0);
if (INVALID_HANDLE_VALUE == hFile)
  return false;

FILETIME FileTime;
SYSTEMTIME SysTime;
GetSystemTime(&SysTime);
SystemTimeToTzSpecificLocalTime(NULL, &SysTime, &SysTime);
SystemTimeToFileTime(&SysTime, &FileTime);

bool bResult = false;
switch(iTag)
{
case 0:
  bResult = SetFileTime(hFile, &FileTime, NULL, NULL);
  break;
case 1:
  bResult = SetFileTime(hFile, NULL, &FileTime, NULL);
  break;
case 2:
  bResult = SetFileTime(hFile, NULL, NULL, &FileTime);
  break;
case 3:
  bResult = SetFileTime(hFile, &FileTime, &FileTime, &FileTime);
  break;
}

CloseHandle(hFile);

return bResult;
}