精华内容
下载资源
问答
  • 6-3 使用函数实现字符串部分复制 (15 分) (PTA练习题) 题干: ** 本题要求实现一个在数组中查找指定元素的简单函数。 函数接口定义: int search( int list[], int n, int x ); 其中list[]是用户传入的数组;n(≥0...

    **

    6-3 使用函数实现字符串部分复制 (15 分) (PTA练习题)

    题干:

    **
    本题要求实现一个在数组中查找指定元素的简单函数。
    函数接口定义:

    int search( int list[], int n, int x );

    其中list[]是用户传入的数组;n(≥0)是list[]中元素的个数;x是待查找的元素。如果找到

    则函数search返回相应元素的最小下标(下标从0开始),否则返回−1。

    - 程序主文件

    #include <stdio.h>
    #define MAXN 10
    
    int search( int list[], int n, int x );
    
    int main()
    {
        int i, index, n, x;
        int a[MAXN];
    
        scanf("%d", &n);
        for( i = 0; i < n; i++ )
            scanf("%d", &a[i]);
        scanf("%d", &x);
        index = search( a, n, x );
        if( index != -1 )
            printf("index = %d\n", index);
        else
            printf("Not found\n");
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */
    
    • 以下为需要自己写的函数部分:
     int search( int a[], int n, int x )
    {
     int i,count=0; 
     if(n==0) return -1;
    for(i=0;i<n;i++) 
        { if(a[i]==x) 
            { 
            count+=1;
             return i;
             } 
        } 
        if(count==0)
            return -1;
     }
    

    **

    over

    **

    展开全文
  • 封装CopyFileEx函数实现文件复制中的暂停,控速,获取进度等。 我的第一篇博客 前段时间无意间想到如何控制文件复制过程的复制速度,并且能实时获得复制进度。对于一个几兆甚至更小的文件,调用API函数...

    封装CopyFileEx函数,实现文件复制中的暂停,控速,获取进度等。


    前段时间无意间想到如何控制文件复制过程的复制速度,并且能实时获得复制进度。对于一个几兆甚至更小的文件,调用API函数CopyFile(Ex)来复制,很快就能完成的。然而对于一个几百兆的大文件来说,如果仍然采用调用同步CopyFileEx,那么函数将阻塞相当长的时间。并且对于大文件我更希望能知道复制的进度。为此,百度谷歌了很长时间(也曾在csdn发过帖子http://topic.csdn.net/u/20110730/16/8ebd7515-83f6-4868-8d7c-2d7a783cda8b.html在此感谢各位坛友的帮助),得知CopyFileEx这个函数能实现我的要求。因此用自己那点浅薄的C++知识对CopyFileEx函数进行了简单的封装,算是实现了自己的需求。今天把之前的代码整理了下,写在自己的csdn博客上,一来算是为自己整理下思路,锻炼下自己的文字描述能力,二来,也想获得各位前辈的指点,若能给那些和我当初一样迷茫的童鞋一个参考,实乃万幸。

    想想这也是我自己的第一篇博客,菜鸟一个,不怕拍砖!吼吼!^_^ 

    CopyFileEx函数原型
    BOOL WINAPI CopyFileEx(
      __in      LPCTSTR lpExistingFileName,
      __in      LPCTSTR lpNewFileName,
      __in_opt  LPPROGRESS_ROUTINE lpProgressRoutine,
      __in_opt  LPVOID lpData,
      __in_opt  LPBOOL pbCancel,
      __in      DWORD dwCopyFlags
    );
    前两个参数很容易明白,既然是复制文件的函数肯定要有源文件和目标文件了。第三个参数是一个回调函数的地址,在复制过程中,每当复制完成一块数据之后便调用一次,回调函数返回后再继续复制过程。如果再回调函数中让线程Sleep()一定的时间,便能减缓整个复制过程的速度,在回调函数中让线程暂定也就能暂停整个复制过程了。第四个数lpData是传给回调函数的参数,可以将在回调函数中需要修改的数据通过指针的方式传入。lpCancel:函数在执行过程中会不断的检测它指向的数值,一旦为TRUE便会取消复制过程。因此,可以用它来实现复制的停止。最后一个参数指示函数执行过程中的一些其它行为,不是非常关心,这里不在赘述。
    对于回调函数
    WORD CALLBACK CopyProgressRoutine(
      __in      LARGE_INTEGER TotalFileSize,
      __in      LARGE_INTEGER TotalBytesTransferred,
      __in      LARGE_INTEGER StreamSize,
      __in      LARGE_INTEGER StreamBytesTransferred,
      __in      DWORD dwStreamNumber,
      __in      DWORD dwCallbackReason,
      __in      HANDLE hSourceFile,
      __in      HANDLE hDestinationFile,
      __in_opt  LPVOID lpData
    );
    系统给我们传入很多有用的数据。可以看到有文件长度,已经拷贝的字节数,每个数据块的长度,回调原因,甚至包括源文件和目标文件的句柄(这里我对第3,4,5这个三个参数并不是十分理解,不过影响不大~)等等。lpData就是之前我们传入的指针。很显然,通过TotalBytesTransferred与TotalFileSize的比值我们就能知道复制进度。另外这个函数返回不同的值也有不同的作用。基本原理就是这样。

    为了能让CopyFileEx不阻塞当前线程,我在类中创建新的线程来调用它,当CopyFileEx返回时通过PostMessage发送窗口消息来通知应用程序文件复制的结果。
    要封装成类,但是这里用到了两个回调函数(线程回调函数和CopyFileEx的回调函数),而回调函数只能是全局函数,因此我将两个回调函数都写成类的静态函数,为了能方便访问类中的成员变量又将this指针传给回调函数(此方法也是之前在网上找到的)。

    好了,最后贴上代码。(由于涉及到了多线程,对于多线程的同步还没做,但是实际中貌似没发现影响。还有其它众多地方不太完善)。

    [cpp]  view plain copy
    1. /************************************************************************** 
    2. 文件名:CopyFile.h 
    3. 文件说明:类FileCopy头文件 
    4. 简要说明:封装CopyFileEx函数,实现文件复制过程的暂停,控速,异步与同步。创建新的 
    5.     线程,并在其中调用CopyFileEx函数,利用CopyFileEx的回调函数实现暂停,控制速度, 
    6.     获取进度等功能。 
    7. 完成日期:21:14 2011/10/4 
    8. 备注:代码不够完善,没能做好线程同步工作,有时间再去改进! 
    9. **************************************************************************/  
    10.   
    11. #pragma once  
    12.   
    13. #define  WM_COPYFILE_NOTIFY WM_USER+118+2  //自定义的windows消息,用来通知窗口  
    14.   
    15. class FileCopy  
    16. {  
    17. private:  
    18.     LPTSTR lpExistingPathName;                   //源文件  
    19.     LPTSTR lpNewPathName;               //目标文件  
    20.     int iSpeedControl;                  //速度控制的变量  
    21.     BOOL bCancel;                       //取消标志,用来传入CopyFileEx的回调函数  
    22.     HANDLE  hEvent_Pause;               //“复制暂停”事件  
    23.     float fCopyProgress;                //复制进度  
    24.     HWND hNotifyWnd;                    //接受通知消息的窗口  
    25.   
    26.     HANDLE hEvent_End;                  //“复制结束”事件  
    27.   
    28.     HANDLE hThread_Copy;                //线程句柄  
    29.   
    30.     LARGE_INTEGER totalFileSize;                 //总的文件长度     
    31.     LARGE_INTEGER totalBytesTransferred;    //已经复制的字节数  
    32.   
    33.     int ret_PGR;                         //作为CopyProgressRoutine的返回值,此参数未用  
    34.   
    35.   
    36.   
    37.     void Initialize();   //初始化内部数据:各种句柄和变量;  
    38.   
    39.     //线程函数,在线程中调用CopyFileEx实现文件复制  
    40.     static DWORD WINAPI ThreadProc_Copy(LPVOID lpParam);  
    41.   
    42.   
    43.     //CopyFileEx的回调函数,在此函数中实现文件复制过程的控制。  
    44.     static DWORD CALLBACK CopyProgressRoutine(  
    45.         LARGE_INTEGER TotalFileSize,  
    46.         LARGE_INTEGER TotalBytesTransferred,  
    47.         LARGE_INTEGER StreamSize,  
    48.         LARGE_INTEGER StreamBytesTransferred,  
    49.         DWORD dwStreamNumber,  
    50.         DWORD dwCallbackReason,  
    51.         HANDLE hSourceFile,  
    52.         HANDLE hDestinationFile,  
    53.         LPVOID lpData  
    54.         );  
    55.   
    56. public:  
    57.     FileCopy(void);  
    58.   
    59.     //可以在构造函数中初始化数据  
    60.     FileCopy(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd=NULL);  
    61.     ~FileCopy(void);  
    62.   
    63.     //初始化必要的参数,源文件和目标文件  
    64.     BOOL Init(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd=NULL);  
    65.   
    66.     //开始拷贝过程  
    67.     BOOL Begin();  
    68.     //暂停复制  
    69.     void Pause();  
    70.     //恢复复制  
    71.     void Resume();  
    72.     //取消复制  
    73.     void Cancel();  
    74.     //停止复制  
    75.     //void Stop();     //Stop();结束复制过程,但保存已经复制的内容,Cancel();会删除已复制的内容。  
    76.   
    77.     //等待复制结束,用来实现“同步”效果,调用此函数后线程会阻塞,直到复制完成或取消。  
    78.     void WaitForEnd();  
    79.       
    80.     //获取复制进度  
    81.     float GetProgress();  
    82.     //获取文件总大小,函数返回方式模仿 API GetFileSize();   一般情况下超过4GB的文件不多  
    83.     //,lpFileSizeHigh直接忽视就行了  
    84.     DWORD GetTotalFileSize(DWORD* lpFileSizeHigh=NULL);  
    85.     //获取已经复制的字节数;  
    86.     DWORD GetBytesTransferred(DWORD* lpTransferredHigh=NULL);  
    87.   
    88.     //设置复制速度  
    89.     void SetSpeed(int iSpeed);  
    90. };  
    [cpp]  view plain copy
    1.    
    [cpp]  view plain copy
    1.    
    [cpp]  view plain copy
    1. /************************************************************************** 
    2. 文件名:CopyFile.cpp 
    3. 文件说明:类FileCopy实现文件,详细信息见FileCopy.h文件 
    4. 完成日期:21:14 2011/10/4 
    5. **************************************************************************/  
    6.   
    7. #include "StdAfx.h"  
    8. #include "FileCopy.h"  
    9.   
    10. FileCopy::FileCopy(void)  
    11. {  
    12.     Initialize();  
    13. }  
    14.   
    15. FileCopy::FileCopy(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd)  
    16. {  
    17.     Init(lpExistingPathName,lpNewPathName,hNotifyWnd);  
    18. }  
    19.   
    20. FileCopy::~FileCopy(void)  
    21. {  
    22. //这里貌似做的不够好。。。。。-_-  
    23.     CloseHandle(hEvent_End);  
    24.     CloseHandle(hEvent_Pause);  
    25.     CloseHandle(hThread_Copy);  
    26. }  
    27.   
    28. void FileCopy::Initialize()  
    29. {  
    30.     bCancel=FALSE;  
    31.     hNotifyWnd=NULL;  
    32.     fCopyProgress=0;  
    33.     hEvent_Pause=NULL;  
    34.     iSpeedControl=-1;  
    35.     totalFileSize.HighPart=0;  
    36.     totalFileSize.LowPart=0;  
    37.     totalBytesTransferred.HighPart=0;  
    38.     totalBytesTransferred.LowPart=0;  
    39.     hThread_Copy=NULL;  
    40.   
    41.     ret_PGR=PROGRESS_CONTINUE;  
    42.   
    43.     //初始化 “复制结束”事件        手动重置  无信号  
    44.     if(hEvent_End!=NULL)  
    45.         CloseHandle(hEvent_End);  
    46.     hEvent_End=CreateEvent(NULL,TRUE,FALSE,NULL);  
    47.   
    48.     //初始化 “复制暂停”事件,       手动重置  有信号状态  
    49.     if(hEvent_Pause!=NULL)  
    50.         CloseHandle(hEvent_Pause);  
    51.     hEvent_Pause=CreateEvent(NULL,TRUE,TRUE,NULL);  
    52. }  
    53.   
    54. BOOL FileCopy::Init(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd/* =NULL */)  
    55. {  
    56.     Initialize();  
    57.     this->lpExistingPathName=lpExistingPathName;  
    58.     this->lpNewPathName=lpNewPathName;  
    59.     this->hNotifyWnd=hNotifyWnd;  
    60.   
    61.     HANDLE hFile=CreateFile(lpExistingPathName,GENERIC_READ,  
    62.         FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,  
    63.         FILE_ATTRIBUTE_NORMAL,NULL);  
    64.     if(INVALID_HANDLE_VALUE==hFile)  
    65.         return FALSE;  
    66.     if(!GetFileSizeEx(hFile,&totalFileSize))  
    67.         return FALSE;  
    68.   
    69.     return TRUE;  
    70. }  
    71.   
    72. BOOL FileCopy::Begin()  
    73. {  
    74.     //在线程中调用CopyFileEx函数,为了保持类的封装性,  
    75.     //线程函数被写成类的静态成员函数,此处传入this指针为了访问成员变量  
    76.     //CopyFileEx的回调函数也是类似于这样实现的。  
    77.     hThread_Copy=CreateThread(NULL,0,ThreadProc_Copy,this,0,NULL);  
    78.     if(NULL==hThread_Copy)  
    79.     {  
    80.         return FALSE;  
    81.     }  
    82.   
    83.     return TRUE;  
    84. }  
    85.   
    86.   
    87. DWORD WINAPI FileCopy::ThreadProc_Copy(LPVOID lpParam)  
    88. {  
    89.     //获得当前类的实例中的相关数据  
    90.     HWND hNotifyWnd=((FileCopy*)lpParam)->hNotifyWnd;  
    91.     LPTSTR lpExistingPathName=((FileCopy*)lpParam)->lpExistingPathName;  
    92.     LPTSTR lpNewPathName=((FileCopy*)lpParam)->lpNewPathName;  
    93.   
    94.     //调用核心API函数CopyFileEx来复制文件  
    95.     BOOL bSucceed=CopyFileEx(lpExistingPathName,lpNewPathName,  
    96.         CopyProgressRoutine,  
    97.         lpParam,&(((FileCopy*)lpParam)->bCancel),  
    98.         COPY_FILE_ALLOW_DECRYPTED_DESTINATION|COPY_FILE_COPY_SYMLINK|COPY_FILE_FAIL_IF_EXISTS);  
    99.   
    100.     //拷贝结束,向窗口发送通知消息;  
    101.     if(hNotifyWnd!=NULL)  
    102.     {  
    103.         if(bSucceed)  
    104.         {  
    105.             PostMessage(hNotifyWnd,WM_COPYFILE_NOTIFY,1,(LPARAM)lpExistingPathName);  
    106.         }  
    107.         else  
    108.         {  
    109.             PostMessage(hNotifyWnd,WM_COPYFILE_NOTIFY,0,(LPARAM)lpExistingPathName);  
    110.         }  
    111.     }  
    112.   
    113.     //将“拷贝结束”事件设置成信号状态  
    114.     SetEvent(((FileCopy*)lpParam)->hEvent_End);  
    115.     return 0;  
    116. }  
    117.   
    118. DWORD CALLBACK FileCopy::CopyProgressRoutine(  
    119.     LARGE_INTEGER TotalFileSize,  
    120.     LARGE_INTEGER TotalBytesTransferred,  
    121.     LARGE_INTEGER StreamSize,  
    122.     LARGE_INTEGER StreamBytesTransferred,  
    123.     DWORD dwStreamNumber,  
    124.     DWORD dwCallbackReason,  
    125.     HANDLE hSourceFile,  
    126.     HANDLE hDestinationFile,  
    127.     LPVOID lpData  
    128.     )  
    129. {  
    130. //保存文件长度和已经复制的数据量  
    131.     ((FileCopy*)lpData)->totalFileSize=TotalFileSize;  
    132.     ((FileCopy*)lpData)->totalBytesTransferred=TotalBytesTransferred;  
    133.   
    134. //计算复制进度  
    135.     ((FileCopy*)lpData)->fCopyProgress=TotalBytesTransferred.QuadPart*1.0/TotalFileSize.QuadPart;  
    136.   
    137. //通过事件对象实现暂停;  
    138.     WaitForSingleObject(((FileCopy*)lpData)->hEvent_Pause,INFINITE);  
    139.   
    140. //通过Sleep()来控制复制速度  
    141.     int iSpeed=((FileCopy*)lpData)->iSpeedControl;  
    142.     if(iSpeed>=0)  
    143.         Sleep(iSpeed);  
    144. //返回0,继续复制,以通过bCancel控制复制结束,此返回值暂时未用  
    145.     return PROGRESS_CONTINUE;  
    146. }  
    147.   
    148. void FileCopy::Pause()  
    149. {  
    150.     ResetEvent(hEvent_Pause);  
    151. }  
    152.   
    153. void FileCopy::Resume()  
    154. {  
    155.     SetEvent(hEvent_Pause);  
    156. }  
    157.   
    158. void FileCopy::Cancel()  
    159. {  
    160.     bCancel=TRUE;  
    161.     Resume();       //恢复暂停状态,让线程自然结束!  
    162. }  
    163.   
    164. void FileCopy::WaitForEnd()  
    165. {  
    166.     WaitForSingleObject(hEvent_End,INFINITE);  
    167. }  
    168.   
    169. float FileCopy::GetProgress()  
    170. {  
    171.     return fCopyProgress;  
    172. }  
    173.   
    174. DWORD FileCopy::GetTotalFileSize(DWORD* lpFileSizeHigh)  
    175. {  
    176.     if(lpFileSizeHigh)  
    177.         *lpFileSizeHigh=totalFileSize.HighPart;  
    178.     return totalFileSize.LowPart;  
    179. }  
    180.   
    181. DWORD FileCopy::GetBytesTransferred(DWORD* lpTransferredHigh)  
    182. {  
    183.     if(lpTransferredHigh)  
    184.         *lpTransferredHigh=totalBytesTransferred.HighPart;  
    185.     return totalBytesTransferred.LowPart;  
    186. }  
    187.   
    188. void FileCopy::SetSpeed(int iSpeed)  
    189. {  
    190.     iSpeedControl=iSpeed;  
    191. //每次线程Sleep()的时间不超过1000ms  
    192.     if(iSpeedControl>1000)  
    193.         iSpeedControl=1000;  
    194. }  


    更正:代码中的LPTSTR变量类型应改成LPCTSTR,否者不能传入CString类型参数。

    更正后的下载地址

    http://download.csdn.net/detail/career2011/3657624
     

    展开全文
  • 1.复制文件,定义与调用用例 BOOL WINAPI CopyFile(  __in LPCTSTR lpExistingFileName,  __in LPCTSTR lpNewFileName,  __in BOOL bFailIfExists );//CopyFile(srcfilepath, dstfilepath, 0
    1.复制文件,定义与调用用例
    BOOL WINAPI CopyFile(
      __in          LPCTSTR lpExistingFileName,
      __in          LPCTSTR lpNewFileName,
      __in          BOOL bFailIfExists
    );//CopyFile(srcfilepath, dstfilepath, 0);
    2.移动文件定义
    BOOL WINAPI MoveFile(
      __in          LPCTSTR lpExistingFileName,
      __in          LPCTSTR lpNewFileName
    );
    3.重命名文件与调用用例
    BOOL WINAPI SetFileShortName(
      __in          HANDLE hFile,
      __in          LPCTSTR lpShortName
    );

    //或者rename(original_name.c_str(), new_name.c_str());
    4.删除文件定义和调用用例
    BOOL WINAPI DeleteFile(
      __in          LPCTSTR lpFileName
    );
    //或者remove(strfile.c_str());

    展开全文
  • 封装CopyFileEx函数实现文件复制中的暂停,控速,获取进度等。 我的第一篇博客 前段时间无意间想到如何控制文件复制过程的复制速度,并且能实时获得复制进度。对于一个几兆甚至更小的文件,调用API函数...

    封装CopyFileEx函数,实现文件复制中的暂停,控速,获取进度等。

    我的第一篇博客


    前段时间无意间想到如何控制文件复制过程的复制速度,并且能实时获得复制进度。对于一个几兆甚至更小的文件,调用API函数CopyFile(Ex)来复制,很快就能完成的。然而对于一个几百兆的大文件来说,如果仍然采用调用同步CopyFileEx,那么函数将阻塞相当长的时间。并且对于大文件我更希望能知道复制的进度。为此,百度谷歌了很长时间(也曾在csdn发过帖子http://topic.csdn.net/u/20110730/16/8ebd7515-83f6-4868-8d7c-2d7a783cda8b.html在此感谢各位坛友的帮助),得知CopyFileEx这个函数能实现我的要求。因此用自己那点浅薄的C++知识对CopyFileEx函数进行了简单的封装,算是实现了自己的需求。今天把之前的代码整理了下,写在自己的csdn博客上,一来算是为自己整理下思路,锻炼下自己的文字描述能力,二来,也想获得各位前辈的指点,若能给那些和我当初一样迷茫的童鞋一个参考,实乃万幸。

    想想这也是我自己的第一篇博客,菜鸟一个,不怕拍砖!吼吼!^_^ 

    CopyFileEx函数原型
    BOOL WINAPI CopyFileEx(
      __in      LPCTSTR lpExistingFileName,
      __in      LPCTSTR lpNewFileName,
      __in_opt  LPPROGRESS_ROUTINE lpProgressRoutine,
      __in_opt  LPVOID lpData,
      __in_opt  LPBOOL pbCancel,
      __in      DWORD dwCopyFlags
    );
    前两个参数很容易明白,既然是复制文件的函数肯定要有源文件和目标文件了。第三个参数是一个回调函数的地址,在复制过程中,每当复制完成一块数据之后便调用一次,回调函数返回后再继续复制过程。如果再回调函数中让线程Sleep()一定的时间,便能减缓整个复制过程的速度,在回调函数中让线程暂定也就能暂停整个复制过程了。第四个数lpData是传给回调函数的参数,可以将在回调函数中需要修改的数据通过指针的方式传入。lpCancel:函数在执行过程中会不断的检测它指向的数值,一旦为TRUE便会取消复制过程。因此,可以用它来实现复制的停止。最后一个参数指示函数执行过程中的一些其它行为,不是非常关心,这里不在赘述。
    对于回调函数
    WORD CALLBACK CopyProgressRoutine(
      __in      LARGE_INTEGER TotalFileSize,
      __in      LARGE_INTEGER TotalBytesTransferred,
      __in      LARGE_INTEGER StreamSize,
      __in      LARGE_INTEGER StreamBytesTransferred,
      __in      DWORD dwStreamNumber,
      __in      DWORD dwCallbackReason,
      __in      HANDLE hSourceFile,
      __in      HANDLE hDestinationFile,
      __in_opt  LPVOID lpData
    );
    系统给我们传入很多有用的数据。可以看到有文件长度,已经拷贝的字节数,每个数据块的长度,回调原因,甚至包括源文件和目标文件的句柄(这里我对第3,4,5这个三个参数并不是十分理解,不过影响不大~)等等。lpData就是之前我们传入的指针。很显然,通过TotalBytesTransferred与TotalFileSize的比值我们就能知道复制进度。另外这个函数返回不同的值也有不同的作用。基本原理就是这样。

    为了能让CopyFileEx不阻塞当前线程,我在类中创建新的线程来调用它,当CopyFileEx返回时通过PostMessage发送窗口消息来通知应用程序文件复制的结果。
    要封装成类,但是这里用到了两个回调函数(线程回调函数和CopyFileEx的回调函数),而回调函数只能是全局函数,因此我将两个回调函数都写成类的静态函数,为了能方便访问类中的成员变量又将this指针传给回调函数(此方法也是之前在网上找到的)。

    好了,最后贴上代码。(由于涉及到了多线程,对于多线程的同步还没做,但是实际中貌似没发现影响。还有其它众多地方不太完善)。

    /**************************************************************************
    文件名:CopyFile.h
    文件说明:类FileCopy头文件
    简要说明:封装CopyFileEx函数,实现文件复制过程的暂停,控速,异步与同步。创建新的
    	线程,并在其中调用CopyFileEx函数,利用CopyFileEx的回调函数实现暂停,控制速度,
    	获取进度等功能。
    完成日期:21:14 2011/10/4
    备注:代码不够完善,没能做好线程同步工作,有时间再去改进!
    **************************************************************************/
    
    #pragma once
    
    #define  WM_COPYFILE_NOTIFY WM_USER+118+2  //自定义的windows消息,用来通知窗口
    
    class FileCopy
    {
    private:
    	LPTSTR lpExistingPathName;			         //源文件
    	LPTSTR lpNewPathName;				//目标文件
    	int iSpeedControl;					//速度控制的变量
    	BOOL bCancel;						//取消标志,用来传入CopyFileEx的回调函数
    	HANDLE  hEvent_Pause;				//“复制暂停”事件
    	float fCopyProgress;				//复制进度
    	HWND hNotifyWnd;					//接受通知消息的窗口
    
    	HANDLE hEvent_End;					//“复制结束”事件
    
    	HANDLE hThread_Copy;				//线程句柄
    
    	LARGE_INTEGER totalFileSize;		         //总的文件长度	
    	LARGE_INTEGER totalBytesTransferred;	//已经复制的字节数
    
    	int ret_PGR;				         //作为CopyProgressRoutine的返回值,此参数未用
    
    
    
    	void Initialize();   //初始化内部数据:各种句柄和变量;
    
    	//线程函数,在线程中调用CopyFileEx实现文件复制
    	static DWORD WINAPI ThreadProc_Copy(LPVOID lpParam);
    
    
    	//CopyFileEx的回调函数,在此函数中实现文件复制过程的控制。
    	static DWORD CALLBACK CopyProgressRoutine(
    		LARGE_INTEGER TotalFileSize,
    		LARGE_INTEGER TotalBytesTransferred,
    		LARGE_INTEGER StreamSize,
    		LARGE_INTEGER StreamBytesTransferred,
    		DWORD dwStreamNumber,
    		DWORD dwCallbackReason,
    		HANDLE hSourceFile,
    		HANDLE hDestinationFile,
    		LPVOID lpData
    		);
    
    public:
    	FileCopy(void);
    
    	//可以在构造函数中初始化数据
    	FileCopy(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd=NULL);
    	~FileCopy(void);
    
    	//初始化必要的参数,源文件和目标文件
    	BOOL Init(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd=NULL);
    
    	//开始拷贝过程
    	BOOL Begin();
    	//暂停复制
    	void Pause();
    	//恢复复制
    	void Resume();
    	//取消复制
    	void Cancel();
    	//停止复制
    	//void Stop();     //Stop();结束复制过程,但保存已经复制的内容,Cancel();会删除已复制的内容。
    
    	//等待复制结束,用来实现“同步”效果,调用此函数后线程会阻塞,直到复制完成或取消。
    	void WaitForEnd();
    	
    	//获取复制进度
    	float GetProgress();
    	//获取文件总大小,函数返回方式模仿 API GetFileSize();   一般情况下超过4GB的文件不多
    	//,lpFileSizeHigh直接忽视就行了
    	DWORD GetTotalFileSize(DWORD* lpFileSizeHigh=NULL);
    	//获取已经复制的字节数;
    	DWORD GetBytesTransferred(DWORD* lpTransferredHigh=NULL);
    
    	//设置复制速度
    	void SetSpeed(int iSpeed);
    };
     
     
    /**************************************************************************
    文件名:CopyFile.cpp
    文件说明:类FileCopy实现文件,详细信息见FileCopy.h文件
    完成日期:21:14 2011/10/4
    **************************************************************************/
    
    #include "StdAfx.h"
    #include "FileCopy.h"
    
    FileCopy::FileCopy(void)
    {
    	Initialize();
    }
    
    FileCopy::FileCopy(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd)
    {
    	Init(lpExistingPathName,lpNewPathName,hNotifyWnd);
    }
    
    FileCopy::~FileCopy(void)
    {
    //这里貌似做的不够好。。。。。-_-
    	CloseHandle(hEvent_End);
    	CloseHandle(hEvent_Pause);
    	CloseHandle(hThread_Copy);
    }
    
    void FileCopy::Initialize()
    {
    	bCancel=FALSE;
    	hNotifyWnd=NULL;
    	fCopyProgress=0;
    	hEvent_Pause=NULL;
    	iSpeedControl=-1;
    	totalFileSize.HighPart=0;
    	totalFileSize.LowPart=0;
    	totalBytesTransferred.HighPart=0;
    	totalBytesTransferred.LowPart=0;
    	hThread_Copy=NULL;
    
    	ret_PGR=PROGRESS_CONTINUE;
    
    	//初始化 “复制结束”事件        手动重置  无信号
    	if(hEvent_End!=NULL)
    		CloseHandle(hEvent_End);
    	hEvent_End=CreateEvent(NULL,TRUE,FALSE,NULL);
    
    	//初始化 “复制暂停”事件,       手动重置  有信号状态
    	if(hEvent_Pause!=NULL)
    		CloseHandle(hEvent_Pause);
    	hEvent_Pause=CreateEvent(NULL,TRUE,TRUE,NULL);
    }
    
    BOOL FileCopy::Init(LPTSTR lpExistingPathName,LPTSTR lpNewPathName,HWND hNotifyWnd/* =NULL */)
    {
    	Initialize();
    	this->lpExistingPathName=lpExistingPathName;
    	this->lpNewPathName=lpNewPathName;
    	this->hNotifyWnd=hNotifyWnd;
    
    	HANDLE hFile=CreateFile(lpExistingPathName,GENERIC_READ,
    		FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,
    		FILE_ATTRIBUTE_NORMAL,NULL);
    	if(INVALID_HANDLE_VALUE==hFile)
    		return FALSE;
    	if(!GetFileSizeEx(hFile,&totalFileSize))
    		return FALSE;
    
    	return TRUE;
    }
    
    BOOL FileCopy::Begin()
    {
    	//在线程中调用CopyFileEx函数,为了保持类的封装性,
    	//线程函数被写成类的静态成员函数,此处传入this指针为了访问成员变量
    	//CopyFileEx的回调函数也是类似于这样实现的。
    	hThread_Copy=CreateThread(NULL,0,ThreadProc_Copy,this,0,NULL);
    	if(NULL==hThread_Copy)
    	{
    		return FALSE;
    	}
    
    	return TRUE;
    }
    
    
    DWORD WINAPI FileCopy::ThreadProc_Copy(LPVOID lpParam)
    {
    	//获得当前类的实例中的相关数据
    	HWND hNotifyWnd=((FileCopy*)lpParam)->hNotifyWnd;
    	LPTSTR lpExistingPathName=((FileCopy*)lpParam)->lpExistingPathName;
    	LPTSTR lpNewPathName=((FileCopy*)lpParam)->lpNewPathName;
    
    	//调用核心API函数CopyFileEx来复制文件
    	BOOL bSucceed=CopyFileEx(lpExistingPathName,lpNewPathName,
    		CopyProgressRoutine,
    		lpParam,&(((FileCopy*)lpParam)->bCancel),
    		COPY_FILE_ALLOW_DECRYPTED_DESTINATION|COPY_FILE_COPY_SYMLINK|COPY_FILE_FAIL_IF_EXISTS);
    
    	//拷贝结束,向窗口发送通知消息;
    	if(hNotifyWnd!=NULL)
    	{
    		if(bSucceed)
    		{
    			PostMessage(hNotifyWnd,WM_COPYFILE_NOTIFY,1,(LPARAM)lpExistingPathName);
    		}
    		else
    		{
    			PostMessage(hNotifyWnd,WM_COPYFILE_NOTIFY,0,(LPARAM)lpExistingPathName);
    		}
    	}
    
    	//将“拷贝结束”事件设置成信号状态
    	SetEvent(((FileCopy*)lpParam)->hEvent_End);
    	return 0;
    }
    
    DWORD CALLBACK FileCopy::CopyProgressRoutine(
    	LARGE_INTEGER TotalFileSize,
    	LARGE_INTEGER TotalBytesTransferred,
    	LARGE_INTEGER StreamSize,
    	LARGE_INTEGER StreamBytesTransferred,
    	DWORD dwStreamNumber,
    	DWORD dwCallbackReason,
    	HANDLE hSourceFile,
    	HANDLE hDestinationFile,
    	LPVOID lpData
    	)
    {
    //保存文件长度和已经复制的数据量
    	((FileCopy*)lpData)->totalFileSize=TotalFileSize;
    	((FileCopy*)lpData)->totalBytesTransferred=TotalBytesTransferred;
    
    //计算复制进度
    	((FileCopy*)lpData)->fCopyProgress=TotalBytesTransferred.QuadPart*1.0/TotalFileSize.QuadPart;
    
    //通过事件对象实现暂停;
    	WaitForSingleObject(((FileCopy*)lpData)->hEvent_Pause,INFINITE);
    
    //通过Sleep()来控制复制速度
    	int iSpeed=((FileCopy*)lpData)->iSpeedControl;
    	if(iSpeed>=0)
    		Sleep(iSpeed);
    //返回0,继续复制,以通过bCancel控制复制结束,此返回值暂时未用
    	return PROGRESS_CONTINUE;
    }
    
    void FileCopy::Pause()
    {
    	ResetEvent(hEvent_Pause);
    }
    
    void FileCopy::Resume()
    {
    	SetEvent(hEvent_Pause);
    }
    
    void FileCopy::Cancel()
    {
    	bCancel=TRUE;
    	Resume();		//恢复暂停状态,让线程自然结束!
    }
    
    void FileCopy::WaitForEnd()
    {
    	WaitForSingleObject(hEvent_End,INFINITE);
    }
    
    float FileCopy::GetProgress()
    {
    	return fCopyProgress;
    }
    
    DWORD FileCopy::GetTotalFileSize(DWORD* lpFileSizeHigh)
    {
    	if(lpFileSizeHigh)
    		*lpFileSizeHigh=totalFileSize.HighPart;
    	return totalFileSize.LowPart;
    }
    
    DWORD FileCopy::GetBytesTransferred(DWORD* lpTransferredHigh)
    {
    	if(lpTransferredHigh)
    		*lpTransferredHigh=totalBytesTransferred.HighPart;
    	return totalBytesTransferred.LowPart;
    }
    
    void FileCopy::SetSpeed(int iSpeed)
    {
    	iSpeedControl=iSpeed;
    //每次线程Sleep()的时间不超过1000ms
    	if(iSpeedControl>1000)
    		iSpeedControl=1000;
    }


    更正:代码中的LPTSTR变量类型应改成LPCTSTR,否者不能传入CString类型参数。

    更正后的下载地址

    http://download.csdn.net/detail/career2011/3657624
     

     

     

    展开全文
  • 1、要实现一个目录下的文件被移动到另外的目录Windows API :BOOL WINAPI MoveFile( _In_ LPCTSTR lpExistingFileName, _In_ LPCTSTR lpNewFileName ); 功能:Moves an existing file or a directory, including...
  • read与write函数实现文件的拷贝

    千次阅读 2019-03-24 11:59:08
    一、函数 size_t read(int fd, void *buf, size_t count); 功能:从文件fd中期望读取count字节的数据存储到buf内 参数:count:期望读取的字节数 返回:成功读取的字节数,0文件末尾,-1出错 ssize_t ...
  • 批量复制文件-matlab实现

    千次阅读 2015-03-22 14:16:55
    虽然各种操作系统(Linux,Mac)都提供了一堆的批量复制文件的指令。但是对我们的需求,还是无能为力。因此,我们就简单地用matlab来实现一下。 函数定义 这个函数有四个参数: function flag = csvcp(src_file_...
  • 话不多说,直接上代码! #include #include #include #include #include #include #include int main(int argc,char* argv[]){ int fd,fd1,fd2;... } }else{ printf("要复制文件不存在\n"); } } return 0; }
  • C语言system函数使用

    万次阅读 多人点赞 2019-11-08 19:09:18
    函数原型 包含在头文件 “stdlib.h” 中 int system(const char * command) 函数功能 执行 dos(windows系统) 或 shell(Linux/Unix系统) 命令,参数字符串command为命令名。另,在windows系统下参数字符串不区分...
  • C语言实现文件复制

    千次阅读 2016-03-30 20:38:13
    使用C语言来复制一个文件(包括各种类型),主流的做法有2种:1.自定义函数 2.调用系统API 。本文介绍自定义函数的方法。  文件类型可以粗略分类为ASCII类型和二进制类型,且大多数为二进制类型,因此本文采用 ...
  • 【C语言】之实现文件复制功能

    万次阅读 多人点赞 2018-03-19 18:35:58
    * 功能描述:实现文件复制功能-linux平台下 * 编写人:王廷云 * 编写日期:2018-1-12 */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define BUFFSIZE 1024 // 缓冲区大小 /* 程序...
  • 系统调用read和write函数实现文件拷贝 #include #include #include #include #include #include #define SIZE 1024 int main() { int from_fd; int to_fd; int nread; int nwrite; char buff...
  • 将可以实现某一个功能的一系列算子打包成一个函数,其作用域只是当前程序,不可被其它程序使用,该函数称为本地程序函数。当程序过于庞大时,通过将各个功能模块打包成本地函数的方式,可以使算法逻辑更加清...
  • 利用C语言中的函数实现文件的Copy

    千次阅读 2016-06-07 19:02:33
    2.读写  (1).按字符进行读写操作  fgetc  int fgetc(FILE *stream);  参数:  @stream 流指针  返回值: ... 失败 返回EOF(end of file) 实际上是一个结束标志 在文件本身并不存在  fputc
  • 要求在命令行输入两个文件名即可实现把第一个文件复制到第二个新文件中,其中mycp函数的要求是mycp(char *src, char *dest),*src是源文件路径,*dest是目标文件路径。知识点:1.Linux系统编程之错误处理:perror , ...
  • C++ 文件拷贝函数 CopyFileExA 使用

    千次阅读 2016-10-13 15:36:16
    1. 前言老板让在相机控制程序中加入一个功能, 将采集的图片移动到相应的目录下去。于是想到了 CopyFileExA。 相关参考文档: 1. CopyFileEx function2....2. 基本思路核心是使用 CopyFileEx, 不过这个函数
  • 警告: 即使是更高等级的文件复制功能 ( shutil.copy(), shutil.copy2() ) 也不能复制所有文件的元数据(metadata)。 在 POSIX 平台上,这意味着文件的属主和用户组会丢失,ACLs也一样。 在 Mac OS 上,...
  • c++实现文件拷贝,不用system函数

    千次阅读 2015-07-09 20:55:52
    使用C++标准程序库的输入输出流(I/O Stream)复制文件,存在许多的方法, 方法一:逐个字符复制 #include  std::ifstream input("in",ios::binary); std::ofstream output("out",ios::binary);
  • 前面介绍了使用API函数SHFileOperation实现复制文件时显示进度对话框 ,这里顺便简单介绍下使用IFileOperation实现复制文件时显示进度对话框这一功能。接口IFileOperation是Windows用来替代SHFileOperation函数的,...
  • C语言文件操作函数大全

    万次阅读 多人点赞 2018-01-19 20:35:35
    C语言文件操作函数大全 2018-1-19  13.1C语言文件 1,两种文件存取方式(输入,输出方式) 顺序存取 直接存取 2,数据的两种存放形式 文本文件 二进制文件 13.2文件指针 定义文件类型指针变量的一般...
  • windows下实现fcntl函数功能

    千次阅读 2019-11-28 17:30:22
    fcntl函数是linux下的一个文件函数,用以加密文件,给文件上锁,防止文件同时被多个进程操作。 我遇到的主要是这两个: fcntl.flock(f, fcntl.LOCK_EX) fcntl.flock(f, fcntl.LOCK_UN) 但是在windows下执行时发现...
  • * 功能:拷贝文件函数 * 参数: * sourceFileNameWithPath:源文件名(带路径) * targetFileNameWithPath:目标文件名(带路径) * 返回值: * SUCCESS: 拷贝成功 * FAILURE:拷贝失败 * author:...
  • C++ 实现文件复制和移动

    万次阅读 2017-02-26 19:44:18
    实现一个文件复制和移动的函数,来处理文件,可惜电脑上面没有安装Matlab,就想用 C++ 来实现这个功能。分别使用 C 里面的 rename 函数和 C++ 中的 stream 来实现。rename 就是简单的修改文件名,如果文件路径...
  • 编写一个应用程序实现文件复制使用格式:java Copy 源文件目标文件,功能是将源文件的内容复制到目标文件。 import java.io.*; public class Main{ public static void main(String args[ ]){ try{ ...
  • 从上图中我们可以看到FileInputStream和FileOutputStream建立起了文件和内存的单行道。FileInputStream只能将数据从外存读到内存,FileOutputStream只能从内存将数据读到外存。 根据他们的特点我写了一个
  • 已知strcpy的函数原型:char *strcpy(char *strDest,const char *...不调用C++/C的字符串库函数,实现字符串复制函数strcpy。  一种方法: char *strcpy(char *strDest, const char *strSrc)//源字符串参数用const修
  • 简单封装CopyFileEx函数在类FileCopy中,实现文件复制过程的进度获取,速度控制,暂停,取消等功能。连夜写了一个测试程序。。。。顺便打包上传
  • #文件复制 import os src_path=r'E:\Pycharm\python100题\代码' target_path=r'E:\Pycharm\python100题\123' #封装成函数 def copy_function(src,target): if os.path.isdir(src) and os.path.isdir(target): ...
  • 用WindowsAPI实现文件复制功能

    千次阅读 2018-04-08 17:54:44
    用WindowsAPI实现文件复制功能 1. c代码 注释也在里面 文件名为 copyfile.c 运行出来的exe为 copyfile.exe #include &lt;windows.h&gt; #include &lt;stdio.h&gt; #define ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 421,758
精华内容 168,703
关键字:

复制文件使用什么函数实现