Windows Practice_文件_文件分割器（三）

最新推荐文章于 2024-05-24 10:14:58 发布
最新推荐文章于 2024-05-24 10:14:58 发布
阅读量301 收藏
点赞数 1
分类专栏： Windows实训 文章标签： windows 敏捷开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011371629/article/details/78014687
版权

两种开发方式

  1. 瀑布式开发
    有需求 -> 分析 -> 建模 -> 编码 -> 维护 所有的类全部是自己设计编码的
  2. 敏捷开发
    需求 -> 编码 -> 重构（建模） -> 编码 需求总是变化的 -> 代码也需要变化
    所谓的敏捷开发就是拿着开源项目修改为自己的项目，随着时间的推移，改变的越来越多的内容，最后可能将原来开源项目中的所有内容都改为自己的内容。

当前类的性质，
类方法及类成员设计的时候
1. 方法及成员的时间和空间取舍
2. 类和类之间除了继承等之外，没有任何关系，每个类只负责把本类的业务逻辑处理好就可以了。

针对这些问题，将原来的文件分割少做了一些改进，其中包括CMyPartFile类的逻辑改进以及多线程的使用，多线程使得在处理大文件的时候，不会让界面卡死。
下面是代码，直接直接贴上去了：

//MySplitAndMerge.h文件
#pragma once
#include <vector>


class CMyPartFile : public CFile
{
public:
    enum eModal
    {
        MODAL_SPLIT,
        MODAL_MERGE
    };

private:
    typedef struct tagPartFileNameHeader
    {
        WORD wFlag;
        WCHAR wstrFirstFileName[MAX_PATH];
        WCHAR wstrNextFileName[MAX_PATH];
        UINT uOriginalFileSize;
    } PARTFILENAMEHEADER;


public:
    // 构造的时候只是负责打开或者创建一个文件，这个需要根据模式来定
    // 算了，还是不在构造函数中进行打开或者创建了，在构造函数中只做参数的配置
    // 如果是分割，那么就在保存的时候进行打开，写入
    // 如果是合并，就在获取数据的时候进行打开，读取
    CMyPartFile(const CString strFilePath, eModal modal);
    ~CMyPartFile();

    BOOL IsValidPartFile(BOOL bNeedClose);
    WCHAR *GetFirstFileName();
    WCHAR *GetNextFileName();
    UINT GetOriginalFileSize() const;

    BOOL SaveDataToFile(WORD wFlag, CString strFirstFileName, CString strNextFileName, UINT uOriginalFileSize, const BYTE *pByte);
    UINT GetDataFromFile(BYTE *pByte);

private:
    void CheckPartFileHeader(); // 这个函数有待于验证是否有必要存在
    BOOL MyOpenFile();


private:
    PARTFILENAMEHEADER m_partFileNameHeader;

    CString m_strFilePath;
    eModal m_modal;
    BOOL m_bInitPartFileHeader;
};

// 专门操作CMyPartFile类的类
class CMySplitAndMerge
{
public:
    /**
     * \brief 
     * \param strFolderName 待分割文件所在的文件夹名字
     * \param strFileName 待分割文件的名字
     * \param bSplitByFileSize 分割的类型：
     * \param uNumber 
     * \return 
     */
    BOOL Split(const CString strFolderName, const CString strFileName, BOOL bSplitByFileSize, UINT uNumber);
    BOOL Merge(const CString strFolderName, const CString strFileName, const CString strDestFileName);

private:
    BOOL MyOpenFile(CFile& file, const CString strFilePath, BOOL bRead) const;
    CString CreateDir(const CString strFileName);


    /**
     * \brief 根据分割文件的个数计算出分割文件的大小
     * \param strFilePath 待分割文件路径
     * \param uNumber 待分割文件个数
     * \return 如果返货0，表示计算失败，否则返回每个分割文件的大小
     */
    UINT CalcFileSize(const CString strFilePath, UINT uFileNumber) const;
    BOOL SplitFileByFileSize(const CString strFolderName, const CString strFilePath, UINT uFileSize) const;

