文件操作(Win32, C++)

已于 2024-03-01 22:15:27 修改
阅读量296 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： c++ windows Win32 文件操作
于 2023-05-22 17:57:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Flame_Cyclone/article/details/130812295

CFileUtils.h

#pragma once

#include <wtypesbase.h>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <tchar.h>

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

enum eFileAttributes
{
    eReadonly              = FILE_ATTRIBUTE_READONLY,
    eHidden                = FILE_ATTRIBUTE_HIDDEN,
    eSystem                = FILE_ATTRIBUTE_SYSTEM,
    eDirectory             = FILE_ATTRIBUTE_DIRECTORY,
    eArchive               = FILE_ATTRIBUTE_ARCHIVE,
    eDevice                = FILE_ATTRIBUTE_DEVICE,
    eNormal                = FILE_ATTRIBUTE_NORMAL,
    eTemporary             = FILE_ATTRIBUTE_TEMPORARY,
    eSparse_file           = FILE_ATTRIBUTE_SPARSE_FILE,
    eReparse_point         = FILE_ATTRIBUTE_REPARSE_POINT,
    eCompressed            = FILE_ATTRIBUTE_COMPRESSED,
    eOffline               = FILE_ATTRIBUTE_OFFLINE,
    eNot_content_indexed   = FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
    eEncrypted             = FILE_ATTRIBUTE_ENCRYPTED,
    eIntegrity_stream      = FILE_ATTRIBUTE_INTEGRITY_STREAM,
    eVirtual               = FILE_ATTRIBUTE_VIRTUAL,
    eNo_scrub_data         = FILE_ATTRIBUTE_NO_SCRUB_DATA,
    eEa                    = FILE_ATTRIBUTE_EA,
    ePinned                = FILE_ATTRIBUTE_PINNED,
    eUnpinned              = FILE_ATTRIBUTE_UNPINNED,
    eRecall_on_open        = FILE_ATTRIBUTE_RECALL_ON_OPEN,
    eRecall_on_data_access = FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS,
};

typedef struct _FILEINFO
{
    _tstring m_fileDir;
    _tstring m_fileName;
    _tstring m_filePath;
    unsigned long long m_fileSize;
    DWORD m_fileAttributes;
    unsigned long long m_ftCreationTime;
    unsigned long long m_ftLastAccessTime;
    unsigned long long m_ftLastWriteTime;

    _FILEINFO() :
        m_fileSize(0),
        m_fileAttributes(0),
        m_ftCreationTime(0),
        m_ftLastAccessTime(0),
        m_ftLastWriteTime(0)
    {

    };
}FILEINFO;

class CFileUtils
{
public:
    //
    // @brief: 获取文件扩展名
    // @param: strfileName     文件名, 如: test.exe
    // @param: bIncludeDot     是否包含 . 号
    // @ret: 扩展名            如 test.exe bIncludeDot = false 时返回 exe, bIncludeDot = true 时返回 .exe, 
    static _tstring GetFileExtName(
        const _tstring& strfileName,
        bool bIncludeDot = false
    );

    //
    // @brief: 获取目录下文件路径
    // @param: fileList     文件路径字符串容器
    // @param: strDir          指定目录
    // @param: extList      扩展名过滤列表, 如: {("exe"), ("txt")}
    // @param: depth        目录深度 如: 0：指定目录为根目录, 遍历0层子目录 
    // @param: bIgnoreCase  是否忽略扩展名过滤大小写
    // @ret: void
    static void GetFileList(
        std::vector<_tstring>& fileList,
        const _tstring& strDir,
        const std::vector<_tstring>& extList = {},
        int32_t depth = MAX_PATH,
        bool bIgnoreCase = true
    );

    //
    // @brief: 获取目录下文件路径
    // @param: fileList     文件路径字符串容器
    // @param: strDir          指定目录
    // @param: extList      扩展名过滤列表, 如: {("exe"), ("txt")}
    // @param: depth        目录深度 如: 0：指定目录为根目录, 遍历0层子目录 
    // @param: bIgnoreCase  是否忽略扩展名过滤大小写
    // @ret: void
    static void GetFileList(
        std::set<_tstring>& fileList,
        const _tstring& strDir,
        const std::vector<_tstring>& extList = {},
        int32_t depth = MAX_PATH,
        bool bIgnoreCase = true
    );

    //
    // @brief: 获取目录下文件路径
    // @param: fileList     文件信息容器
    // @param: strDir          指定目录
    // @param: extList      扩展名过滤列表, 如: {("exe"), ("txt")}
    // @param: depth        目录深度 如: 0：指定目录为根目录, 遍历0层子目录 
    // @param: bIgnoreCase  是否忽略扩展名过滤大小写
    // @ret: void
    static void GetFileList(
        std::map<_tstring, FILEINFO>& fileList,
        const _tstring& strDir,
        const std::vector<_tstring>& extList = {},
        int32_t depth = MAX_PATH,
        bool bIgnoreCase = true
    );

