// 判断文件是否存在

BOOL IsFileExist(const CString& csFile)

{

    DWORD dwAttrib = GetFileAttributes(csFile);

    return INVALID_FILE_ATTRIBUTES != dwAttrib &&  == (dwAttrib & FILE_ATTRIBUTE_DIRECTORY);

}

// 判断文件夹是否存在

BOOL IsDirExist(const CString & csDir)

{

    DWORD dwAttrib = GetFileAttributes(csDir);

    return INVALID_FILE_ATTRIBUTES != dwAttrib &&  != (dwAttrib & FILE_ATTRIBUTE_DIRECTORY);

}

// 判断文件或文件夹是否存在

BOOL IsPathExist(const CString & csPath)

{

    DWORD dwAttrib = GetFileAttributes(csPath);

    return INVALID_FILE_ATTRIBUTES != dwAttrib;

}

// 判断文件或文件夹是否存在

BOOL IsPathExistEx(const CString & csPath)

{

    WIN32_FILE_ATTRIBUTE_DATA attrs = {  };

    return  != GetFileAttributesEx(csPath, GetFileExInfoStandard, &attrs);

}

// 创建目录
BOOL CreateFolder(CString strPath)

{

    SECURITY_ATTRIBUTES attrib;

    attrib.bInheritHandle = FALSE;

    attrib.lpSecurityDescriptor = NULL;

    attrib.nLength = sizeof(SECURITY_ATTRIBUTES);

    return ::CreateDirectory(strPath, &attrib);

    //return ::CreateDirectory(strPath,NULL);

}


// 删除目录及子目录

BOOL DeleteDirectory(CString DirName)

{

    CString PUBPATH;

    PUBPATH = DirName;

    CFileFind tempFind;

    DirName += "\\*.*";

    BOOL IsFinded = (BOOL)tempFind.FindFile(DirName);

    while(IsFinded)

    {

        IsFinded = (BOOL)tempFind.FindNextFile();

        if(!tempFind.IsDots())

        {

            CString strDirName;

            strDirName += PUBPATH;

            strDirName += "\\";

            strDirName += tempFind.GetFileName();

            if(tempFind.IsDirectory())

            {

                DeleteDirectory(strDirName);

            }

            else

            {

                SetFileAttributes(strDirName, FILE_ATTRIBUTE_NORMAL); //去掉文件的系统和隐藏属性

                DeleteFile(strDirName);

            }

        }

    }

    tempFind.Close();

    if(!RemoveDirectory(PUBPATH))

    {

        return FALSE ;

    }

    return TRUE;

}

// 获取目录数
int GetDirNum(CString strPath)

{

    int nDirNum = ;

    CFileFind tempFind;

    BOOL bFound;

    bFound = tempFind.FindFile(strPath + _T("\\*.*"));

    while (bFound)

    {

        bFound = tempFind.FindNextFile();

        if(!tempFind.IsDots())

        {

            if(tempFind.IsDirectory())　　// 判断是否为文件夹

                nDirNum++;

        }

    }

    tempFind.Close();

    return nDirNum;

}    

// 文件末尾写入记录 （以时间为例）
void WriteRecord(time_t tm, CString strRecordFilePath)

{

    CTime ctm(tm);

    CString strTime = ctm.Format(_T("%Y-%m-%d %H_%M_%S"));

    CStdioFile stdioFile;

    if (stdioFile.Open(strRecordFilePath, CFile::modeWrite))

    {

        stdioFile.SeekToEnd();

        stdioFile.WriteString(strTime);

        stdioFile.Close();

    }

}


// 读取第一条记录

CString ReadRecord(CString strRecordFilePath)

{

    CString strFirstRecord = _T("");

    CStdioFile stdioFile;

    if (stdioFile.Open(strRecordFilePath, CFile::modeReadWrite))

    {

        stdioFile.SeekToBegin();

        stdioFile.ReadString(strFirstRecord);

        stdioFile.Close();

    }

    return strFirstRecord;

}


// 删除第一条记录

void DeleteRecord(CString strRecordFilePath)

{

    vector<CString> vecStr;

    CString strTemp;

    CStdioFile stdioFile;

    if (stdioFile.Open(strRecordFilePath, CFile::modeNoTruncate|CFile::modeRead))

    {

        stdioFile.ReadString(strTemp);

        while (stdioFile.ReadString(strTemp))

        {

            vecStr.push_back(strTemp);

        }

        stdioFile.Close();

        stdioFile.Open(strRecordFilePath, CFile::modeCreate|CFile::modeWrite);

        for (int i = ; i < (int)vecStr.size(); i++)

        {

            stdioFile.WriteString(vecStr[i]);

        }

        stdioFile.Close();

    }

}

