银行家算法C++实现

最新推荐文章于 2024-05-14 00:53:41 发布
最新推荐文章于 2024-05-14 00:53:41 发布
阅读量3.1w 收藏 361
点赞数 66
分类专栏： Algorithm 文章标签： 银行家算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingpy/article/details/79915768
版权

网上有很多银行家算法的源代码，下面是本人自己写的，基本算法模型参考教材。

介绍

银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉（Edsger Wybe Dijkstra）在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。

背景简介

在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。

银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

安全状态
如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。

不安全状态
不存在一个安全序列。不安全状态不一定导致死锁。

标题实现

要求

  1. 建立银行家算法的数据结构描述；

  2. 将初始数据放在文件中，算法运行时读出；

  3. 对给定的资源请求，使用算法判断是否允许；

  4. 输出每次判断产生的执行序列。

开发环境

windows C++ Code Blocks

程序实现

数据结构

Available[PROGRESS];    
 //定义可用资源向量

sign[PROGRESS],work[PROGRESS][REC_NUM],workAll[PROGRESS][REC_NUM];
 //记录成功的安全序列,并定义工作矩阵和可用资源矩阵

Max[PROGRESS][REC_NUM],Allocation[PROGRESS][REC_NUM],Need[PROGRESS][REC_NUM];
//定义最大需求矩阵Max，分配矩阵Allocation，需求矩阵Need

Request[PROGRESS][REC_NUM]; 
//定义请求矩阵Requset

运行步骤

//读取文件数据并打印,然后将数据存入到相应矩阵中
		Read_file();

//任务开始
        int i,N=0;    // 'N'表示请求资源次数
        int Request[PROGRESS][REC_NUM];  //定义请求矩阵Requset
        while(N!=999) {
                cout<<endl<<"请输入请求资源Request[进程标号i][资源类型j]:"<<endl;
                cout<<"进程i=：";
                cin>>i;
                cout<<"各类资源数量(A B C)=:  ";
                for(int m = 0;m < REC_NUM;m++)
                        cin>>Request[i][m];
                cout<<endl;
   //执行银行家算法
                int result = Banker_Algorithm(i,Request);
   //输出每次判断产生的执行序列
                cout<<endl<<"资源分配表："<<endl;
                Print_Run_Order(result);
                cout<<endl<<"请输入N(当N=999退出)："<<endl;
                cin>>N;
        }

安全性算法设计思路

开始将可用资源数目赋给工作向量Work

for(int r = 0;r < REC_NUM;r++)  Work[r] = Available[r]；

执行while循环，只有满足条件（4行，6行）才将Finish置为1(true)，并释放进程占有所有资源，这时用数组sign（13行）保存此进程标号，用于输出安全序列。

注意每当找到符合条件的进程，就将i置为-1，并i++，重新开始扫描进程，因为当某个进程释放资源后，标号为0的进程可能符合条件（14行）。

1    while(i < PROGRESS) {
2              if(Finish[i] == 0){
3                      //满足条件释放资源，并从头开始扫描进程集合
4                      while(j < REC_NUM && Need[i][j] <= Work[j] )
5                              j++;
6                       if(j == REC_NUM) {
7                              for(int k = 0;k < REC_NUM;k++){
8                                       work[i][k] = Work[k];
9                                       Work[k] = Work[k]+Allocation[i][k];
10                                      workAll[i][k] = Work[k];
11                              }
12                              Finish[i]=1;
13                              sign[m]=i;  //保存安全序列
14                              i=-1;m++;
15                      }
16              }
17              j=0;i++;
18     }

循环结束后，返回Finsih 中true的个数

for(int p = 0;p < PROGRESS;p++){             
     if(Finish[p] == 1)                     
           n++;   //记录'true'个数
}
return n;     //返回'true'个数

附程序源代码

//如要引用请附上以下说明
/**

 * 操作系统课程设计

 * 题目：11.银行家算法

 * 输入请求资源，判断安全状态;

 * 打印资源分配表

 * 作者：易树

 * 版本：3.0 （完成时间 2016.12.20）

 */


#include <iostream>
#include <fstream>

#define PROGRESS 5     //进程数量
#define REC_NUM  3     //资源种类数量

using namespace std;

//定义数据结构

int Available[PROGRESS];      //定义可用资源向量Available
int sign[PROGRESS],work[PROGRESS][REC_NUM],workAll[PROGRESS][REC_NUM];
        //记录成功的安全序列,并定义工作矩阵和可用资源矩阵

