【操作系统实验考试笔记】

最新推荐文章于 2022-06-04 23:00:00 发布
最新推荐文章于 2022-06-04 23:00:00 发布
阅读量174 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45209148/article/details/118229679
版权

题目

t1
利用fork pipe实现 cat /etc/passwd | wc -l 命令

//利用fork pipe实现 cat /etc/passwd | wc -l 命令

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <linux/string.h>
#include <fcntl.h>
int fd[2];
void mysys(char *cmd1,char *cmd2)
{
	char c1[100];
	char c2[100];
	strcpy(c1,cmd1);
	strcpy(c2,cmd2);
	pid_t pid;
   pipe(fd);
	/*创建子进程，管道的所有操作都在这里面完成*/
	pid=fork();
	if (pid == 0) { 
        // child
      //cat输出到屏幕的内容重定向到fd[1]管道写端
        dup2(fd[1], 1); 
        close(fd[0]);
        close(fd[1]);
       // execl("/bin/sh","sh","-c",cmd1 ,NULL);
       execlp("cat","cat","/etc/passwd",NULL);
        //write(1, "hello", 6); 
        exit(0);
    }
    // parent
   // int file=open("log.txt",O_CREAT|O_RDWR,666);
   
   //标准输入定向到管道输入端
   //wc直接到管道读端去读
    dup2(fd[0], 0); 
   //标准输入定向到管道输入端
   // dup2(file,1);
    close(fd[0]);
    close(fd[1]);
    execlp("wc","wc","-l",NULL);
    //read(0, buf, sizeof(buf)); 
    //execl("/bin/sh","sh","-c",cmd2 ,NULL);
    //printf("Receive:%s\n", buf); 
    //return 0;

	
}

 
int main()
{
	printf("> ");
	char command[100];
	 /*分割两条命令，分别存入cmd1，和cmd2中。
	 以 | 为分隔符，将命令以及参数字符串存入*/
	fgets(command,100,stdin);
	char *cmd1,*cmd2,*filename;
	cmd1= strtok(command," ");
    // puts(cmd1);
	filename= strtok(NULL,"|");
	//puts(filename);
	cmd2= strtok(NULL,"\n");
	//puts(cmd2);
	
	//创建新数组地址
	char *command1= (char *)malloc(strlen(cmd1)+strlen(filename)+1);
	char *command2= (char *)malloc(strlen(cmd2)+strlen(filename)+1);
	strcpy(command1,cmd1);
	strcat(command1," ");
	strcat(command1,filename);
	//puts(command1);
	strcpy(command2,cmd2);
  // puts(command2);
   mysys(command1,command2);
	
	return 0;
}

2019 t2

10个子进程计算0100之，和第一个进程计算010，第二计算11~20，以此类推。 并利用管道把结果返回到主进程

//10个子进程计算0~100,第一个进程计算0~10，第二计算11~20，以此类推。 并利用管道把结果返回到主进程
//(open函数)
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
//（read/write）(pipe) (sleep)
#include <unistd.h>
//(进程)
#include <stdio.h>
//(exit)
#include <stdlib.h>
//pthread.h包含了函数pthread_create的声明
#include <pthread.h>
int main()
{
    int pid;    
    int allsum=0;
    int fds[20];
    int i;
    for(i=0;i<20;i++)
       {
           
           pipe(&fds[i*2]);
       }

     for( i=0;i<10;i++)
     {

        pid = fork();
       if (pid == 0) 
       { 
            int j=0;
            int sum=0;
            for(j=(i*10+1);j<=(i+1)*10;j++)
                sum+=j;

            write(fds[i*2+1], &sum,sizeof(int));
            for(i=0;i<20;i++)
             close(fds[i]);
         exit(0);
       }

     }
     
     
  
    
    
    // parent

    for (i = 0; i < 10; i++) {
        int result=0;
        read(fds[i*2],&result,sizeof(int));
        allsum += result;
    }
     for( i =0; i<20;i++)
        close(fds[i]);

    printf("sum = %d\n", allsum);

    return 0;
}