    BOOL GetAllPartFile(const CString strFolderName, const CString strFileName);

private:
    std::vector<CMyPartFile *> m_vecMyPartFile;
};

#include "stdafx.h"
#include "MySplitAndMerge.h"

//MySplitAndMerge.cpp文件

CMyPartFile::CMyPartFile(const CString strFilePath, eModal modal) : CFile(), m_strFilePath(strFilePath), m_modal(modal), m_bInitPartFileHeader(FALSE)
{
}

CMyPartFile::~CMyPartFile()
{
}

BOOL CMyPartFile::IsValidPartFile(BOOL bNeedClose)
{
    CheckPartFileHeader();
    if (bNeedClose)
    {
        Close();
    }
    return m_partFileNameHeader.wFlag == MAKEWORD('P', 'o');
}

WCHAR* CMyPartFile::GetFirstFileName()
{
    return m_partFileNameHeader.wstrFirstFileName;
}

WCHAR* CMyPartFile::GetNextFileName()
{
    return m_partFileNameHeader.wstrNextFileName;
}

UINT CMyPartFile::GetOriginalFileSize() const
{
    return m_partFileNameHeader.uOriginalFileSize;
}

BOOL CMyPartFile::SaveDataToFile(WORD wFlag, CString strFirstFileName, CString strNextFileName, UINT uOriginalFileSize, const BYTE *pByte)
{
    m_partFileNameHeader.wFlag = wFlag;
    wcscpy_s(m_partFileNameHeader.wstrFirstFileName, strFirstFileName);
    wcscpy_s(m_partFileNameHeader.wstrNextFileName, strNextFileName);
    m_partFileNameHeader.uOriginalFileSize = uOriginalFileSize;

    BOOL bRet = TRUE;
    if (MyOpenFile())
    {
        Write(&m_partFileNameHeader, sizeof(PARTFILENAMEHEADER));
        Write(pByte, uOriginalFileSize);
        Close();
    }
    else
    {
        bRet = FALSE;
    }
    return bRet;
}

UINT CMyPartFile::GetDataFromFile(BYTE* pByte)
{
    UINT uReadByte = 0;

    if (m_partFileNameHeader.uOriginalFileSize == Read(pByte, m_partFileNameHeader.uOriginalFileSize))
    {
        uReadByte = m_partFileNameHeader.uOriginalFileSize;
    }
    Close();
    return uReadByte;
}

void CMyPartFile::CheckPartFileHeader()
{
    if (!m_bInitPartFileHeader)
    {
        MyOpenFile();
        if (Read(&m_partFileNameHeader, sizeof(PARTFILENAMEHEADER)) == sizeof(PARTFILENAMEHEADER))
        {
            m_bInitPartFileHeader = TRUE;
        }
    }
}

BOOL CMyPartFile::MyOpenFile()
{
    BOOL bRet = FALSE;
    WCHAR strErrorMessage[MAXBYTE] = { 0 };
    CFileException fileException;
    UINT nOpenFlags = CFile::typeBinary;
    if (MODAL_SPLIT == m_modal)
    {
        nOpenFlags |= (CFile::modeCreate | CFile::modeWrite);
    }
    else
    {
        nOpenFlags |= CFile::modeRead;
    }

    if (Open(m_strFilePath, nOpenFlags, &fileException))
    {
        bRet = TRUE;
    }
    else
    {
        fileException.GetErrorMessage(strErrorMessage, MAXBYTE);
        AfxMessageBox(strErrorMessage);
    }

    return bRet;
}

