【Linux】：自定义shell（简易版）

于 2024-07-20 20:08:23 发布
阅读量650 收藏 6
点赞数 15
分类专栏： Linux系统编程 文章标签： linux shell
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yikefore/article/details/140306530
版权

朋友们、伙计们，我们又见面了，本期来给大家带来一期自定义shell，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

C 语 言 专 栏：C语言：从入门到精通

数据结构专栏：数据结构

个  人  主  页 ：stackY、

C + + 专 栏   ：C++

Linux 专 栏  ：Linux

目录

引言： 

1. 命令行提示符 

2. 获取用户指令

2.1 封装命令行和获取指令

3. 执行用户输入的命令

3.1 分割命令字符串

3.2 创建子进程执行指令

3.3  封装分割字符串和执行命令

4. 内建命令的执行

4.1 cd命令 

4.2 export命令

4.3 echo命令

5. 检查重定向

6. 完整代码

引言： 

Linux命令行的功能非常强大，我们用了这么长时间的shell，那么本期我们来自己实现一个简单版的shell。

1. 命令行提示符 

我们可以先看一下原本的shell：

要实现一个shell先得有一个命令行提示符，这个命令行提示符前面是用户名，中间是主机号，后面是工作目录，这些属性我们可以直接定义，但是在Linux环境变量中都保存着这些属性，并且是动态的，所以我们直接使用环境变量中的这些属性；

在程序中获取环境变量的接口叫做getenv：

#include <stdlib.h>
char *getenv(const char *name);

接下来我们先使用getenv实现三个获取命令行提示符的函数：

// 获取用户名
const char* getUsername()
{
    const char* name = getenv("USER");
    if(name) return name;
    return "none";
}
// 获取主机名
const char* getHostname()
{
    const char* hostname = getenv("HOSTNAME");
    if(hostname) return hostname;
    return "none";
}
// 获取当前工作目录
const char* getCwd()
{
    const char* cwd = getenv("PWD");
    if(cwd) return cwd;
    return "none";
}

获取完成之后，紧接着按照原本shell的格式来把他们拼接在一起打印出来看一看：

int main()
{
    // 打印命令行提示符
    printf("[%s@%s %s]# ", getUsername(), getHostname(), getCwd());
    return 0;
}

可以看到我们的shell命令行提示符已经完成了，接下来就需要获取用户输入的命令了。

2. 获取用户指令

要获取用户输入的指令，我们先定义一个用来保存指令的字符数组，由于我们输入的指令可能不只是单纯的一个，还会输入一些带选项的指令，此时就不能使用scanf来读取，需要用按行读取的函数接口，我们选择fgets：

C语言会默认打开三个流：

  • ① 标准输入流：stdin
  • ② 标准输出流：stdout
  • ③ 标准错误流：stderr

所以我们从标准输入流中读取用户写入的命令：

#define NUM 1024

int main()
{
    char usercommand[NUM];

    // 打印命令行提示符
    printf("[%s@%s %s]# ", getUsername(), getHostname(), getCwd());
    // 获取用户输入命令
    char* r = fgets(usercommand, sizeof(usercommand), stdin);
    if(r == NULL) return 1;
    
    return 0;
}

当我们输入命令时，最后肯定会跟上一个'\n'，所以我们需要将命令行中的最后一个位置的'\n'设置为'\0'。

int main()
{
    char usercommand[NUM];

    // 打印命令行提示符
    printf("[%s@%s %s]# ", getUsername(), getHostname(), getCwd());
    // 获取用户输入命令
    char* r = fgets(usercommand, sizeof(usercommand), stdin);
    if(r == NULL) return 1;
    // 命令规范化
    usercommand[strlen(usercommand) - 1] = '\0';   // 不会存在越界问题
    return 0;
}

这样写是不存在越界的问题，假设我们什么命令都不输入，但是最后还是会敲一下回车，所以只有一个'\n'，将这个'\n'改为'\0'也符合预期。