2019 t3

2个线程计算1100，第一个计算startmiddle，第二个计算middle~end。

#include <stdio.h>
#include <pthread.h>
#include <pthread.h>
#include <sys/types.h>
#include <stdlib.h>

struct params
{
    int start;
    int end;
};

struct result
{
   int sum;
 };

 void *compute(void *args)
 {
     struct params *param=(struct params*)args;
     int sum=0;
     int i;
     for(i=param->start;i<=param->end;i++)
         sum+=i;
     
     struct result *result=malloc(sizeof(struct result));
     result->sum=sum;
     return result;
     }

int parallel_add(int start, int end)
{
    int middle=(start+end)/2;
    struct params param[2];
    pthread_t worker[2];
    int sum=0;
    int i=0;
    struct result *result;
    struct params *p_param=param;
    p_param->start=start;
    p_param->end=middle;
    pthread_create(&worker[0],NULL,compute,p_param);
    p_param++;
    p_param->start=middle+1;
    p_param->end=end;
    pthread_create(&worker[1],NULL,compute,p_param);
    for(i=0;i<2;i++)
    
    {
        
        pthread_join(worker[i],(void**)&result);
        sum+=result->sum;
        free(result);
     }
     return sum;


}

int main()
{
    // 1+2+3 ... + 100 = 5050
    printf("sum = %d\n", parallel_add(1, 101));
    return 0;
}

2019 t4

4个子进程，分别为爹妈儿女。爹往盘子里放苹果，儿子消耗苹果。妈往盘子里放橘子，女儿消耗橘子。盘子里只容许放一个水果。
使程序按如下结果运行循环
put apple
get apple
put orange
get orange

#include <stdio.h>
#include <pthread.h>
int temp=0;
pthread_mutex_t mutex;
pthread_cond_t wait_apple;
pthread_cond_t wait_orange;
pthread_cond_t full_apple;
pthread_cond_t full_orange;
void *father_entry(void *arg)
{
   while(1)
{   pthread_mutex_lock(&mutex);
    while(temp!=0)
        pthread_cond_wait(&wait_orange,&mutex);
    temp=1;
    puts("put apple");
    pthread_cond_broadcast(&full_apple);
    pthread_mutex_unlock(&mutex);
    sleep(1);
}
    return NULL;
}

void *mother_entry(void *arg)
{
    while(1)
    {
    pthread_mutex_lock(&mutex);
    while(temp!=0)
        pthread_cond_wait(&wait_apple,&mutex);
    temp=2;
    puts("put orange");
    pthread_cond_broadcast(&full_orange);
    pthread_mutex_unlock(&mutex);
    sleep(1);
    }
    return NULL;
}

void *son_entry(void *arg)
{
    while(1)
    {
    pthread_mutex_lock(&mutex);
    while(temp!=1)
        pthread_cond_wait(&full_apple,&mutex);

    temp=0;    
    puts("get apple");
    pthread_cond_broadcast(&wait_apple);
    pthread_mutex_unlock(&mutex);
    sleep(1);
    }
    return NULL;
}

void *daughter_entry(void *arg)
{
   while(1){
   pthread_mutex_lock(&mutex);
    while(temp!=2)
        pthread_cond_wait(&full_orange,&mutex);
    temp=0;
    puts("get orange");
    pthread_cond_broadcast(&wait_orange);
    pthread_mutex_unlock(&mutex);
    sleep(1);
   }
    return NULL;
}

int main()
{
    pthread_t father_thread;
    pthread_t mother_thread;
    pthread_t son_thread;
    pthread_t daughter_thread;
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&wait_apple,NULL);
    pthread_cond_init(&wait_orange,NULL);
    pthread_cond_init(&full_apple,NULL);
    pthread_cond_init(&full_orange,NULL);
    temp=0;
    pthread_create(&father_thread, NULL, &father_entry, NULL);
    sleep(1);
    pthread_create(&mother_thread, NULL, &mother_entry, NULL);
    pthread_create(&son_thread, NULL, &son_entry, NULL);
    pthread_create(&daughter_thread, NULL, &daughter_entry, NULL);

    while (1);
    return 0;
}