int Max[PROGRESS][REC_NUM],Allocation[PROGRESS][REC_NUM],Need[PROGRESS][REC_NUM];
        //定义最大需求矩阵Max，分配矩阵Allocation，需求矩阵Need

 

void Read_file();     //读取文件
int Banker_Algorithm(int,int [][REC_NUM]);       //银行家算法
int Safe_Algorithm(int [],int [][REC_NUM],int [][REC_NUM]);    //安全性算法
void Print_Run_Order(int);         //打印判断执行序列

int main()
{
        //读取文件数据并打印,然后将数据存入到相应矩阵中
        Read_file();

         //任务开始
        int i,N=0;    // 'N'表示请求资源次数
        int Request[PROGRESS][REC_NUM];  //定义请求矩阵Requset
        while(N!=999) {
                cout<<endl<<"请输入请求资源Request[进程标号i][资源类型j]:"<<endl;
                cout<<"进程i=：";
                cin>>i;
                cout<<"各类资源数量(A B C)=:  ";
                for(int m = 0;m < REC_NUM;m++)
                        cin>>Request[i][m];
                cout<<endl;
                //执行银行家算法
                int result = Banker_Algorithm(i,Request);
                //输出每次判断产生的执行序列
                cout<<endl<<"资源分配表："<<endl;
                Print_Run_Order(result);
                cout<<endl<<"请输入N(当N=999退出)："<<endl;
                cin>>N;
        }
}

//读取文件数据，打印到控制台，并将数据存入到相应矩阵中
void Read_file(){
        //读取完整文件并打印
        ifstream inFile1("Alldata.txt",ios::in);  //创建文件流对象
        if(!inFile1)      //判断对象inFile打开文件成功与否
              cerr<<"File open error."<<endl;  //使用错误流对象输出错误信息
        else {
                char c;
                while((c=inFile1.get())!=EOF)  //按字符读取文件内容，到达末尾停止
                        cout<<c;
                cout<<endl;
                inFile1.close();
        }

        //读取只有数字的文件并存入矩阵中
        ifstream inFile2("data.txt",ios::in);
        if(!inFile2)
              cerr<<"File open error."<<endl;
        else{
                int data;
               //读取数字并存入矩阵
               for(int j = 0;j < PROGRESS;j++) {
                for(int i = 0;i < REC_NUM;i++) {
                      inFile2>>data;
                       Max[j][i]=data;
                }
                for(int i = 0;i < REC_NUM;i++) {
                      inFile2>>data;
                       Allocation[j][i]=data;
                }
                for(int i = 0;i < REC_NUM;i++) {
                      inFile2>>data;
                      Need[j][i]=data;
                }
                if(j==0) {
                        for(int i = 0;i < REC_NUM;i++) {
                              inFile2>>data;
                              Available[i]=data;
                       }
                }
               }
                inFile2.close();
        }
}

//银行家算法
int Banker_Algorithm (int i,int Request[][REC_NUM]){
        for(int m = 0;m < REC_NUM;m++) {
                if(Request[i][m] > Need[i][m]){
                        cout<<"所需资源数超出其宣布的最大值!"<<endl;
                        return 0;
                } else if(Request[i][m] > Available[m]) {
                        cout<<"无足够资源，p["<<i<<"]需等待!"<<endl;
                        return 0;
                }
        }

        //尝试为进程分配资源
        for(int j = 0;j < REC_NUM;j++) {
                Available[j] = Available[j] - Request[i][j];
                Allocation[i][j] = Allocation[i][j] + Request[i][j];
                Need[i][j] = Need[i][j] - Request[i][j];
        }

        //执行安全性算法
        int n = Safe_Algorithm(Available,Need,Allocation);
        cout<<endl;

        if(n == PROGRESS) {//有5个'true'返回1，表示此时刻安全
                cout<<"此时刻是安全状态，可以分配资源给"<<"P["<<i<<"]!"<<endl;
        }else {

//把给进程P[i]分配过的资源还给系统
                for(int j = 0;j < REC_NUM;j++) {
                        Available[j] = Available[j] + Request[i][j];
                        Allocation[i][j] = Allocation[i][j] - Request[i][j];
                        Need[i][j] = Need[i][j] + Request[i][j];
                }
                cout<<"此时刻不是安全状态，不能将资源分配给"<<"P["<<i<<"]!"<<endl;
        }
        return n;
}