2.1 封装命令行和获取指令

将打印命令行提示符和获取用户指令封装称为一个函数，后面我们直接调用这个函数即可。

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

#define NUM 1024

int getUserCommand(char *command, int sz)
{
    // 打印命令行提示符
    printf("[%s@%s %s]# ", getUsername(), getHostname(), getCwd());
    // 获取用户输入命令
    char* r = fgets(command, sz, stdin);
    if(r == NULL) return -1;
    // 命令规范化
    command[strlen(command) - 1] = '\0';   // 不会存在越界问题
    return strlen(command);
}

int main()
{
    char usercommand[NUM];
    getUserCommand(usercommand, sizeof(usercommand));
    //printf("%s", usercommand);
    return 0;
}

3. 执行用户输入的命令

获取完用户输入的指令，接下来就需要执行对应的指令了。 

3.1 分割命令字符串

要能正确执行对应的命令，就需要将输入的命令以及选项做合理的分割：分割命令字符串我们选用C语言中的strtok函数：

将分割好的字符串存放在一个字符指针数组中，最后以NULL结尾即可：

int main()
{
    char usercommand[NUM];

    // 打印命令行提示符 + 获取用户指令
    getUserCommand(usercommand, sizeof(usercommand));
    // 分割命令字符串
    char *argv[SIZE];
    int argc = 0;
    argv[argc++] = strtok(usercommand, SEP);
    while (argv[argc++] = strtok(NULL, SEP)){};

    return 0;
}

3.2 创建子进程执行指令

因为要执行指令就需要进行程序替换，如果单进程替换的话后面的代码就不能运行，所以创建子进程，让子进程去执行对应的指令。

在这里的程序替换选择的函数接口是：execvp

我们使用命令行输入指令肯定是想要我输完一个结果显示紧接着就可以输入下一个，所以需要设置一个循环的结构，并且为了效率，当获取用户指令失败、或者用户没有输入有效指令，就继续获取，就不用进行下面分割字符串、创建子进程的过程了。

#define SEP " "
#define SIZE 64

int main()
{
    while (1)
    {
        char usercommand[NUM];
        // 打印命令行提示符 + 获取用户指令
        int flag = getUserCommand(usercommand, sizeof(usercommand));
        if (flag <= 0)
            continue;
        // 分割命令字符串
        char *argv[SIZE];
        int argc = 0;
        argv[argc++] = strtok(getUserCommand, SEP);
        while (argv[argc++] = strtok(NULL, SEP))
        {};
        // 创建子进程执行命令
        pid_t id = fork();
        if (id < 0)
            return 1;
        else if (id == 0) // child
        {
            // 程序替换执行命令
            execvp(argv[0], argv);
            exit(1);
        }
        else // parent
        {
            pid_t rid = waitpid(id, NULL, 0);
        }
    }
    return 0;
}

3.3  封装分割字符串和执行命令

为了使用方便以及代码简介，直接将这两个接口封装称为一个函数即可：

// 分割命令字符串
void commandSplit(char *in, char *out[])
{
    int argc = 0;
    out[argc++] = strtok(in, SEP);
    while (out[argc++] = strtok(NULL, SEP))
    {
    };
}

// 执行命令
int excuteCommand(char *argv[])
{
    // 创建子进程执行命令
    pid_t id = fork();
    if (id < 0)
        return -1;
    else if (id == 0) // child
    {
        // 程序替换执行命令
        execvp(argv[0], argv);
        exit(1);
    }
    else // parent
    {
        pid_t rid = waitpid(id, NULL, 0);
    }
    return 0;
}

4. 内建命令的执行

在Linux中有一批命令，需要我们的bash自己去执行，类似于自己内部的一个函数，这批命令就叫做内建命令，例如：cd、export、echo的特殊用法等，因此我们需要在执行命令之前，判断用户输入的命令是否为内建命令，如果为内建命令，直接让我们的父进程直接去执行内建命令，同样的我们将判断内建命令封装成一个函数，直接在这个函数里面调用执行对应的内建命令：