2016 t1

主进程创建1个子进程
主进程通过管道与子进程连接
子进程的标准输出连接到管道的写端
主进程的标准输入连接到管道的读端
在子进程中调用exec(“echo”, “echo”, “hello world”, NULL)
在父进程中调用read(0, buf, sizeof(buf))，从标准输入中获取子进程发送的字符串，并打印出来

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(void)
{
    int fds[2];
    int buf[512];
    pipe(fds); 
    pid_t pid;
    pid = fork();
    int readsize;
    if(pid == 0)
    {
        dup2(fds[1],STDOUT_FILENO);
        execlp("echo", "echo", "hello world", NULL);
        exit(0);
    }
    else if (pid > 0)
    {
     	readsize = read(fds[0], buf, 512);
     	write(STDOUT_FILENO, buf, readsize);      
    }
    close(fds[0]);
    close(fds[1]);
    return 0;

}

2016 t2

主进程创建2个子进程，主进程通过两个管道分别与两个子进程连接
第一个子进程计算从1加到50的和，并将结果通过管道送给父进程
第一个子进程计算从50加到100的和，并将结果通过管道送给父进程
父进程读取两个子进程的结果，将他们相加，打印出来，结果为5050

2016 t3

1.主线程创建10个子线程 - 第0个子线程计算从01加到10的和 - 第1个子线程计算从11加到20的和 - 第2个子线程计算从21加到30的和 - … - 第9个子线程计算从91加到100的和 2. 主线程归并10个子线程的计算结果，最终结果为5050 3. 本题必须使用线程参数来完成

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>


typedef struct {
    int from;
    int to;
    int ans;
} Arg;


void *calc(void *arg)
{
    Arg *p = arg;
    int i;
    p->ans = 0;
    for(i = p->from; i<= p->to; ++i)
    	p->ans += i;
    return NULL;
}

int main(void)
{
    pthread_t ths[10];
    Arg args[10];
    int i, sum=0;    
    for(i = 0; i< 10; ++i)
    {
    	args[i].from = i*10 + 1;
    	args[i].to = (i+1) * 10;
    	pthread_create(ths + i, 0, calc, args + i); 
    }
    
    for(i = 0; i< 10; ++i)
        pthread_join(ths[i], NULL);
    
    for(i = 0; i<10; ++i)
        sum += args[i].ans;
    
    printf("%d\n", sum);    
    return 0;
}

2016 t4

  1. 主线程创建4个子线程T1、T2、T3、T4，主线程在4个子线程退出后，才退出
  2. 线程T1、T2、T3、T4的运行时代码如下：
#include <unistd.h> // sleep函数声明在该头文件中

void *T1_entry(void *arg)
{
    sleep(2);  // 睡眠2秒，不准删除此条语句，否则答题无效
    puts(“T1”);
}

void *T2_entry(void *arg)
{
    sleep(1);  // 睡眠1秒，不准删除此条语句，否则答题无效
    puts(“T2”);
}

void *T3_entry(void *arg)
{
    sleep(1);  // 睡眠1秒，不准删除此条语句，否则答题无效
    puts(“T3”);
}

void *T4_entry(void *arg)
{
    puts(“T4”);
}
  1. 使用信号量或者条件变量机制(而不是使用sleep函数)，使得这四个线程满足如下制约关系：
    • T1的print语句执行后，T2和T3才可以执行print语句
    • T2和T3的print语句执行后，T4才可以执行print语句
  2. 程序输出结果为
T1
T2
T3
T4

或者

T1
T3
T2
T4

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

pthread_cond_t s1_signal = PTHREAD_COND_INITIALIZER;
pthread_cond_t s2_signal = PTHREAD_COND_INITIALIZER;
int t1_gone = 0, t2_gone = 0, t3_gone = 0;
pthread_mutex_t s1_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t s2_mutex = PTHREAD_MUTEX_INITIALIZER;

