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

最新推荐文章于 2021-05-23 07:14:09 发布
最新推荐文章于 2021-05-23 07:14:09 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： VC/MFC学习

本文转自：http://blog.csdn.net/career2011/article/details/6844513


封装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
 


小刺猬001
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++:用CopyFileExA拷贝文件 (附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-16 344
C++:用CopyFileExA拷贝文件 (附完整源码)
VB大文件的复制、移动带进度条及暂停功能
12-21
一个简单的文件复制、移动范例，带进度条显示、暂停继续功能。主要用到API函数CopyFileEx及MoveFileWithProgress。希望对有这方面需求的网友有所帮助。
封装CopyFileEx实例复制文件，提供同步、异步复制调用
06-23
封装CopyFileExe成为一个类，提供简单的同步、异步调用文件复制、暂停、恢复、取消复制，自动计算速度和进度，回调给调用者。
c# 封装的文件夹操作类之复制文件夹
dazhexuan0219的博客
01-16 92
c# 封装的文件夹操作类之复制文件夹 一.复制文件夹原理： 1.递归遍历文件夹 2.复制文件 二.FolderHelper.cs 1 /// <summary> 2 /// 文件夹操作类 3 /// </summary> 4 public static class FolderHelper 5 {...
C++在复制文件的过程中显示进度条
dxm809的博客
05-23 749
void CFileCopyDlg::OnPut() { if(strname.IsEmpty()) return; BROWSEINFO bi; char buffer[MAX_PATH]; ZeroMemory(buffer,MAX_PATH); bi.hwndOwner=GetSafeHwnd(); bi.pidlRoot=NULL; bi.pszDisplayName=buffer; bi.lpszTitle="选择一个文件夹"; .
封装CopyFileEx，实现文件复制异步，控速，获取进度
10-05
简单封装CopyFileEx函数在类FileCopy中，实现文件复制过程的进度获取，速度控制，暂停，取消等功能。连夜写了一个测试程序。。。。顺便打包上传
PWM.rar_51 PWM 小车_pwm控速_电机控速
09-14
"PWM控速2"这个文件可能包含了实现这一功能的源代码或详细步骤。它可能包括了初始化定时器、配置PWM输出、设置占空比以及处理中断服务程序的代码。通过分析和理解这段代码，我们可以学习如何在实际项目中应用PWM技术...
基于51单片机PID算法的直流电机测速控速设计
07-18
基于51单片机PID算法的直流电机测速控速设计，测量精度很高，控制精度也很高，误差在1r/min内，这是经过本人长期调试所得出的成果！程序里的PID参数是在大量实验过程得到的，很具有参考价值！希望对大家有所帮助！
用PLL实现心电图机的走纸控速电路* (2005年)
05-19
阐述了利用锁相技术来控制心电图机走纸电路中电机的速度，使其稳速工作，而其中的选频电路、锁相环路采用CPLD（Complex Programmable Logic Device）实现。与传统心电图机走纸控速电路相比，采用CPLD实现心电图机的...
API函数CopyFileEx使用详解(delphi)
热门推荐
bobWu 的 学习日记
12-04 1万+
 { 函数原型 }   function CopyFileEx(    lpExistingFileName   : PChar;               // 来源文件    lpNewFileName        : PChar;               // 目标文件    lpProgressRoutine    : TFNProgressRoutine;  // 用于返回文
CopyFileEx 函数
会飞的丑小鸭的博客
05-14 1144
例子 // ConsoleApplication2.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include using namespace std; DWORD CALLBACK CopyProg
MFC拷贝文件及进度条显示
Arcsinsin的学习笔记
08-02 5680
参考：封装CopyFileEx函数，实现文件复制中的暂停，控速，获取进度。 http://blog.csdn.net/career2011/article/details/6844513 实例讲解C++中CopyFileEx函数的简单用法 http://www.exam8.com/computer/djks/dj2/C/ziliao/200903/1316720.html MFC文件拷
VC下文件(夹)拷贝的方式
caomiao2006的专栏
11-23 2125
    1、直接通过CRT标注函数fopen/fclose打开/关闭文件，fread/fwrite读写文件；    2、WIN32 API的CopyFile函数或CopyFileEX(回调函数返回进度)函数直接进行拷贝；    3、WIN32 API的SHFileOperation函数拷贝文件或文件夹；    4、WIN32 API的CreateFile、ReadFile和WriteF
红外51单片机控速代码
最新发布
10-25
红外控制电机转速的代码一般分为两部分：红外接收部分和电机控制部分。 红外接收部分： 1. 首先需要定义红外接收引脚和电机控制引脚的端口号，例如： ``` sbit IRIN=P3^2; //红外接收引脚 sbit ENA=P1^0; //电机使能引脚 sbit ENB=P1^1; sbit IN1=P1^2; //电机控制引脚 sbit IN2=P1^3; ``` 2. 然后需要编写红外接收函数，例如： ``` void IR_receive() { unsigned char i=0; unsigned char j=0; unsigned char k=0; unsigned char IR_data[4]={0}; while(IRIN==1); //等待低电平 while(IRIN==0); //等待高电平 for(i=0;i<4;i++) { for(j=0;j<8;j++) { while(IRIN==1); //等待低电平 while(IRIN==0); //等待高电平 delay_us(1); if(IRIN==1) { IR_data[i]|=(0x01<<(7-j)); while(IRIN==1); //等待低电平 } } } if(IR_data[2]==(~IR_data[3])) { switch(IR_data[2]) { case 0x18: //按键1 IN1=1; IN2=0; break; case 0x08: //按键2 IN1=0; IN2=1; break; case 0x1C: //按键3 IN1=1; IN2=1; break; case 0x5A: //按键4 ENA=0; ENB=0; break; case 0x52: //按键5 ENA=1; ENB=1; break; } } } ``` 这个函数的作用是接收红外信号，并根据不同的按键控制电机的转速和方向。 电机控制部分： 1. 首先需要定义电机控制函数，例如： ``` void motor_control(unsigned char speed) { TH0=256-speed; //设置定时器初值 TL0=256-speed; TR0=1; //启动定时器 } ``` 这个函数的作用是根据传入的速度值控制电机的转速。 2. 然后需要编写定时器中断函数，例如： ``` void timer0() interrupt 1 { static unsigned char count=0; count++; if(count>=10) //每10个定时器中断周期改变一次电机状态 { count=0; IN1=!IN1; IN2=!IN2; } } ``` 这个函数的作用是定时改变电机的状态，从而控制电机的转速和方向。 最后，在主函数中需要启动定时器和红外接收功能，例如： ``` void main() { TMOD=0x01; //定时器0工作在模式1 TH0=0; TL0=0; ET0=1; //允许定时器0中断 EA=1; //开启总中断 while(1) { IR_receive(); //接收红外信号 motor_control(100); //控制电机转速 } } ``` 这样就完成了红外控制电机转速的代码。如果需要更详细的代码实现，可以参考一些相关的开源项目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值