4.1 cd命令 

cd命令是更改我们的工作目录，更改工作目录的接口是chdir：

路径更改完之后，还需要更改环境变量中的PWD，所以先用获取当前路径的接口getcwd：

然后使用sprintf将当前路径导出到环境变量中。

cd命令还需要注意一个小细节，cd后面没有路径默认情况是cd到家目录。

char cwd[1024];  // 接受当前工作目录的缓冲区

void cd(char *path)
{
    chdir(path); // 改变当前工作目录
    char tmp[1024]; // 
    getcwd(tmp, sizeof(tmp)); // 获取当前工作目录
    sprintf(cwd, "PWD=%s", tmp); // 写入到缓冲区中
    putenv(cwd);   // 导出环境变量
}

// 判断内建命令
int isBuildinCommand(char *argv[])  
{
    if (strcmp(argv[0], "cd") == 0)  // cd path
    {
        char *path = NULL;
        if(argv[1] == NULL) home = homePath();
        else path = argv[1];
        cd(path);
        return 1;
    }
    // 可以再列举更多内建命令
    return 0;
}

4.2 export命令

 我们使用export命令来在命令行中导出环境变量，所以我们设置全局的缓冲区来接收要导出的环境变量，然后使用putenv来导出环境变量。

int isBuildinCommand(char *argv[])
{
    if (strcmp(argv[0], "cd") == 0)  // cd path
    {
        char *path = NULL;
        if(argv[1] == NULL) path = getHomePath();
        else path = argv[1];
        cd(path);
        return 1;
    }
    else if(strcmp(argv[0], "export") == 0)
    {
        if(argv[1] == NULL) return 1;
        strcpy(enval, argv[1]);  // 拷贝到缓冲区
        putenv(enval);  // 导出
        return 1;
    }
    
    // 可以再列举更多内建命令
    return 0;
}

4.3 echo命令

我们使用echo命令首先打印普通变量（echo 1244），其次打印退出码（echo $?），还会打印环境变量（echo $PATH），所以这些特殊用法都要实现：


// 判断内建命令
int isBuildinCommand(char *argv[])
{
    if (strcmp(argv[0], "cd") == 0) // cd path
    {
        char *path = NULL;
        if (argv[1] == NULL)
            path = getHomePath();
        else
            path = argv[1];
        cd(path);
        return 1;
    }
    else if (strcmp(argv[0], "export") == 0)
    {
        if (argv[1] == NULL)
            return 1;
        strcpy(enval, argv[1]); // 拷贝到缓冲区
        putenv(enval);          // 导出
        return 1;
    }
    else if (strcmp(argv[0], "echo") == 0)
    {
        if (argv[1] == NULL)   // echo
        {
            printf("\n");
            return 1;
        }
        else if (*(argv[1]) == '$' && strlen(argv[1]) > 1) // echo $...
        {
            char *val = argv[1] + 1;
            if (strcmp(val, "?") == 0)
            {
                printf("%d\n", lastcode);
                lastcode = 0;
            }
            else
            {
                const char *env_val = getenv(val);
                if (env_val)
                    printf("%s\n", env_val);
                else
                    printf("\n");
            }
            return 1;
        }
        else          // echo 1234
        {
            printf("%s\n", argv[1]);
            return 1;
        }
    }
    // 可以再列举更多内建命令
    return 0;
}

5. 检查重定向

在获取完指令后先检测一下指令中是否存在重定向。

先获取重定向的类型，再拆分要重定向的文件。

获取完成之后在执行命令的时候直接使用重定向完成操作。