void *T1_entry(void *arg)
{
    pthread_mutex_lock(&s1_mutex);

    sleep(2);
    puts("T1");

    t1_gone = 1;
    pthread_cond_broadcast(&s1_signal);
    pthread_mutex_unlock(&s1_mutex);

    return NULL;
}

void *T2_entry(void *arg)
{
    pthread_mutex_lock(&s1_mutex);
    while(!t1_gone)
        pthread_cond_wait(&s1_signal, &s1_mutex);
    pthread_mutex_unlock(&s1_mutex);
    
    sleep(1);
    puts("T2");
    
    pthread_mutex_lock(&s2_mutex);
    t2_gone = 1;
    pthread_cond_signal(&s2_signal);
    pthread_mutex_unlock(&s2_mutex);
    
    return NULL;
}

void *T3_entry(void *arg)
{
    pthread_mutex_lock(&s1_mutex);
    while(!t1_gone)
        pthread_cond_wait(&s1_signal, &s1_mutex);
    pthread_mutex_unlock(&s1_mutex);
     
    sleep(1);
    puts("T3");
    
    pthread_mutex_lock(&s2_mutex);
    t3_gone = 1;
    pthread_cond_signal(&s2_signal);
    pthread_mutex_unlock(&s2_mutex);

    return NULL;
}

void *T4_entry(void *arg)
{
    pthread_mutex_lock(&s2_mutex);
    while(!t2_gone || !t3_gone)
        pthread_cond_wait(&s2_signal, &s2_mutex);
        
    puts("T4");
    
    pthread_mutex_unlock(&s2_mutex);
    return NULL;
}



int main(void)
{
    pthread_t t1,t2,t3,t4;
    pthread_create(&t1, 0, T1_entry, NULL);
    pthread_create(&t2, 0, T2_entry, NULL);
    pthread_create(&t3, 0, T3_entry, NULL);
    pthread_create(&t4, 0, T4_entry, NULL);
    
    pthread_join(t4, NULL);
    return 0;
}

第二种

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>

typedef struct {
	int value;
	pthread_mutex_t mutex;
	pthread_cond_t cond;
}sema_t;

sema_t t1_2_ready;
sema_t t1_3_ready;
sema_t t2_ready;
sema_t t3_ready;


void sema_init(sema_t *sema, int value)
{
	sema->value = value;
	pthread_mutex_init(&sema->mutex, NULL);
	pthread_cond_init(&sema->cond, NULL);
}

void sema_wait(sema_t *sema)
{
	pthread_mutex_lock(&sema->mutex);
	while (sema->value <= 0)
        	pthread_cond_wait(&sema->cond, &sema->mutex);
    	sema->value--;
	pthread_mutex_unlock(&sema->mutex);
}

void sema_signal(sema_t *sema)
{
	pthread_mutex_lock(&sema->mutex);
	++sema->value;
	pthread_cond_signal(&sema->cond);
	pthread_mutex_unlock(&sema->mutex);
}

void *T1_entry(void *arg)
{
	sleep(2);  // 睡眠2秒，不准删除此条语句，否则答题无效
	puts("T1");
	sema_signal(&t1_2_ready);
	sema_signal(&t1_3_ready);

}

void *T2_entry(void *arg)
{
	sema_wait(&t1_2_ready);
	sleep(1);  // 睡眠1秒，不准删除此条语句，否则答题无效
	puts("T2");
	sema_signal(&t2_ready);
}

void *T3_entry(void *arg)
{
	sema_wait(&t1_3_ready);
	sleep(1);  // 睡眠1秒，不准删除此条语句，否则答题无效
	puts("T3");
	sema_signal(&t3_ready);

}

void *T4_entry(void *arg)
{
	sema_wait(&t2_ready);
	sema_wait(&t3_ready);
	puts("T4");
}