BOOL CMySplitAndMerge::Split(const CString strFolderName, const CString strFileName, BOOL bSplitByFileSize, UINT uNumber)
{
    BOOL bRet = FALSE;
    UINT uFileSize = uNumber;

    if (!bSplitByFileSize)
    {
        uFileSize = CalcFileSize(strFolderName + L"\\" + strFileName, uNumber);
    }

    if (uFileSize > 0)
    {
        // 开始分割文件
        CString strDirName;
        strDirName = CreateDir(strFileName);
        CreateDirectory(strFolderName + L"\\" + strDirName, nullptr);
        bRet = SplitFileByFileSize(strFolderName + L"\\" + strDirName, strFolderName + L"\\" + strFileName, uFileSize);
    }
    else
    {
        AfxMessageBox(TEXT("分割的文件大小不能为0"));
    }

    return bRet;
}

BOOL CMySplitAndMerge::Merge(const CString strFolderName, const CString strFileName, const CString strDestFileName)
{
    BOOL bRet = TRUE;

    if (GetAllPartFile(strFolderName, strFileName))
    {
        CFile file;
        if (MyOpenFile(file, strFolderName + L"\\" + strDestFileName, FALSE))
        {
            for (auto value : m_vecMyPartFile)
            {
                UINT uOriginalFileSize = value->GetOriginalFileSize();
                BYTE *pByte = new BYTE[uOriginalFileSize];
                memset(pByte, 0, uOriginalFileSize);
                UINT uReadFileLength = value->GetDataFromFile(pByte);
                if (uReadFileLength != uOriginalFileSize)
                {
                    bRet = FALSE;
                    break;
                }
                file.Write(pByte, uReadFileLength);
            }

            file.Close();

            m_vecMyPartFile.clear();
        }
    }

    return bRet;
}

BOOL CMySplitAndMerge::MyOpenFile(CFile& file, const CString strFilePath, BOOL bRead) const
{
    CFileException fileException;
    UINT nOpenFlags = CFile::typeBinary;
    if (bRead)
    {
        nOpenFlags |= CFile::modeRead;
    }
    else
    {
        nOpenFlags |= (CFile::modeCreate | CFile::modeWrite);
    }

    BOOL bRet = file.Open(strFilePath, nOpenFlags, &fileException);
    if (!bRet)
    {
        WCHAR strErrorMessage[MAXBYTE] = { 0 };
        fileException.GetErrorMessage(strErrorMessage, MAXBYTE);
        bRet = FALSE;
        AfxMessageBox(strErrorMessage);
    }

    return bRet;
}

CString CMySplitAndMerge::CreateDir(const CString strFileName)
{
    CString strDirName;
    for (int i = 0; i < strFileName.GetLength(); ++i)
    {
        if (strFileName.GetAt(i) != L'.')
        {
            strDirName += strFileName.GetAt(i);
        }
        else
        {
            break;
        }
    }

    return strDirName;
}

UINT CMySplitAndMerge::CalcFileSize(const CString strFilePath, UINT uFileNumber) const
{
    UINT uRet = 0;

    CFile file;
    if (MyOpenFile(file, strFilePath, TRUE))
    {
        uRet = static_cast<UINT>(file.GetLength() % uFileNumber ? file.GetLength() / uFileNumber + 1 : file.GetLength() / uFileNumber);
    }

    return uRet;
}

BOOL CMySplitAndMerge::SplitFileByFileSize(const CString strFolderName, const CString strFilePath, UINT uFileSize) const
{
    BOOL bRet = FALSE;
    BYTE *pByte = new BYTE[uFileSize];
    memset(pByte, 0, uFileSize);
    CFile file;
    if (MyOpenFile(file, strFilePath, TRUE))
    {
        ULONGLONG ullFileLength = file.GetLength();
        ULONGLONG ullReadLength = 0;
        UINT uReadByteNumber, uPartFileCount = 0;
        CString strFirstFileName = TEXT("0.part"), strCurFileName, strNextFileName;
        while (true)
        {
            uReadByteNumber = file.Read(pByte, uFileSize);
            ullReadLength += uReadByteNumber;

            strCurFileName.Format(L"%s\\%d.part", strFolderName.GetString(), uPartFileCount++);
            strNextFileName.Format(L"%d.part", uPartFileCount);

            if (ullReadLength >= ullFileLength)
            {
                strNextFileName = L"NULL";
                bRet = TRUE;
            }

            CMyPartFile myPartFile(strCurFileName, CMyPartFile::MODAL_SPLIT);
            myPartFile.SaveDataToFile(MAKEWORD('P', 'o'), strFirstFileName, strNextFileName, uReadByteNumber, pByte);

            if (bRet)
            {
                break;
            }
            memset(pByte, 0, uFileSize);
        }
    }

    return bRet;
}