    //
    // @brief: 获取目录下子目录
    // @param: fileList     文件信息容器
    // @param: strDir          指定目录
    // @param: depth        目录深度 如: 0：指定目录为根目录, 遍历0层子目录 
    // @ret: void
    static void GetDirList(
        std::vector<_tstring>& fileList,
        const _tstring& strDir,
        int32_t depth = MAX_PATH
    );

    //
    // @brief: 获取目录下文件路径
    // @param: fileList     文件信息容器
    // @param: strDir          指定目录
    // @param: depth        目录深度 如: 0：指定目录为根目录, 遍历0层子目录 
    // @ret: void
    static void GetDirList(
        std::map<_tstring, FILEINFO>& dirList,
        const _tstring& strDir,
        int32_t depth = MAX_PATH
    );

    //
    // @brief: 检查路径是否存在
    // @param: strPath      路径
    // @ret: 存在返回true
    static bool IsExist(const _tstring& strPath);

    //
    // @brief: 检查路径是否隐藏
    // @param: strPath      路径
    // @ret: 隐藏返回true
    static bool IsHidden(const _tstring& strPath);

    //
    // @brief: 检查路径是否是存档
    // @param: strPath      路径
    // @ret: 存档返回true
    static bool IsArchive(const _tstring& strPath);

    //
    // @brief: 检查路径是否是只读
    // @param: strPath      路径
    // @ret: 只读返回true
    static bool IsReadOnly(const _tstring& strPath);

    //
    // @brief: 检查路径是否是目录
    // @param: strPath      路径
    // @ret: 目录返回true
    static bool IsDirectory(const _tstring& strPath);

    //
    // @brief: 获取路径属性
    // @param: strPath      路径
    // @ret: 成功返回true
    static bool GetAttributes(const _tstring& strPath, DWORD& dwAttr);

    //
    // @brief: 设置路径属性
    // @param: strPath      路径
    // @ret: 成功返回true
    static bool SetAttributes(const _tstring& strPath, const DWORD& dwAttr);

    //
    // @brief: 获取文件大小
    // @param: strPath      路径
    // @ret: 文件大小
    static unsigned long long GetFileSize(const _tstring& strPath);

    //
    // @brief: 删除文件
    // @param: strPath      路径
    // @ret: 成功返回true
    static bool DeleteArchive(const _tstring& strPath);

    //
    // @brief: 删除目录(递归删除子目录及文件)
    // @param: strPath      路径
    // @ret: 成功返回true
    static bool DeleteDir(const _tstring& strPath);

    //
    // @brief: 创建目录(递归)
    // @param: strPath      路径
    // @ret: 成功返回true
    static bool CreateDir(const _tstring& strPath);
};

class CFileHelper
{
public:
    static bool GetAttributes(const _tstring& strPath, DWORD& dwAttr);
    static bool SetAttributes(const _tstring& strPath, const DWORD& dwAttr);

public:
    CFileHelper();
    CFileHelper(const CFileHelper&) = delete;
    CFileHelper(const _tstring& strPath, bool bReadonly = false);
    ~CFileHelper();

    bool Open(const _tstring& strPath, bool bCreateIfNoExist = true, bool bReadonly = false);
    void Close();
    bool IsOpen() const;
    bool GetSize(unsigned long long& ullSize) const;
    bool GetAttributes(DWORD& dwAttr) const;
    bool SetAttributes(const DWORD& dwAttr) const;
    LONGLONG GetPointer() const;
    bool SetPointer(LONGLONG llPos = 0, DWORD dwFlag = FILE_CURRENT);
    bool Read(LPVOID lpBuffer, DWORD dwSize, LONGLONG llPos = 0, LPDWORD lpBytesRead = nullptr, DWORD dwFlag = FILE_CURRENT);
    bool Write(LPCVOID lpBuffer, DWORD dwSize, LONGLONG llPos = 0, LPDWORD lpBytesWritten = nullptr, DWORD dwFlag = FILE_CURRENT);
    bool Clear();
    bool SetEnd(LONGLONG llPos);

private:
    HANDLE m_hFile;
    _tstring m_strFile;
};

CFileUtils.cpp

#include "CFileUtils.h"
#include <io.h>

_tstring CFileUtils::GetFileExtName(const _tstring& strfileName, bool bIncludeDot/* = false*/)
{
    _tstring strExtName = strfileName;
    size_t nExtPos = strExtName.find_last_of(_T('.'));
    if (_tstring::npos == nExtPos)
    {
        return _T("");
    }

    if (bIncludeDot)
    {
        strExtName.erase(0, nExtPos);
    }
    else
    {
        strExtName.erase(0, nExtPos + 1);
    }

    return strExtName;
}