int main()
{
	sema_init(&t1_2_ready,0);
	sema_init(&t1_3_ready,0);
	sema_init(&t2_ready,0);
	sema_init(&t3_ready,0);

	pthread_t T1,T2,T3,T4;
	pthread_create(&T1, NULL, T1_entry, NULL);
	pthread_create(&T2, NULL, T2_entry, NULL);
	pthread_create(&T3, NULL, T3_entry, NULL);
	pthread_create(&T4, NULL, T4_entry, NULL);
	pthread_join(T1,NULL);
	pthread_join(T2,NULL);
	pthread_join(T3,NULL);
	pthread_join(T4,NULL);
	return 0;
}

ring.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#define N 10
#define LOOPCOUNT 25

void *add(void *arg){
    int *num = (int *)arg;
    num[1] = num[0] + 1;
    int *result = num;
}
int main()
{
    int buff[N][2];
    int i = 0;
    for(i = 0;i < N;i++)
    {
        buff[i][0]=0;
        buff[i][1]=0;
    }
    pthread_t tids[N];

    i = 0;
    int count = 0;
    while(i < N)
    {
        count++;
        if(count == LOOPCOUNT)
            break;

        printf("from T[%d]",i+1);
        pthread_create(&tids[i],NULL,add,(void *)&buff[i]);
        pthread_join(tids[i],NULL);
        int result = buff[i][1];

        i = (i+1) % N;
        buff[i][0] = result;
        printf("to T[%d] send %d\n",i+1,result);
    }
    return 0;
}
weixin_45209148
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统实验课笔记（陆续更新）
01-09
文章目录1.切换到根用户（超级用户）2.基础命令创建文件（两种）:1.用cat命令2.用vi编辑器3.创建用户与删除用户4.进程 ctrl+alt+t 打开黑框 1.切换到根用户（超级用户） su root或者su – 然后输入密码（密码不显示*也不显示明文 输入完成后按回车即可） 普通用户为$ 根用户为# 只有super user才可创建文件 即进行写操作 2.基础命令 pwd 查看当前路径 ls 查看当前路径下文件与文件夹（蓝色为文件夹 白色为文件） cd 文件夹名 跳到指定文件夹（返回上一级 cd 两个点）//中间有空格 mkdir 文件夹名 创建文件夹(make 创建) rmdir
操作系统笔记期末考试
12-19
在准备操作系统笔记期末考试时，考生应通过实际案例来加深理论知识的理解，并熟悉操作系统相关的实验操作，如使用命令行工具进行进程管理、内存查看、文件操作等。同时，历年试题和模拟题的练习也是必不可少的，以...
ucore操作系统实验笔记（零）实验前的准备
weixin_38611196的博客
01-23 1015
在ubuntu操作系统下进行所有实验，试验前要做的准备工作主要有： 1.熟悉Linux操作系统基本操作。 2.学习80x86汇编语言（AT&amp;amp;T格式）与IA-32计算机体系结构基础知识。这方面的资料有《Intel80x86处理器开发者手册，Vol.3》《Professional Assembly Language》（Richard Blum著） 3.按学堂在线网站上视频课程的要求搭建基本的实...
南京航空航天大学2020-2021学年操作系统实验考试题目
huifeidezhua233的博客
06-04 575
南京航空航天大学2020-2021学年操作系统实验考试题目
linux操作系统实践期末考试
NolanKy 的 技术博客
06-20 1162
选择题 I. Single Choice Questions (2 * 20 = 40 points) ##################################################### Command “ls -l” list the detail infomation of files. Which one is a soft link file according to the first ten characters? A. -rw-rw-rw- B. -rwxrwxr
操作系统实验
The_Only_God的博客
07-10 347
进程同步(linux环境) 生产者消费者问题 生产者 #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<sys/ipc.h> #include<semaphore.h> #include<fcntl.h> #include<sys/stat.h> int main() { int i=0,n; sem_t *mutex=sem_open
南航《操作系统》上机课程资料笔记
10-10
本资料包“南航《操作系统》上机课程资料笔记”包含了丰富的学习材料，旨在帮助学生深入理解和掌握操作系统的核心概念及实践技能。 在操作系统课程中，上机实践部分尤为重要，因为它能将理论知识转化为实际操作，让...
南航计算机学院考研保研 操作系统课程的实验代码-实验心得-上机考试练习-笔试复习笔记.zip
最新发布
04-21
这个压缩包文件提供了丰富的学习资源，包括实验代码、实验心得、上机考试练习以及笔试复习笔记，旨在帮助学生全面提升操作系统领域的知识和技能。 1. 实验代码： 实验代码部分可能包含多个实验项目，如进程管理、...
北大 考研 操作系统 作业 笔记
04-05
九、操作系统实验与实践 这部分可能包含一些实际操作，如操作系统调用的实现、进程通信机制的模拟、内存管理策略的分析等。 这份“北大本科作业及答案”可能包含了上述知识点的具体题目和解答，对于准备北大考研的...
自学考试04757信息系统开发与管理备考笔记
10-10
信息系统开发与管理备考笔记是自学考试04757的重要组成部分，本文档对信息系统开发与管理的基本概念和方法进行了详细的介绍。 一、信息与数据的关系 信息是经过加工的数据，是有一定含义，能减少不确定性，对决策...
计算机操作系统实验代码（6个实验）
06-09
计算机操作系统实验代码，包括先来先服务FCFS和短作业优先SJF进程调度算法、时间片轮转RR进程调度算法、预防进程死锁的银行家算法、动态分区分配算法、虚拟内存页面置换算法、磁盘调度算法
自考操作系统实践十大题型
04-29
自考 操作系统 实践 十大题型 源码
操作系统往年实验机考答案
07-11
NUAA操作系统朱广蔚老师往年机考答案，到15级为止使用的是往年题，但是经过18年的考试来看19年老师应该会改题目了，仅供参考
使用fork()，exec()，dup2(), pipe()，open()系统调用完成与shell命令等价的功能：grep -v usr result.txt
07-12
使用fork()，exec()，dup2(), pipe()，open()系统调用完成与下列shell命令等价的功能：grep -v usr result.txt
操作系统上机题目（多进程2）
Betterc5的博客
06-24 550
1、主进程创建2个子进程，主进程通过两个管道分别与两个子进程连接 2、第一个子进程计算从1加到50的和，并将结果通过管道送给父进程 3、第一个子进程计算从50加到100的和，并将结果通过管道送给父进程 4、父进程读取两个子进程的结果，将他们相加，打印出来，结果为5050 code： #include&lt;stdio.h&gt; #include&lt;unistd.h&gt; #in...
操作系统上机题目（多线程2）
Betterc5的博客
06-24 760
主线程创建4个子线程T1、T2、T3、T4， 主线程在4个子线程退出后，才退出 线程T1、T2、T3、T4的运行时代码如下： #include &lt;unistd.h&gt; // sleep函数声明在该头文件中 void *T1_entry(void *arg) { sleep(2); // 睡眠2秒，不准删除此条语句，否则答题无效 puts(“T1”); } ...
linux编程两个子进程,是否可以在同一父代创建的两个子进程之间建立管道(LINUX,POSIX)...
weixin_29056101的博客
04-28 109
这基本上是shell在构建重定向链时所做的事情,例如ls | grep foo | sort | uniq有一些关于Unix编程的优秀介绍性文本,其中通过本书实现了一个简单的shell. shell的任务之一是重定向.其中一本书是Michael K. Johnson和Erik W. Troan的“Linux应用程序编程”.要为N个进程构建重定向链,您需要N-1个管道.对于每个重定向,您使用管道(i...
操作系统实验及代码（全）
热门推荐
菜鸟鸟的博客
02-20 6万+
题目1：基本操作命令实践 题目2：Windows进程的创建与销毁 题目3 作业调度 题目4 基于优先数的时间片轮转调度算法调度处理器 题目5 银行家算法 题目6 内存管理 题目7 页面置换 题目8 磁盘调度
嵌入式工程师考试题目.doc
12-02
嵌入式工程师考试题目.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值