BOOL CMySplitAndMerge::GetAllPartFile(const CString strFolderName, const CString strFileName)
{
    BOOL bRet = FALSE;

    CMyPartFile myPartFile(strFolderName + L"\\" + strFileName, CMyPartFile::MODAL_MERGE);
    if (myPartFile.IsValidPartFile(TRUE))
    {
        CString strCurFilePath, strNextFilePath = myPartFile.GetFirstFileName();
        while (true)
        {
            strCurFilePath = strFolderName + L"\\" + strNextFilePath;
            CMyPartFile *pFile = new CMyPartFile(strCurFilePath, CMyPartFile::MODAL_MERGE);
            if (pFile->IsValidPartFile(FALSE))
            {
                m_vecMyPartFile.push_back(pFile);
                strNextFilePath = pFile->GetNextFileName();
                if (strNextFilePath == L"NULL")
                {
                    bRet = TRUE;
                    break;
                }
                strCurFilePath = strFolderName + L"\\" + strNextFilePath;
            }
            else
            {
                break;
            }
        }
    }

    return bRet;
}
// FileSplitAndMergeDlg.h : 头文件
//

#pragma once


#define WM_MYINFO   (WM_USER + 100)

class CMySplitAndMerge;

// CFileSplitAndMergeDlg 对话框
class CFileSplitAndMergeDlg : public CDialogEx
{
// 构造
public:
    CFileSplitAndMergeDlg(CWnd* pParent = NULL);    // 标准构造函数

// 对话框数据
#ifdef AFX_DESIGN_TIME
    enum { IDD = IDD_FILESPLITANDMERGE_DIALOG };
#endif

    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持


// 实现
protected:
    HICON m_hIcon;

    // 生成的消息映射函数
    virtual BOOL OnInitDialog();
    afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
    afx_msg void OnPaint();
    afx_msg HCURSOR OnQueryDragIcon();
    DECLARE_MESSAGE_MAP()
public:
    CMySplitAndMerge *m_pMySplitAndMergeFile;


    afx_msg void OnBnClickedButtonSplit();
    afx_msg void OnBnClickedButtonMerge();

    afx_msg LRESULT OnMyInfo(WPARAM wParam, LPARAM lParam);


    static UINT ThreadFunc(LPVOID pParm);//线程函数的定义

    CString m_strFolderName;
    CString m_strFileName;
    CString m_strDestFileName;
    UINT m_uFileSize;
    BOOL m_bSplitByFileSize;
    BOOL m_bSplit;

    CWinThread *m_pThread;
};

// FileSplitAndMergeDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "FileSplitAndMerge.h"
#include "FileSplitAndMergeDlg.h"
#include "afxdialogex.h"


#include "MySplitAndMerge.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