// 检查重定向
void checkRedir(char command[], int len)
{
    char *end = command + len - 1; // 从后向前面检查
    char *start = command;
    while (end > start)
    {
        if (*end == '>') // 输出重定向       ls -a -l >> log.txt
        {
            if (*(end - 1) == '>') // 追加重定向
            {
                *(end - 1) = '\0';
                filename = end + 1;
                SkipSpace(filename);
                redir = AppendRedir;
                break;
            }
            else
            {
                *end = '\0';
                filename = end + 1;
                SkipSpace(filename);
                redir = OutputRedir;
                break;
            }
        }
        else if (*end == '<') // 输入重定向
        {
            *end = '\0';
            filename = end + 1;
            SkipSpace(filename);
            redir = InputRedir;
            break;
        }
        else
        {
            end--;
        }
    }
}

6. 完整代码

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

#define NUM 1024
#define SEP " "
#define SIZE 64

#define NoneRedir 0
#define OutputRedir 1
#define AppendRedir 2
#define InputRedir 3

int redir = NoneRedir;
char *filename = NULL;

char cwd[1024];
int lastcode = 0;
char enval[1024];

// 获取用户名
const char *getUsername()
{
    const char *name = getenv("USER");
    if (name)
        return name;
    return "none";
}
// 获取主机名
const char *getHostname()
{
    const char *hostname = getenv("HOSTNAME");
    if (hostname)
        return hostname;
    return "none";
}
// 获取当前工作目录
const char *getCwd()
{
    const char *cwd = getenv("PWD");
    if (cwd)
        return cwd;
    return "none";
}
// 获取家目录
char *getHomePath()
{
    char *home = getenv("HOME");
    if (home)
        return home;
    else
        return (char *)".";
}

// 打印命令行提示符 + 获取用户指令
int getUserCommand(char *command, int sz)
{
    // 打印命令行提示符
    printf("[%s@%s %s]# ", getUsername(), getHostname(), getCwd());
    // 获取用户输入命令
    char *r = fgets(command, sz, stdin);
    if (r == NULL)
        return 1;
    // 命令规范化
    command[strlen(command) - 1] = '\0'; // 不会存在越界问题
    return strlen(command);
}

// 分割命令字符串
void commandSplit(char *in, char *out[])
{
    int argc = 0;
    out[argc++] = strtok(in, SEP);
    while (out[argc++] = strtok(NULL, SEP))
    {
    };
}

// 执行命令
int excuteCommand(char *argv[])
{
    // 创建子进程执行命令
    pid_t id = fork();
    if (id < 0)
        return -1;
    else if (id == 0) // child
    {
        int fd = 0;
        if (redir == InputRedir) // 输入重定向
        {
            fd = open(filename, O_RDONLY);
            dup2(fd, 0);
        }
        else if (redir == OutputRedir) // 输出重定向
        {
            fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
            dup2(fd, 1);
        }
        else if (redir == AppendRedir) // 追加重定向
        {
            fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);
            dup2(fd, 1);
        }
        else
        {
            // do nothing
        }
        // 程序替换执行命令
        execvp(argv[0], argv);
        exit(1);
    }
    else // parent
    {
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if (rid > 0)
        {
            lastcode = WEXITSTATUS(status);
        }
    }
    return 0;
}

void cd(char *path)
{
    chdir(path);                 // 改变当前工作目录
    char tmp[1024];              //
    getcwd(tmp, sizeof(tmp));    // 获取当前工作目录
    sprintf(cwd, "PWD=%s", tmp); // 写入到缓冲区中
    putenv(cwd);                 // 导出环境变量
}