//安全性算法
int Safe_Algorithm(int Available[],int Need[][REC_NUM],int Allocation[][REC_NUM]) {
        int i=0,j=0,m=0,n=0;
        int Work[REC_NUM],Finish[PROGRESS] = {0,0,0,0,0};
        for(int r = 0;r < REC_NUM;r++) //将可用资源数目赋给工作向量Work
                Work[r] = Available[r];
        while(i < PROGRESS) {
                if(Finish[i] == 0){
                        //满足条件释放资源，并从头开始扫描进程集合
                        while(j < REC_NUM && Need[i][j] <= Work[j] )
                                j++;
                        if(j == REC_NUM) {
                                for(int k = 0;k < REC_NUM;k++){
                                        work[i][k] = Work[k];
                                        Work[k] = Work[k]+Allocation[i][k];
                                        workAll[i][k] = Work[k];
                                }
                                Finish[i]=1;
                                sign[m]=i;  //保存安全序列
                                i=-1;m++;
                        }
                }
                j=0;i++;
        }
        for(int p = 0;p < PROGRESS;p++){
               if(Finish[p] == 1)
                        n++;   //记录'true'个数
        }
        return n;     //返回'true'个数
}

//打印安全性检查的执行序列
void Print_Run_Order(int result) {
        if(result == PROGRESS) {
                cout<<" 进程\\资源情况"<<" Work(A B C)"<<" Need(A B C)"
                    <<" Allocation(A B C)"<<" Work+Available(A B C)"<<" Finish";
                cout<<endl;
                for(int i = 0;i < PROGRESS;i++) {
                        cout<<"    "<<"P["<<sign[i]<<"]  "<<'\t';
                        for(int j = 0;j < REC_NUM;j++)
                               cout<<work[sign[i]][j]<<" ";
                        cout<<'\t'<<'\t';
                        for(int j = 0;j < REC_NUM;j++)
                               cout<<Need[sign[i]][j]<<" ";
                        cout<<'\t'<<'\t';
                        for(int j = 0;j < REC_NUM;j++)
                               cout<<Allocation[sign[i]][j]<<" ";
                        cout<<'\t'<<'\t';
                        for(int j = 0;j < REC_NUM;j++)
                               cout<<workAll[sign[i]][j]<<" ";
                        cout<<'\t'<<'\t';
                        cout<<"true"<<endl;
                }
                cout<<endl<<"找到安全序列｛P["<<sign[0]<<"]";
                for(int m = 1;m < PROGRESS;m++){
                        cout<<", P["<<sign[m]<<"]";
                }
                cout<<"}"<<endl;
        } else {
                cout<<"   进程\\资源情况 "<<"  Allocation(A B C)"<<"   Need(A B C)"<<"   Available(A B C)";
                cout<<endl;
                for(int k = 0;k < 5;k++){
                        cout<<'\t'<<"P["<<k<<"]"<<'\t'<<'\t';
                        for(int j = 0;j < 3;j++)
                                cout<<Allocation[k][j]<<" ";
                        cout<<'\t'<<'\t';
                        for(int j = 0;j < 3;j++)
                                cout<<Need[k][j]<<" ";
                        cout<<'\t'<<'\t';
                        if(k == 0) {
                                for(int j = 0;j < 3;j++)
                                cout<<Available[j]<<" ";
                        }
                        cout<<endl;
                }
        }
}

运行截图

这里写图片描述

这里写图片描述

项目地址

github地址
csdn下载

参考文献

  1. 《 计算机操作系统》 汤小丹 梁红兵 哲风屏 汤子灜 编著
  2. 百度百科-银行家算法
lingpy
关注
  • 66
    点赞
  • 踩
  • 361
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 20
    评论