void CFileUtils::GetFileList(
    std::vector<_tstring>& fileList, 
    const _tstring& strDir, 
    const std::vector<_tstring>& extList /* = {} */, 
    int32_t depth /*  = MAX_PATH */,
    bool bIgnoreCase/* = true*/
)
{
    //到达深度限制返回
    if (depth < 0)
    {
        return;
    }

    WIN32_FIND_DATA findData = { 0 };
    HANDLE hFindHandle = INVALID_HANDLE_VALUE;
    hFindHandle = FindFirstFile((strDir + _T("\\*.*")).c_str(), &findData);
    if (INVALID_HANDLE_VALUE == hFindHandle)
    {
        return;
    }

    do
    {
        _tstring strName = findData.cFileName;

        //非目录
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            if (extList.empty())
            {
                fileList.emplace_back(strDir + _T("\\") + strName);
            }
            else
            {
                //获取扩展名
                _tstring strExtName = GetFileExtName(strName, false);

                //大小写比较区分
                if (bIgnoreCase)
                {
                    //进行扩展名过滤
                    for (auto& item : extList)
                    {
                        if (0 == _tcsicmp(item.c_str(), strExtName.c_str()))
                        {
                            fileList.emplace_back(strDir + _T("\\") + strName);
                        }
                    }
                }
                else
                {
                    //进行扩展名过滤
                    for (auto& item : extList)
                    {
                        if (item == strExtName)
                        {
                            fileList.emplace_back(strDir + _T("\\") + strName);
                        }
                    }
                }
            }
            continue;
        }

        //上一级目录与当前目录跳过
        if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
        {
            continue;
        }

        (void)GetFileList(fileList, strDir + _T("\\") + strName, extList, depth - 1);

    } while (::FindNextFile(hFindHandle, &findData));

    ::FindClose(hFindHandle);
}

void CFileUtils::GetFileList(
    std::set<_tstring>& fileList,
    const _tstring& strDir,
    const std::vector<_tstring>& extList/* = {}*/,
    int32_t depth/* = MAX_PATH*/,
    bool bIgnoreCase/* = true*/
)
{
    //到达深度限制返回
    if (depth < 0)
    {
        return;
    }

    WIN32_FIND_DATA findData = { 0 };
    HANDLE hFindHandle = INVALID_HANDLE_VALUE;
    hFindHandle = FindFirstFile((strDir + _T("\\*.*")).c_str(), &findData);
    if (INVALID_HANDLE_VALUE == hFindHandle)
    {
        return;
    }

    do
    {
        _tstring strName = findData.cFileName;

        //非目录
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            if (extList.empty())
            {
                fileList.insert(strDir + _T("\\") + strName);
            }
            else
            {
                //获取扩展名
                _tstring strExtName = GetFileExtName(strName, false);

                //大小写比较区分
                if (bIgnoreCase)
                {
                    //进行扩展名过滤
                    for (auto& item : extList)
                    {
                        if (0 == _tcsicmp(item.c_str(), strExtName.c_str()))
                        {
                            fileList.insert(strDir + _T("\\") + strName);
                        }
                    }
                }
                else
                {
                    //进行扩展名过滤
                    for (auto& item : extList)
                    {
                        if (item == strExtName)
                        {
                            fileList.insert(strDir + _T("\\") + strName);
                        }
                    }
                }
            }
            continue;
        }

        //上一级目录与当前目录跳过
        if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
        {
            continue;
        }

        (void)GetFileList(fileList, strDir + _T("\\") + strName, extList, depth - 1);

    } while (::FindNextFile(hFindHandle, &findData));

    ::FindClose(hFindHandle);
}