//================================头文件===================================

#if !defined _CEFILEFIND_H_

#define _CEFILEFIND_H_

// CeFileFind.h : header file

#include <afxwin.h>

/////////////////////////////////////////////////////////////////////////////

// CCeFileFind window

class CCeFileFind : public CWnd

{

    // Construction

public:

    CCeFileFind( );

public:

    // Operations

    void Close();

    virtual BOOL FindNextFile( );

    virtual BOOL FindFile( LPCTSTR pstrName = NULL);

public:

    // Attributes

    //Gets the length of the found file, in bytes.

    DWORD GetLength() const;

    //Gets the name, including the extension, of the found file

    CString GetFileName() const;

    //Gets the whole path of the found file.

    CString GetFilePath() const;

    //Gets the whole path of the found file.

    CString GetRoot() const;

    // to get the time the specified file was created

    virtual BOOL GetCreationTime( FILETIME* pFileTime ) const;

    virtual BOOL GetCreationTime( CTime& refTime ) const;

    //Gets the time that the file was last accessed.

    virtual BOOL GetLastAccessTime( CTime& refTime ) const;

    virtual BOOL GetLastAccessTime( FILETIME* pFileTime ) const;

    //Gets the time the file was last changed and saved.

    virtual BOOL GetLastWriteTime( FILETIME* pFileTime ) const;

    virtual BOOL GetLastWriteTime( CTime& refTime ) const;

    //Indicates the desired file attributes of the file to be found.

    virtual BOOL MatchesMask( DWORD dwMask ) const;

    //Determines if the name of the found file has the name "." or "..",

    //indicating that is actually a directory.

    virtual BOOL IsDots( ) const;

    //Determines if the found file is read-only.

    BOOL IsReadOnly( ) const;

    //Determines if the found file is a directory.

    BOOL IsDirectory( ) const;

    //Determines if the found file is compressed.

    BOOL IsCompressed( ) const;

    //Determines if the found file is a system file.

    BOOL IsSystem( ) const;

    //Determines if the found file is hidden.

    BOOL IsHidden( ) const;

    //Determines if the found file is temporary.

    BOOL IsTemporary( ) const;

    //Determines if the found file is normal (in other words, has no other attributes).

    BOOL IsNormal( ) const;

    //Determines if the found file is archived.

    BOOL IsArchived( ) const;

    // Implementation

public:

    virtual ~CCeFileFind();

private:

    LPWIN32_FIND_DATA m_pfiledata;

    LPWIN32_FIND_DATA m_pNextdata;

    CString m_csRoot;

    HANDLE m_hFileHandle;

    char m_chDirSeparator;

    void AssertDoneNext() const;

};

#endif // !defined _CEFILEFIND_H_

//====================================源文件===============================

// CeFileFind.cpp : implementation file

//

#include "stdafx.h"

#include "CeFileFind.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

#define DELETE_POINTER(ptr) if( ptr != NULL ) \

{ \

    delete ptr; \

    ptr = NULL; \

}

#define DIR_SEPERATOR '\\'

/////////////////////////////////////////////////////////////////////////////

// CCeFileFind

CCeFileFind::CCeFileFind()

:m_hFileHandle(NULL), // initialize to NULL

m_pfiledata(NULL)

{

}

CCeFileFind::~CCeFileFind()

{

    Close();

}

// Operations

BOOL CCeFileFind::FindFile(LPCTSTR pstrName)

{

    //Close();

    // if NULL , wild card search

    if( NULL == pstrName )

    {

        m_csRoot = DIR_SEPERATOR;

        pstrName = _T("\\*.*");

    }

    else

    {

        m_csRoot = pstrName;

        int nPos = m_csRoot.ReverseFind( '\\' );

        if( nPos ==  )

            m_csRoot = '\\';

        else

            m_csRoot = m_csRoot.Left( nPos );

    }

    m_pNextdata = new WIN32_FIND_DATA;

    // search for file

    m_hFileHandle = FindFirstFile( pstrName, m_pNextdata );

    if ( m_hFileHandle == INVALID_HANDLE_VALUE )

    {

        Close();

        return FALSE;

    }

    // file was found

    return TRUE;

}

BOOL CCeFileFind::FindNextFile()

{

    ASSERT(m_hFileHandle != NULL);

    if (m_hFileHandle == NULL)

        return FALSE;

    if (m_pfiledata == NULL)

        m_pfiledata = new WIN32_FIND_DATA;

    AssertDoneNext();

    LPWIN32_FIND_DATA pTemp = m_pfiledata;

    m_pfiledata = m_pNextdata;

    m_pNextdata = pTemp;

    return ::FindNextFile(m_hFileHandle, m_pNextdata);

}