class CAboutDlg : public CDialogEx
{
public:
    CAboutDlg();

// 对话框数据
#ifdef AFX_DESIGN_TIME
    enum { IDD = IDD_ABOUTBOX };
#endif

    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

// 实现
protected:
    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(IDD_ABOUTBOX)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()


// CFileSplitAndMergeDlg 对话框



CFileSplitAndMergeDlg::CFileSplitAndMergeDlg(CWnd* pParent /*=NULL*/)
    : CDialogEx(IDD_FILESPLITANDMERGE_DIALOG, pParent)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CFileSplitAndMergeDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CFileSplitAndMergeDlg, CDialogEx)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_BN_CLICKED(IDC_BUTTON_SPLIT, &CFileSplitAndMergeDlg::OnBnClickedButtonSplit)
    ON_BN_CLICKED(IDC_BUTTON_MERGE, &CFileSplitAndMergeDlg::OnBnClickedButtonMerge)
    ON_MESSAGE(WM_MYINFO, &CFileSplitAndMergeDlg::OnMyInfo)
END_MESSAGE_MAP()


// CFileSplitAndMergeDlg 消息处理程序

BOOL CFileSplitAndMergeDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    // 将“关于...”菜单项添加到系统菜单中。

    // IDM_ABOUTBOX 必须在系统命令范围内。
    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        BOOL bNameValid;
        CString strAboutMenu;
        bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
        ASSERT(bNameValid);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }

    // 设置此对话框的图标。  当应用程序主窗口不是对话框时，框架将自动
    //  执行此操作
    SetIcon(m_hIcon, TRUE);         // 设置大图标
    SetIcon(m_hIcon, FALSE);        // 设置小图标

    // TODO: 在此添加额外的初始化代码
    m_pMySplitAndMergeFile = new CMySplitAndMerge();

    return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CFileSplitAndMergeDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialogEx::OnSysCommand(nID, lParam);
    }
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。  对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CFileSplitAndMergeDlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // 用于绘制的设备上下文

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // 使图标在工作区矩形中居中
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // 绘制图标
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialogEx::OnPaint();
    }
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CFileSplitAndMergeDlg::OnQueryDragIcon()
{
    return static_cast<HCURSOR>(m_hIcon);
}



void CFileSplitAndMergeDlg::OnBnClickedButtonSplit()
{
    CFileDialog fileDlg(TRUE);
    if (fileDlg.DoModal() == IDOK)
    {
        m_bSplit = TRUE;
        m_bSplitByFileSize = TRUE;
        m_strFolderName = fileDlg.GetFolderPath();
        m_strFileName = fileDlg.GetFileName();
        m_uFileSize = 1024 * 1024 * 32;

        m_pThread = AfxBeginThread(ThreadFunc, this);

        if (m_pThread == nullptr)
        {
            AfxMessageBox(TEXT("线程函数启动失败！"));
        }
    }
}


void CFileSplitAndMergeDlg::OnBnClickedButtonMerge()
{
    CFileDialog fileDlg(TRUE);
    if (fileDlg.DoModal() == IDOK)
    {
        m_bSplit = FALSE;
        m_strFolderName = fileDlg.GetFolderPath();
        m_strFileName = fileDlg.GetFileName();
        m_strDestFileName = L"myFile.txt";

        m_pThread = AfxBeginThread(ThreadFunc, this);

        if (m_pThread == nullptr)
        {
            AfxMessageBox(TEXT("线程函数启动失败！"));
        }
    }
}

LRESULT CFileSplitAndMergeDlg::OnMyInfo(WPARAM wParam, LPARAM lParam)
{
    if (wParam == 0)
    {
        if (m_bSplit)
        {
            ((CButton *)GetDlgItem(IDC_BUTTON_SPLIT))->EnableWindow(FALSE);
        }
        else
        {
            ((CButton *)GetDlgItem(IDC_BUTTON_MERGE))->EnableWindow(FALSE);
        }
    }
    else
    {
        if (m_bSplit)
        {
            ((CButton *)GetDlgItem(IDC_BUTTON_SPLIT))->EnableWindow(TRUE);
        }
        else
        {
            ((CButton *)GetDlgItem(IDC_BUTTON_MERGE))->EnableWindow(TRUE);
        }
    }




    return 0;
}