void CFileUtils::GetFileList(
    std::map<_tstring, FILEINFO>& fileList,
    const _tstring& dir,
    const std::vector<_tstring>& extList /* = {} */,
    int32_t depth /*  = MAX_PATH */,
    bool bIgnoreCase/* = true*/
)
{
    //到达深度限制返回
    if (depth < 0)
    {
        return;
    }

    WIN32_FIND_DATA findData = { 0 };
    HANDLE hFindHandle = INVALID_HANDLE_VALUE;
    hFindHandle = FindFirstFile((dir + _T("\\*.*")).c_str(), &findData);
    if (INVALID_HANDLE_VALUE == hFindHandle)
    {
        return;
    }

    do
    {
        _tstring strName = findData.cFileName;

        //非目录
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            FILEINFO info;
            info.m_fileName = findData.cFileName;
            info.m_fileSize = (unsigned long long)findData.nFileSizeHigh << 32 | findData.nFileSizeLow;
            info.m_fileDir = dir;
            info.m_filePath = dir + _T("\\") + strName;
            info.m_ftCreationTime = *(size_t*)&findData.ftCreationTime;
            info.m_ftLastAccessTime = *(size_t*)&findData.ftLastAccessTime;
            info.m_ftLastWriteTime = *(size_t*)&findData.ftLastWriteTime;
            info.m_fileAttributes = findData.dwFileAttributes;

            info.m_ftCreationTime = (info.m_ftCreationTime - 116444736000000000) / 10000000;
            info.m_ftLastAccessTime = (info.m_ftLastAccessTime - 116444736000000000) / 10000000;
            info.m_ftLastWriteTime = (info.m_ftLastWriteTime - 116444736000000000) / 10000000;

            if (extList.empty())
            {
                fileList.insert(std::make_pair(dir + _T("\\") + strName, info));
            }
            else
            {
                //获取扩展名
                _tstring strExtName = GetFileExtName(strName, false);

                //大小写比较区分
                if (bIgnoreCase)
                {
                    //进行扩展名过滤
                    for (const auto& item : extList)
                    {
                        if (0 == _tcsicmp(item.c_str(), strExtName.c_str()))
                        {
                            fileList.insert(std::make_pair(dir + _T("\\") + strName, info));
                        }
                    }
                }
                else
                {
                    //进行扩展名过滤
                    for (const auto& item : extList)
                    {
                        if (item == strExtName)
                        {
                            fileList.insert(std::make_pair(dir + _T("\\") + strName, info));
                        }
                    }
                }
            }
            continue;
        }

        //上一级目录与当前目录跳过
        if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
        {
            continue;
        }

        (void)GetFileList(fileList, dir + _T("\\") + strName, extList, depth - 1);

    } while (::FindNextFile(hFindHandle, &findData));

    ::FindClose(hFindHandle);
}

void CFileUtils::GetDirList(
    std::vector<_tstring>& fileList,
    const _tstring& strDir,
    int32_t depth/* = MAX_PATH*/
)
{
    //到达深度限制返回
    if (depth < 0)
    {
        return;
    }

    WIN32_FIND_DATA findData = { 0 };
    HANDLE hFindHandle = INVALID_HANDLE_VALUE;
    hFindHandle = FindFirstFile((strDir + _T("\\*.*")).c_str(), &findData);
    if (INVALID_HANDLE_VALUE == hFindHandle)
    {
        return;
    }

    do
    {
        _tstring strName = findData.cFileName;

        //上一级目录与当前目录跳过
        if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
        {
            continue;
        }

        //非目录
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            continue;
        }

        fileList.emplace_back(strDir + _T("\\") + strName);
        (void)GetDirList(fileList, strDir + _T("\\") + strName, depth - 1);

    } while (::FindNextFile(hFindHandle, &findData));

    ::FindClose(hFindHandle);
}

void CFileUtils::GetDirList(
    std::map<_tstring, FILEINFO>& dirList,
    const _tstring& strDir,
    int32_t depth/* = MAX_PATH*/
)
{
    //到达深度限制返回
    if (depth < 0)
    {
        return;
    }

    WIN32_FIND_DATA findData = { 0 };
    HANDLE hFindHandle = INVALID_HANDLE_VALUE;
    hFindHandle = FindFirstFile((strDir + _T("\\*.*")).c_str(), &findData);
    if (INVALID_HANDLE_VALUE == hFindHandle)
    {
        return;
    }

    do
    {
        _tstring strName = findData.cFileName;

        //上一级目录与当前目录跳过
        if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
        {
            continue;
        }

        //非目录
        if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            continue;
        }

        FILEINFO info;
        info.m_fileName = findData.cFileName;
        info.m_fileSize = (unsigned long long)findData.nFileSizeHigh << 32 | findData.nFileSizeLow;
        info.m_fileDir = strDir;
        info.m_filePath = strDir + _T("\\") + strName;
        info.m_ftCreationTime = *(size_t*)&findData.ftCreationTime;
        info.m_ftLastAccessTime = *(size_t*)&findData.ftLastAccessTime;
        info.m_ftLastWriteTime = *(size_t*)&findData.ftLastWriteTime;
        info.m_fileAttributes = findData.dwFileAttributes;

        info.m_ftCreationTime = (info.m_ftCreationTime - 116444736000000000) / 10000000;
        info.m_ftLastAccessTime = (info.m_ftLastAccessTime - 116444736000000000) / 10000000;
        info.m_ftLastWriteTime = (info.m_ftLastWriteTime - 116444736000000000) / 10000000;

        dirList.insert(std::make_pair(strDir + _T("\\") + strName, info));
        (void)GetDirList(dirList, strDir + _T("\\") + strName, depth - 1);

    } while (::FindNextFile(hFindHandle, &findData));

    ::FindClose(hFindHandle);
}