void CCeFileFind::Close()

{

    DELETE_POINTER( m_pfiledata );

    DELETE_POINTER( m_pNextdata );

    if( m_hFileHandle!= NULL && m_hFileHandle !=

        INVALID_HANDLE_VALUE )

    {

        ::FindClose( m_hFileHandle );

        m_hFileHandle = NULL;

    }

}

BOOL CCeFileFind::MatchesMask(DWORD dwMask) const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if ( m_pfiledata != NULL)

        return (!!(m_pfiledata->dwFileAttributes & dwMask) );

    else

        return FALSE;

}

CString CCeFileFind::GetRoot() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

        return m_csRoot;

    else

        return CString("");

}

BOOL CCeFileFind::GetLastAccessTime(FILETIME* pTimeStamp) const

{

    ASSERT(m_hFileHandle != NULL);

    ASSERT(pTimeStamp != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL && pTimeStamp != NULL)

    {

        *pTimeStamp = m_pfiledata -> ftLastAccessTime;

        return TRUE;

    }

    else

        return FALSE;

}

BOOL CCeFileFind::GetLastWriteTime(FILETIME* pTimeStamp) const

{

    ASSERT(m_hFileHandle != NULL);

    ASSERT(pTimeStamp != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL && pTimeStamp != NULL)

    {

        *pTimeStamp = m_pfiledata -> ftLastWriteTime;

        return TRUE;

    }

    else

        return FALSE;

}

BOOL CCeFileFind::GetCreationTime(FILETIME* pTimeStamp) const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL && pTimeStamp != NULL)

    {

        *pTimeStamp = m_pfiledata -> ftCreationTime;

        return TRUE;

    }

    else

        return FALSE;

}

BOOL CCeFileFind::GetLastAccessTime(CTime& refTime) const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        refTime = CTime( m_pfiledata -> ftLastAccessTime );

        return TRUE;

    }

    else

        return FALSE;

}

BOOL CCeFileFind::GetLastWriteTime(CTime& refTime) const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        refTime = CTime( m_pfiledata -> ftLastWriteTime );

        return TRUE;

    }

    else

        return FALSE;

}

BOOL CCeFileFind::GetCreationTime(CTime& refTime) const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        refTime = CTime( m_pfiledata -> ftCreationTime );

        return TRUE;

    }

    else

        return FALSE;

}

BOOL CCeFileFind::IsDots() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    // return TRUE if the file name is "." or ".." and

    // the file is a directory

    BOOL bResult = FALSE;

    if (m_pfiledata != NULL && IsDirectory())

    {

        LPWIN32_FIND_DATA pFindData = m_pfiledata;

        if (pFindData->cFileName[] == '.')

        {

            if (pFindData->cFileName[] == '\0' ||

                (pFindData->cFileName[] == '.' &&

                pFindData->cFileName[] == '\0'))

            {

                bResult = TRUE;

            }

        }

    }

    return bResult;

}

BOOL CCeFileFind::IsArchived( ) const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsCompressed() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes ==

            FILE_ATTRIBUTE_COMPRESSED )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsDirectory() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsHidden() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes & FILE_ATTRIBUTE_HIDDEN )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsNormal() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes & FILE_ATTRIBUTE_NORMAL )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsReadOnly() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes & FILE_ATTRIBUTE_READONLY )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsSystem() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes & FILE_ATTRIBUTE_SYSTEM )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

BOOL CCeFileFind::IsTemporary() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

    {

        if( m_pfiledata -> dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY )

            return TRUE;

        else

            return FALSE;

    }

    return FALSE;

}

CString CCeFileFind::GetFilePath() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    CString csResult = m_csRoot;

    if (csResult[csResult.GetLength()-] != DIR_SEPERATOR )

        csResult += DIR_SEPERATOR;

    csResult += GetFileName();

    return csResult;

}

CString CCeFileFind::GetFileName() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    CString ret;

    if (m_pfiledata != NULL)

        ret = m_pfiledata->cFileName;

    return ret;

}

DWORD CCeFileFind::GetLength() const

{

    ASSERT(m_hFileHandle != NULL);

    AssertDoneNext();

    if (m_pfiledata != NULL)

        return m_pfiledata -> nFileSizeLow;

    else

        return ;

}

void CCeFileFind::AssertDoneNext() const

{

    // if you trip the ASSERT in the else side, you've called

    // a Get() function without having done at least one

    // FindNextFile() call

    if (m_hFileHandle == NULL)

        ASSERT( m_pfiledata == NULL && m_pNextdata == NULL);

    else

        ASSERT( m_pfiledata != NULL && m_pNextdata != NULL);

}