CSDN博客

img xiangsl

一些工具函数

发表于2004/12/30 16:10:00  823人阅读

#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;
}

0 0

相关博文

我的热门文章

img
取 消
img即使是一小步
也想与你分享
打开
img