bool CFileUtils::IsExist(const _tstring& strPath)
{
    return 0 == _taccess_s(strPath.c_str(), 00);
}

bool CFileUtils::IsHidden(const _tstring& strPath)
{
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return false;
    }

    return attr.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN;
}

bool CFileUtils::IsArchive(const _tstring& strPath)
{
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return false;
    }

    return attr.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE;
}

bool CFileUtils::IsReadOnly(const _tstring& strPath)
{
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return false;
    }

    return attr.dwFileAttributes & FILE_ATTRIBUTE_READONLY;
}

bool CFileUtils::IsDirectory(const _tstring& strPath)
{
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return false;
    }

    return attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
}

bool CFileUtils::GetAttributes(const _tstring& strPath, DWORD& dwAttr)
{
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return false;
    }

    dwAttr = attr.dwFileAttributes;
    return true;
}

bool CFileUtils::SetAttributes(const _tstring& strPath, const DWORD& dwAttr)
{
    return ::SetFileAttributes(strPath.c_str(), dwAttr);
}

unsigned long long CFileUtils::GetFileSize(const _tstring& strPath)
{
    unsigned long long ullSize = 0;
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return 0;
    }

    ullSize = (unsigned long long)attr.nFileSizeHigh << 32 | attr.nFileSizeLow;

    return ullSize;
}

bool CFileUtils::DeleteArchive(const _tstring& strPath)
{
    bool bSuccess = false;

    if (strPath.empty())
    {
        return false;
    }

    bSuccess = ::DeleteFile(strPath.c_str());

    if (!bSuccess && ERROR_FILE_NOT_FOUND == ::GetLastError())
    {
        bSuccess = true;
    }

    return bSuccess;
}

bool CFileUtils::DeleteDir(const _tstring& strDir)
{
    WIN32_FIND_DATA findData = { 0 };
    HANDLE hFindHandle = INVALID_HANDLE_VALUE;

    if (strDir.empty())
    {
        return false;
    }

    hFindHandle = FindFirstFile((strDir + _T("\\*.*")).c_str(), &findData);
    if (INVALID_HANDLE_VALUE == hFindHandle)
    {
        return false;
    }

    do
    {
        _tstring strFilePath = strDir + _T("\\") + findData.cFileName;

        //上一级目录与当前目录跳过
        if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
        {
            continue;
        }

        if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) //删除目录
        {
            DeleteDir(strFilePath);
            continue;
        }
        else    //删除文件
        {
            ::DeleteFile(strFilePath.c_str());
        }

    } while (::FindNextFile(hFindHandle, &findData));
    ::FindClose(hFindHandle);

    return ::RemoveDirectory(strDir.c_str());
}

bool CFileUtils::CreateDir(const _tstring& strPath)
{
    _tstring strDriver;              //驱动器号, 如 D:
    _tstring strSubPath = strPath;   //路径, 如 Test\1\2\3

    if (strPath.empty())
    {
        return false;
    }

    //获取盘符
    do
    {
        size_t nFindIndex = strPath.find_first_of(':');  //检查是否有驱动器号
        if (nFindIndex == _tstring::npos)
        {
            break;
        }

        strDriver = strPath.substr(0, nFindIndex + 1); //得到驱动器号, 如 D:
        nFindIndex = strPath.find(_T("\\"), nFindIndex);
        if (nFindIndex == _tstring::npos)
        {
            break;
        }

        strSubPath = strPath.substr(nFindIndex + 1); //得到路径, 如 Test\1\2\3
    } while (false);

    _tstring strDestDir;
    size_t nFindBegin = 0;
    size_t nFindIndex = 0;
    do
    {
        nFindIndex = strSubPath.find(_T("\\"), nFindBegin);
        if (nFindIndex != _tstring::npos)
        {
            strDestDir = strSubPath.substr(0, nFindIndex);
            nFindBegin = nFindIndex + 1;
        }
        else
        {
            strDestDir = strSubPath;
        }

        if (!strDriver.empty())
        {
            strDestDir = strDriver + _T("\\") + strDestDir;
        }

        if (!::CreateDirectory(strDestDir.c_str(), NULL) && ERROR_ALREADY_EXISTS != ::GetLastError())
        {
            return false;
        }

    }while (nFindIndex != _tstring::npos);

    return true;
}

CFileHelper::CFileHelper()
    :
    m_hFile(INVALID_HANDLE_VALUE)
{

}