// 判断内建命令
int isBuildinCommand(char *argv[])
{
    if (strcmp(argv[0], "cd") == 0) // cd path
    {
        char *path = NULL;
        if (argv[1] == NULL)
            path = getHomePath();
        else
            path = argv[1];
        cd(path);
        return 1;
    }
    else if (strcmp(argv[0], "export") == 0)
    {
        if (argv[1] == NULL)
            return 1;
        strcpy(enval, argv[1]); // 拷贝到缓冲区
        putenv(enval);          // 导出
        return 1;
    }
    else if (strcmp(argv[0], "echo") == 0)
    {
        if (argv[1] == NULL)
        {
            printf("\n");
            return 1;
        }
        else if (*(argv[1]) == '$' && strlen(argv[1]) > 1)
        {
            char *val = argv[1] + 1;
            if (strcmp(val, "?") == 0)
            {
                printf("%d\n", lastcode);
                lastcode = 0;
            }
            else
            {
                const char *env_val = getenv(val);
                if (env_val)
                    printf("%s\n", env_val);
                else
                    printf("\n");
            }
            return 1;
        }
        else
        {
            printf("%s\n", argv[1]);
            return 1;
        }
    }
    // 可以再列举更多内建命令
    return 0;
}

#define SkipSpace(pos)        \
    do                        \
    {                         \
        while (isspace(*pos)) \
            pos++;            \
    } while (0)

// 检查重定向
void checkRedir(char command[], int len)
{
    char *end = command + len - 1; // 从后向前面检查
    char *start = command;
    while (end > start)
    {
        if (*end == '>') // 输出重定向       ls -a -l >> log.txt
        {
            if (*(end - 1) == '>') // 追加重定向
            {
                *(end - 1) = '\0';
                filename = end + 1;
                SkipSpace(filename);
                redir = AppendRedir;
                break;
            }
            else
            {
                *end = '\0';
                filename = end + 1;
                SkipSpace(filename);
                redir = OutputRedir;
                break;
            }
        }
        else if (*end == '<') // 输入重定向
        {
            *end = '\0';
            filename = end + 1;
            SkipSpace(filename);
            redir = InputRedir;
            break;
        }
        else
        {
            end--;
        }
    }
}

int main()
{
    while (1)
    {
        char usercommand[NUM];
        // 打印命令行提示符 + 获取用户指令
        int flag = getUserCommand(usercommand, sizeof(usercommand));
        if (flag <= 0)
            continue;
        // 检测重定向
        checkRedir(usercommand, sizeof(usercommand));
        // 分割命令字符串
        char *argv[SIZE];
        commandSplit(usercommand, argv);
        // 判断内建命令
        int sign = isBuildinCommand(argv);
        if (sign)
            continue;
        // 执行命令
        excuteCommand(argv);
    }
    return 0;
}

朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，欲知后事如何，请听下回分解~，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！       