专栏目录
操作系统银行家算法模拟实现（C语言版）
闭关修炼——暂退
05-23 8万+
目录 一、实验目的 二、实验内容 三、实验要点说明 银行家算法实例 程序结构 四、实验代码 五、实验运行结果 一、实验目的 通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。 二、实验内容 （1）模拟一个银行家算法： 设置数据结构 设计安全性算法 （2） 初始化时让系统拥有一定的资源 （3） 用键盘输入的方式申请资源 （4）如果预分配后，系统处于安全...
【OS笔记 29】处理死锁的四种方法——避免死锁（资源分配图算法与银行家算法）
qq_43722079的博客
09-11 6514
一、系统安全状态 系统处于安全状态时，就可避免死锁；处于不安全状态时，可能发生死锁。 1. 安全状态与不安全状态 所谓安全状态，是指系统此时能找到一个进程的序列<P1,P2,P3…Pn>，只要按照此顺序为其分配资源，就能使每个进程都能顺利完成。 ...
2024年最全银行家算法——C语言实现_银行家算法c语言实现(1)，2024最新C C++笔经
2401_84978503的博客
05-14 1031
/尝试将资源分配给请求进程的时候，发生改变的数组有，allocation，stillNeeds，available,work;j++) //j表示列。printf(“进程%d所申请的资源已经超过了其一开始定义的最大值，不予分配\n”);//第一步检查进程所申请的资源数目是否超过其一开始声明的最大值。printf(“请输入系统中各种资源的数量：\n”);printf(“当前系统的资源分配情况如下:\n”);printf(“资源名称\t”);//初始化系统中各个资源的数量。
C/C++实现银行家算法
CansoKing的博客
05-21 3582
#define MAXPROCESS 255 #include <iostream> #include <string> #include <vector> using namespace std; // 进程类定义 class Process { public: // 进程名字 string name; // 资源种类数目 int allocation_and_need_size; // 已分配资源 int *allocation; // 需求资源
需求矩阵
热门推荐
smilesundream的博客
04-19 1万+
链接：https://www.nowcoder.com/questionTerminal/1ae37daa6de74caca937c5d497ce2e49 来源：牛客网 1）可利用资源向量Available 是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K，则表示系统中现有Rj类资源K个。 2）最大需求矩阵Max 这是一个n×m
银行家算法vc++模拟实现
脚踏实地
12-15 5027
操作系统在对资源进行分配的时候会出现一种资源的争抢，为了避免在资源争抢的时候出现死锁现象引入了银行家算法。
银行家算法C++实现（源代码）
09-13
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行...
银行家算法 c++实现（代码+报告）
04-05
《银行家算法C++实现详解》 银行家算法是一种经典的资源分配和死锁预防策略，由艾兹格·迪杰斯特拉在1965年提出。它主要用于确保系统在面临资源请求时能够避免死锁的发生，从而保证系统的安全性。在本资料中，我们...
银行家算法c++实现
06-03
银行家算法c++实现
银行家算法C++实现1
08-08
实验要求学生实现一个基于银行家算法的资源管理系统，通过C++编程。实验的目标是理解和应用银行家算法，以及操作系统的基本功能调用，如获取日期和时间。 在设计银行家算法时，关键的数据结构包括： 1. **可利用...
银行家算法c++ 实现
12-09
在C++实现银行家算法的过程中，主要涉及到以下几个关键概念： 1. **资源**: 这是操作系统中的硬件或软件资源，如CPU时间、内存、磁盘空间等。在银行家算法中，每个资源都有一个数量，可以被多个进程共享。 2. **...
操作系统实验银行家算法VC++源代码
04-27
银行家算法 1． 实验目的和要求 银行家算法是避免死锁的一种重要方法，要求编写和调试一个简单的银行家算法程序。加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。 2． 实验内容 1．设计进程对各类资源最大申请表示及初值确定。 2．设定系统提供资源初始状况。 3．设定每次某个进程对各类资源的申请表示。 4．编制程序，依据银行家算法，决定其申请是否得到满足。 3． 实验说明 1．数据结构 假设有M个进程N类资源，则有如下数据结构： MAX[M*N] M个进程对N类资源的最大需求量 AVAILABLE[N] 系统可用资源数 ALLOCATION[M*N] M个进程已经得到N类资源的资源量 NEED[M*N] M个进程还需要N类资源的资源量 2．银行家算法 设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。 (1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。 (2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。 (3)系统试探分配资源，修改相关数据： AVAILABLE=AVAILABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST (4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。 3．安全性检查 (1)设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE (2)从进程集合中找到一个满足下述条件的进程， FINISH[i]=FALSE NEED<=WORK 如找到，执行(3)；否则，执行(4) (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 WORK=WORK+ALLOCATION FINISH=TRUE GO TO 2 (4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。 4． 参考程序 #include "string.h" #include "iostream.h" #define M 5 //总进程数 #define N 3 //总资源数 #define FALSE 0 #define TRUE 1 //M个进程对N类资源最大资源需求量 int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; //系统可用资源数 int AVAILABLE[N]={10,5,7}; //M个进程已经得到N类资源的资源量 int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}}; //M个进程还需要N类资源的资源量 int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; int Request[N]={0,0,0};
操作系统—银行家算法（C++实现）
05-13
银行家算法 ： 固定进程数以及资源类别，输入所需分配进程的编号以及资源个数，经过系统安全检查，判断是否安全，安全则分配成功，输出安全序列；不安全则分配失败 语言：C++ 运行环境：Visual Studio 2013/更高版本
银行家算法C语言完整版
11-28
银行家算法C语言完整源代码，能正确编译运行，结果正确，个人编写没有雷同
银行家算法避免死锁C语言代码实现
01-18
银行家算法的实现，当输入每类资源的MAX和Allocation，计算是否存在安全序列
银行家算法（C实现）
07-18
银行家算法是一个避免死锁的著名算法，它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
操作系统——银行家算法（c++实现）
weixin_67131528的博客
10-23 691
编写银行家算法程序，能够对进程提出的资源请求进行判断，并打印出计算得到的安全序列。目的：利用银行家算法实现系统资源的动态分配及进程安全状态检测问题。
银行家算法及其c++代码实现
weixin_39660224的博客
08-05 2574
最近小编在学习自考操作系统的过程中，了解到了一种可以避免进程死锁的算法-----银行家算法 如果您已经知道什么是银行家算法，只想看代码，直接到 源码部分 什么是银行家算法 银行家算法是操作系统中避免死锁的一种算法 什么是死锁 和我们线程死锁类似，不同线程持有对方的锁，多个线程又不能释放锁，即产生死锁 类似上图，P1 申请 输出设备，但是输出设备被P2占有，P2又申请输入设备 输入设备又被P1占有形成回路 如何避免呢？ 和简单只要在资源分配前检测当前系统是否处于安全状态，是否能被分配，分配之后系统是否还是安
c++实现银行家算法
分享快乐
07-08 9852
大三上学期的时候自己写的银行家算法的代码，复制粘贴到编译器即可运行，希望帮助到其他人！/* Financier algorithm.(银行家算法) */ //=====<head file>============================================================== #include<stdio.h> #include<windows.h>
银行家算法C++简单实现
最新发布
06-03
银行家算法是避免死锁的著名算法。以下是C++的简单实现： ```c++ #include <iostream> using namespace std; const int P = 5; // 定义进程数 const int R = 3; // 定义资源数 void calculateNeed(int need[P][R], int maxm[P][R], int allot[P][R]); bool isSafe(int processes[], int avail[], int maxm[][R], int allot[][R]); int main() { int processes[P] = { 0, 1, 2, 3, 4 }; // 定义进程数组 int avail[R] = { 3, 3, 2 }; // 定义资源数组 int maxm[P][R] = { { 7, 5, 3 }, { 3, 2, 2 }, { 9, 0, 2 }, { 2, 2, 2 }, { 4, 3, 3 } }; // 定义最大需求矩阵 int allot[P][R] = { { 0, 1, 0 }, { 2, 0, 0 }, { 3, 0, 2 }, { 2, 1, 1 }, { 0, 0, 2 } }; // 定义已分配矩阵 int need[P][R]; // 定义需求矩阵 calculateNeed(need, maxm, allot); if (isSafe(processes, avail, maxm, allot)) cout << "系统是安全的" << endl; else cout << "系统是不安全的" << endl; return 0; } // 计算需求矩阵 void calculateNeed(int need[P][R], int maxm[P][R], int allot[P][R]) { for (int i = 0; i < P; i++) for (int j = 0; j < R; j++) need[i][j] = maxm[i][j] - allot[i][j]; } // 判断系统是否是安全的 bool isSafe(int processes[], int avail[], int maxm[][R], int allot[][R]) { int need[P][R]; calculateNeed(need, maxm, allot); bool finish[P] = { 0 }; int safeSeq[P]; int work[R]; for (int i = 0; i < R; i++) work[i] = avail[i]; int count = 0; while (count < P) { bool found = false; for (int i = 0; i < P; i++) { if (!finish[i]) { int j; for (j = 0; j < R; j++) if (need[i][j] > work[j]) break; if (j == R) { for (int k = 0; k < R; k++) work[k] += allot[i][k]; safeSeq[count++] = i; finish[i] = true; found = true; } } } if (!found) return false; } return true; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lingpy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值