CFileHelper::CFileHelper(const _tstring& strPath, bool bReadonly/* = false*/)
{
    Open(strPath, true, bReadonly);
}

CFileHelper::~CFileHelper()
{
    Close();
}

bool CFileHelper::IsOpen() const
{
    return INVALID_HANDLE_VALUE != m_hFile;
}

bool CFileHelper::GetSize(unsigned long long& ullSize) const
{
    if (!IsOpen())
    {
        return false;
    }

    LARGE_INTEGER ullFileSize = { 0 };
    if (!::GetFileSizeEx(m_hFile, &ullFileSize))
    {
        return false;
    }

    ullSize = ullFileSize.QuadPart;
    return true;
}

bool CFileHelper::GetAttributes(const _tstring& strPath, DWORD& dwAttr)
{
    WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    {
        return false;
    }

    dwAttr = attr.dwFileAttributes;
    return true;
}

bool CFileHelper::SetAttributes(const _tstring& strPath, const DWORD& dwAttr)
{
    return ::SetFileAttributes(strPath.c_str(), dwAttr);
}

bool CFileHelper::GetAttributes(DWORD& dwAttr) const
{
    if (!IsOpen())
    {
        return false;
    }

    return GetAttributes(m_strFile, dwAttr);
}

bool CFileHelper::SetAttributes(const DWORD& dwAttr) const
{
    if (!IsOpen())
    {
        return false;
    }

    return SetAttributes(m_strFile, dwAttr);
}

bool CFileHelper::Open(const _tstring& strPath, bool bCreateIfNoExist/* = false*/, bool bReadonly/* = false*/)
{
    if (strPath.empty())
    {
        return false;
    }

    //不重复打开相同文件
    if (m_strFile == strPath && IsOpen())
    {
        return true;
    }

    //关闭文件, 如果已经打开
    Close();

    m_strFile = strPath;
    DWORD dwOpenFlag = GENERIC_READ;
    if (!bReadonly)
    {
        dwOpenFlag |= GENERIC_WRITE;
    }

    m_hFile = CreateFile(m_strFile.c_str(),
        dwOpenFlag,
        FILE_SHARE_READ,
        NULL,
        bCreateIfNoExist ? OPEN_ALWAYS : OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL);

    if (INVALID_HANDLE_VALUE == m_hFile)
    {
        return false;
    }

    return true;
}

void CFileHelper::Close()
{
    if (INVALID_HANDLE_VALUE != m_hFile)
    {
        ::CloseHandle(m_hFile);
        m_hFile = INVALID_HANDLE_VALUE;
    }
}

LONGLONG CFileHelper::GetPointer() const
{
    LARGE_INTEGER  liDistanceToMove = { 0 };
    LARGE_INTEGER  liNewFilePointer = { 0 };
    ::SetFilePointerEx(m_hFile, liDistanceToMove, &liNewFilePointer, FILE_CURRENT);

    return liNewFilePointer.QuadPart;
}

bool CFileHelper::SetPointer(LONGLONG llPos/* = 0*/, DWORD dwFlag/* = FILE_CURRENT*/)
{
    LARGE_INTEGER  liDistanceToMove = { 0 };

    if (!IsOpen())
    {
        return false;
    }

    liDistanceToMove.QuadPart = llPos;
    return ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, dwFlag);
}

bool CFileHelper::Read(LPVOID lpBuffer, DWORD dwSize, LONGLONG llPos/* = 0*/, LPDWORD lpBytesRead/* = nullptr*/, DWORD dwFlag/* = FILE_CURRENT*/)
{
    if (!IsOpen() || nullptr == lpBuffer)
    {
        return false;
    }

    LARGE_INTEGER  liDistanceToMove = { 0 };
    BOOL bResult = FALSE;
    liDistanceToMove.QuadPart = llPos;
    ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, dwFlag);
    DWORD dwBytesRead = 0;

    bResult = ::ReadFile(m_hFile, lpBuffer, dwSize, &dwBytesRead, NULL);
    if (nullptr != lpBytesRead)
    {
        *lpBytesRead = dwBytesRead;
    }

    return bResult;
}

bool CFileHelper::Write(LPCVOID lpBuffer, DWORD dwSize, LONGLONG llPos/* = 0*/, LPDWORD lpBytesWritten/* = nullptr*/, DWORD dwFlag/* = FILE_CURRENT*/)
{
    if (!IsOpen() || nullptr == lpBuffer)
    {
        return false;
    }

    LARGE_INTEGER  liDistanceToMove = { 0 };
    BOOL bResult = FALSE;
    liDistanceToMove.QuadPart = llPos;
    ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, dwFlag);

    DWORD dwBytesWritten = 0;
    bResult = ::WriteFile(m_hFile, lpBuffer, dwSize, &dwBytesWritten, NULL);

    if (nullptr != lpBytesWritten)
    {
        *lpBytesWritten = dwBytesWritten;
    }

    return bResult;
}