stackY、
关注
  • 15
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
emrex-shell：简单的shell模拟器
02-09
`emrex-shell`就是这样一个简化版的命令解释器，帮助初学者了解shell的工作流程。 ### 2. 命令解析 命令解析是shell的核心功能之一。在`emrex-shell`中，这通常包括分词（tokenizing）、命令查找和参数处理。分词是...
windows上linux命令工具 grep 等等
12-05
综上所述，这个压缩包为Windows用户提供了一个简易的Linux命令行环境，让用户无需完全安装Linux或使用虚拟机，也能在Windows上使用熟悉的Linux命令进行日常工作。通过解压并配置环境，用户可以在Windows的命令提示符...
【linux深入剖析】操作系统与用户之间的接口：自定义简易shell制作全过程
RO-BERRY
03-14 1261
首先做一个shell的目录，用来装我们的自定义shel然后在目录下创建Makefile文件以及myshell.c文件编写Makefile和myshell.c文件Makefile上面几步很好走，最重要的是我们的myshell.c文件应该如何去编写呢？
【Linux小练习】模拟简易的shell
weixin_51983604的博客
02-26 3880
文章目录一、进程程序替换一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 一、进程程序替换 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.f.
Linux模拟实现【简易版bash】
北 海的博客
03-22 4832
Linux 系统主要分为 内核(kernel) 和 外壳(shell)，普通用户是无法接触到内核的，因此实际在进行操作时是在和外壳程序打交道，在 shell 外壳之上存在 命令行解释器(bash)，负责接收并执行用户输入的指令，本文模拟实现的就是一个 简易版命令行解释器
进程程序替换+简易版shell实现
cxy_zjt的博客
05-14 440
进程程序替换 如何进行程序替换 不同程序替换函数之间的区别 系统接口调用其他语言的函数 替换函数execle 简易版shell实现
myshell_实现一个简易的myshell_
10-03
在本项目中，我们关注的是“myshell”的实现，这是一个简化版的shell程序，具有基本的命令处理能力，例如改变工作目录（cd命令）。我们将探讨如何构建这样一个程序，并了解它涉及到的关键知识点。 首先，我们要理解...
简易java运维工具
06-02
总结，"简易Java运维工具"是利用Java语言和Linux Shell命令相结合的利器，为系统管理员提供了强大的远程服务器管理能力。它不仅可以提升运维效率，还能确保服务的稳定性和安全性，是现代IT环境中不可或缺的一部分。...
simple_shell
04-06
在这个特定的案例中，"simple_shell" 可能是一个用C语言编写的简易版本的Unix/Linux shell。C语言是系统编程的首选语言之一，因为它允许低级别的内存管理和直接访问硬件资源。 描述中的 "初始化读我，待完成 马球" ...
LINUX:懒汉单例模式线程池
W2155的博客
07-16 446
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
定制 Linux 内核的意义
地球空间
07-17 287
2. **配置内核**：使用 `make menuconfig` 或 `make xconfig` 配置内核，选择需要支持的硬件和功能。1. **性能优化**：通过定制内核，可以针对特定的硬件或应用场景优化性能，比如减少不必要的驱动支持、优化调度算法等。7. **持续维护**：随着时间的推移，可能需要对内核进行更新和维护，以支持新的硬件和功能。6. **测试和调试**：启动系统，测试新内核的功能和性能，根据需要进行调试和优化。4. **安装内核**：编译完成后，将生成的内核镜像和相关的模块安装到系统中。
Qmi8658a姿态传感器使用心得（2）linux
Starry的博客
07-19 859
COD 原理，CTRL9，自检（详细代码示例）
【Linux杂货铺】期末总结篇4：shell编程
聆风吟的博客
07-17 3516
本文主要分享作者本人期末复习的总结，欢迎大家借鉴浏览。
文件在Linux下为binary格式在Windows下为utf-8格式
qq_38220334的博客
07-17 326
想着是不是之前遇到的问题，有可能是文件中含有特殊字符，然后用vim命令来编辑这个文件，发现，还真是含有一个特殊字符，然后将它删除掉，文件就变成utf-8格式的文件了。在Windows下和Mac下都是没有问题的，在华为云服务器上也是没问题的（操作系统不是centos），但是在自己搭建的Linux服务器（centos）上是有问题的。用shell或者Python脚本去将这个文件转为utf-8格式的，但是都失败了。
Linux 注意事项
最新发布
m0_74012211的博客
07-19 324
Linux 与 Windows 是两个相互独立的操作系统，两者有较大差距
【Linux】深入探索`cp`命令：文件复制的全面指南
lph159的博客
07-18 337
cp命令用于复制文件或目录的内容。cp [选项] 源文件 目标文件或目录使用cp命令可以在文件系统中创建新的副本，无论是单个文件还是整个目录树。接下来我们将详细介绍cp命令的各个选项及其用法。
【Linux】文件管理常用命令【超详细】
2301_82023330的博客
07-16 721
这篇博客介绍了Linux系统中的常用文件管理命令，包括`ls`、`cd`、`cp`、`mv`、`rm`和`mkdir`等。通过这些命令，用户可以高效地浏览目录、复制和移动文件、删除文件以及创建新目录。文章详细讲解了每个命令的基本用法和常见选项，并通过实例演示了这些命令在实际操作中的应用，帮助读者掌握文件管理的基本技能，提升Linux系统的使用效率。
单链表算法 - 环形链表II
黎相思的技术博客
07-17 450
- 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。那么为什么相遇点和头节点到入环节点的距离是相等的。. - 力扣（LeetCode）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

stackY、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值