UINT CFileSplitAndMergeDlg::ThreadFunc(LPVOID lParam)
{
    CFileSplitAndMergeDlg *pDlg = (CFileSplitAndMergeDlg *)lParam;

    if (pDlg->m_bSplit)
    {
        ::SendMessageW(pDlg->m_hWnd, WM_MYINFO, 0, 0);
        if (pDlg->m_pMySplitAndMergeFile->Split(pDlg->m_strFolderName, pDlg->m_strFileName, pDlg->m_bSplitByFileSize, pDlg->m_uFileSize))
        {
            AfxMessageBox(TEXT("分割完成"));
        }
        else
        {
            AfxMessageBox(TEXT("分割失败"));
        }
        ::SendMessageW(pDlg->m_hWnd, WM_MYINFO, 1, 0);
    }
    else
    {
        ::SendMessageW(pDlg->m_hWnd, WM_MYINFO, 0, 0);
        if (pDlg->m_pMySplitAndMergeFile->Merge(pDlg->m_strFolderName, pDlg->m_strFileName, pDlg->m_strDestFileName))
        {
            AfxMessageBox(TEXT("合并完成"));
        }
        else
        {
            AfxMessageBox(TEXT("合并失败"));
        }
        ::SendMessageW(pDlg->m_hWnd, WM_MYINFO, 1, 0);
    }

    return 0;
}
艺术人生666
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
windows 文件分割工具
11-07
对于很大的日志，记事本都打不开的时候，就需要有分割工具将他们分割成一小份一小份的，让记事本或者其他工具可以打开
windows 大文本文件分割器
07-12
windows 大文本文件分割器，用于对windows下超大文本文件进行分隔成多个文件，然后对小文件进行查看。
Windows Practice_文件_文件分割器（一）
艺术人生的专栏
09-17 534
文件分割的意义有以下几点需要进行文件分割： 以前的硬盘格式是FAT32，也是意味着最大的内存放的单个文件是4GB，如果文件超过4GB，就需要进行分割成小于4GB的文件才能存储到硬盘上； 网络虚度比较慢，并且还会出现中断，一旦中断，下载的文件就会失效。 我们在做分割时候，除了考虑分割外，还需要考虑合并，否则分割也就没有意义了。CFile函数注意事项CFile默认打开的是文本格式，这不符合文件风格的要求
适用于 Windows 7/8/10/11 的 6 款最佳免费分区软件
最新发布
Geeker55的博客
05-24 2005
分区软件程序旨在帮助您创建、缩小、删除、扩展、合并或拆分硬盘和其他存储设备的分区。虽然可以在 Windows 中对硬盘进行分区而无需使用其他软件，但您可以执行的活动范围有限。例如，如果没有外部工具，您无法调整分区大小或合并分区。在这篇文章中，我们将分享您可以使用的适用于 Windows 7 到 Windows 11的五款最佳免费磁盘分区软件。
Windows环境下文件分割器（XP平台测试）
jianchiwhb的专栏
05-14 975
<br />才学SDK时写的，粗糙难免，见者无怪！<br /> <br />/////////////FileCut.c<br />#include"FileCut.h"<br />#include"resource.h"<br /> <br />BOOL SelectFile(OPENFILENAME* ofn,int Mode)<br />{<br />       if(Mode==FILE_COM)<br />              ofn->Flags=OFN_ALLOWMULTISELECT
文件分离器（Windows系统环境下运行）
荧光百叶草的博客
08-03 751
文件分离器
practice_测试文件_源码
10-01
在“practice_测试文件_源码”这个压缩包中，我们收集了一系列的MATLAB源代码文件，用于测试和练习MATLAB的基本功能。这些文件对于初学者来说尤其有帮助，能够让他们更好地理解和掌握MATLAB编程的基础知识。以下是...
final_signal.zip_practice_signal filter
09-19
标题 "final_signal.zip_practice_signal filter" 暗示了我们正在处理一个关于信号过滤的实践项目，其中可能包含一个使用卡尔曼滤波器（Kalman Filter）的实现。卡尔曼滤波器是一种广泛应用在信号处理和估计理论中的...
Java_practice_answer.rar_java practi_java 习题_practice
09-23
本资源“Java_practice_answer.rar”包含了Java实践学习的相关资料，特别是针对Java编程习题的解答，是Java初学者和进阶者提升技能的理想资源。 文件“Java编程习题与解答（中文版）”很可能是一个文档，详细列举了...
CPP2019作业三_TheNovice_practice_
10-03
【标题】"CPP2019作业三_TheNovice_practice_" 暗示了这是一个针对初学者的C++编程练习集，可能是某个课程或训练营中的第三份作业，旨在帮助初学者巩固C++基础知识。 【描述】"The novice exercises of learning C ...
文件分割器 FileCut
05-13
很好用的文件分割工具哦，分割可以小至1K，大至若干G。 绿色无需安装，单个可执行文件，简单易用无毒。
VideoImgDemo_practice_视频截图_
10-01
本实践项目，"VideoImgDemo_practice_视频截图_"，聚焦于使用C语言实现视频截图功能，这对于理解底层图像处理和多媒体编程有着重要的学习价值。下面我们将深入探讨这个实践项目的相关知识点。 1. **C语言基础**：...
Windows Practice_文件_文件分割器（二）
艺术人生的专栏
09-17 353
文件分割器实现时注意的几点分割文件的头信息结构体的设计，如果里面需要存储字符串的信息，我们必须使用字符串数组来存储，而不能使用类似于CString、string等字符串对象来存储，因为使用这些对象在存储的时候还好，可以知道它的长度进行文件的写入，但是在读取的时候就会出现问题了，因为不知道读取多少。 解决方法有两个： 1. 在头文件信息结构体中加上构造函数和一些其它的辅助函数（这样就相当于类的功能
Windows Practice（八）_MFC
艺术人生的专栏
09-08 423
简单的Spy++实现从Spy++运行的效果来看，我们不难推测出，它是根据鼠标移动的位置来进行窗口的查找。那么是什么API呢？那就需要靠万能的谷歌和百度了。源码实现： 解决方案结构如下： 运行效果如下图： 主要代码如下：// Spy++DemoDlg.cpp : 实现文件 //#include "stdafx.h" #include "Spy++Demo.h" #include "Spy++
Windows项目实战开发
03-24
（一）Windows Practice_文件搜索器由于Windows自带的文件搜索的搜索速度比较慢，所以我们需要自己写一个文件搜索器来提高文件的扫描速度。文件搜索需要用到两个Windows API，一个是FindFirstFile，另一个是FindNextFile函数。 首先我们先来看一下这两个函数的原型：……
Windows下切分文件
热门推荐
BetterWorld的专栏
04-12 3万+
Windows下切分文件在linux下有split可以很方便的切分文件。windows下cmd未找到相关命令。当然，也可以安装GnuWin32，利用现成的split命令来进行切分。但是如者二者都没有呢，又暂时不想安装GnuWin32。作为一个程序员，信奉自己动手，丰衣足食。自己写一个切分文件的脚本或者软件吧。需求来源于自己一不小心，一个服务程序跑飞了生成了一个12G的日志，俺用ue打开之，卡了5分钟
Windows Practice_Dll&Hook_DetourHook库
艺术人生的专栏
10-03 686
DetoursDetours是经过微软认证的一个开源软件，下载地址，虽然是开源软件，但是它又分成了两个版本，分别是： Detours Professional 3.0 is available for commercial use. Detours Express 3.0 is available for immediate download under a no-fee license for r
在Practice_10_cifar100代码中添加SE注意力模块
05-29
好的，首先需要在代码中引入SE注意力模块所需的库和函数： ```python import tensorflow as tf def se_block(input_feature, ratio=8): """Squeeze-and-excitation block""" channel_axis = 1 if tf.keras....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值