bool CFileHelper::Clear()
{
    if (!IsOpen())
    {
        return false;
    }

    LARGE_INTEGER  liDistanceToMove = { 0 };
    ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, FILE_BEGIN);
    return ::SetEndOfFile(m_hFile);
}

bool CFileHelper::SetEnd(LONGLONG llPos)
{
    if (!IsOpen())
    {
        return false;
    }

    LARGE_INTEGER  liDistanceToMove = { 0 };
    liDistanceToMove.QuadPart = llPos;
    ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, FILE_BEGIN);
    return ::SetEndOfFile(m_hFile);
}

 

 

Flame_Cyclone
关注
win32(7)--文件操作
pyx的学习笔记
06-18 2575
一、创建/打开文件、读文件、写文件及文件大小获取和文件偏移：CreateFile、ReadFile、WriteFile、GetFileSize、SetFilePointer。 CreateFile:创建/打开文件 HANDLE WINAPI CreateFile( //返回值是句柄，错误返回INVALID_HANDLE_VALUE(-1) _In_ LPCWSTR lpFil
[Win32] 文件系统操作
zuishikonghuan的博客
07-20 4272
上一节讲了文件同步读写，这次就说说文件系统的操作。 文件系统，简单理解一下，因为磁盘上数据有他的存储方式，而应用程序如果对每种磁盘格式都有了解的话，无疑太难实现，而且兼容性也无法保证，因此，操作系统就将具体的磁盘格式虚拟成（抽象成）一个文件系统，应用程序只需对文件系统操作，磁盘设备驱动程序会把对文件系统的操作转化为对磁盘扇区的操作，这就是文件系统。 一。枚举子目录/枚举文件 依靠三个
WIN32核心编程 - 文件系统 - 文件操作 - 目录操作
最新发布
0xCC说逆向
07-08 1153
层次结构（Hierarchy）：文件系统中文件和目录之间的组织关系形成了层次结构，通常是树状结构，其中根目录是顶层目录，包含其他目录和文件，而子目录可以包含更多的子目录和文件。文件可以是文本文件、图像文件、音频文件、视频文件等，每个文件都有一个唯一的文件名。目录可以包含文件和其他目录，形成文件系统的层次结构。文件内容的读取和写入可以通过标准C++库中的fstream类或Windows API的。：表示文件是系统文件，这通常表示操作系统用于内部用途的文件。针对一个打开的文件，将当前文件位置设为文件末尾。
Win32文件操作
csdn_gddf102384398的博客
10-24 1025
①打开文件的示例代码： HANDLE hSrcFile = CreateFile(TEXT(&amp;quot;main.cpp&amp;quot;), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hSrcFile==INVALID_HANDLE_VALUE) { printf(&amp;quot;打开文件失败\n&amp;quot;
采用win32函数对文件的基本操作
mmdev
12-14 200
写了个win32函数对文件操作的程序，这里记录一下。 FileHandle.h #pragma once #define MAX_RECORD 100 typedef struct _PhoneRecord { char id[4]; // id char name[16]; // name char phoneNumber[20]; // 电话号码 un...
win32常用文件操作
weixin_30668887的博客
08-08 138
读写ini： char BkIsEncrypt[50] = {0}; GetPrivateProfileString("TaskSetting", "IsEncrypt", "", BkIsEncrypt, 10, "c:\\a.txt"); WritePrivateProfileString("TaskSetting", "IsEncrypt", "Y", pIniFil...
Win32学习笔记 - 文件操作
Vinx Blog
03-28 648
1、获取驱动器盘符和类型1.1 获取本机存在的驱动器DWORD GetLogicalDrives(VOID);该函数的返回值是一个无符号的32位整数，每一位代表一个驱动器，Bit 0代表驱动器A, Bit 1代表驱动器B, Bit 2代表驱动器C，依次类推。如果该位为1，表示该驱动器存在，否则不存在。1.2 获取系统盘的盘符DWORD GetLogicalDriveStrings( DWORD nB
win32 C++ kafka 库
01-22
标题"win32 C++ kafka 库"指的是一个专门为32位Windows操作系统编译的C++库，用于与Apache Kafka进行通信。这个库提供了C++接口，使得开发者能够方便地在C++项目中集成Kafka功能，进行生产者和消费者操作，例如发布...
kuangjia.zip_梦幻西游_纯win32 c++
09-24
《梦幻西游》是一款深受玩家喜爱的网络游戏，而“kuangjia.zip”这个压缩包则包含了一位...这将涵盖文件操作、窗口创建、事件处理、图形绘制等多个方面，有助于深化对编程基础的理解，并为更复杂的项目打下坚实基础。
WIN32编程的C++例子源码.rar_WIN32编程的C++例子源码_win32 开发 下载_win32 源码
09-23
【描述】中的信息表明，这些源代码是作者在平时练习过程中编写的，这意味着它们可能包含了各种基础到进阶的WIN32 API用法，涵盖了窗口创建、消息处理、图形绘制、文件操作等多个方面。通过分析和运行这些代码，...
win32 c++ 连连看
05-01
首先，`win32 c++ 连连看`这个标题暗示了我们的编程语言是C++，而使用的平台是Windows操作系统。Win32 API是微软提供的编程接口，用于构建原生Windows应用程序。C++是一种强大的、通用的编程语言，特别适合开发底层...
WIN32程序的C++编程
04-18
Win32 API提供了丰富的函数和结构，用于窗口管理、消息处理、内存管理、文件操作等。在C++中使用Win32 API，我们需要理解窗口过程（Window Procedure）、消息队列和消息循环等核心概念。窗口过程是处理窗口消息的...
WIN32常用API—文件相关操作API（删除指定文件，复制文件，新建/打开文件，移动文件，读取文件，写入文件内容，获取文件大小，创建目录，获取文件或目录的属性、设置文件属性）
m0_62783065的博客
11-11 1301
WIN32常用API—文件相关操作API（删除指定文件，复制文件，新建/打开文件，移动文件，读取文件，写入文件内容，获取文件大小，创建目录，获取文件或目录的属性、设置文件属性）
win32配置文件相关操作
weixin_42452990的博客
09-10 849
在我们的程序设计中经常需要对一些参数进行配置，配置好后还要在下一次启动仍然有效，那么一个有效的可行办法就是使用ini文件，也就是Windows初始化文件来保存一些我们的设置，然后让程序启动的时候从这个ini文件中读取相关配置。我们需要做以下的工作。 1.创建此ini文件，Windows对ini文件的操作有专门的函数，我们经常用的就是WritePrivateProfileString(...
Win32中文件的操作
weixin_30663391的博客
07-27 847
1 文件的创建或打开 　　HANDLE CreateFile(LPCTSTR lpFileName,　　　　　　　　　　　　　　　　//文件路径和名称 　　　　　　　　　　　　DWORD dwDesiredAccess, 　　　　　　　　　　　 //访问方式，最常用的值是GENERIC_READ，GENERIC_WRITE或两　　　　　　　　　个:GENERIC_READ|GE...
win32核心编程00：文件操作
坚持硬核
05-23 715
目录 0x00.文件基本操作 0x01写入： 0x02获取文件大小： 0x03设置文件内容指针： 0x04拷贝文件： 0x05移动文件： 0x06关闭文件句柄： 0x07.文件夹操作 windows操作系统的文件系统：每个文件夹下都有两个默认隐藏的文件夹： 0x08实现文件夹遍历： 0x09.文件映射 0x00.文件基本操作 C文件操作：FILE* fopen f...
WIN32开发之ini文件操作
金属服务，美好生活，天网改变世界，华帝量子科技。
07-29 428
1、写入ini文件 CString strCount = "123456789";//写入参数 TCHAR exeFullPath[MAX_PATH]; // Full path GetModuleFileName(NULL, exeFullPath, MAX_PATH); std::wstring strFullPath = (std::wstring)(exeFullPath); int nStart = strFullPath.find_last_of(TEXT("
文件操作总结
AAAA202012的博客
07-12 951
文章目录前言文件操作—C语言文件操作—C++文件操作—WIN32 前言 最近因为用到了文件操作相关内容，所以趁着机会总结一下。这里主要介绍三种文件操作的方法，分别是C语言、C++以及WIN32里的文件操作方法。 所谓"文件"，一般指存储在外部介质上数据的几何，一般数据都是以文件的形式存放在外部介质上的，而我们的操作系统是以文件为单位对数据进行管理的。 对文件进行分类，依据不同，分出的类别也不同。按介质可将文件分为：磁盘文件、光盘文件、U盘文件；按用途可将文件分为：程序文件(program file)、数.
如何在Win32下操作大于2G的文件
长剑一挥的博客
08-31 1686
最近帮导师写一个点云播放器，需要读取5个左右的文本文档。主要想到了有两种方法来解决这个问题：一是将文件一次性读取到内存中，这种方法比较省事，但是读取过程时间太长，无法忍受；第二种方法就是逐帧读取的方式，这种方式若想实现任意帧的访问，则必须知道文件指针在文件中的位置。 当文件小于2G时，使用fseek和ftell可以获取文件的大小。当文件大于4G时，使用_fseeki64和_ftelli64，如果
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值