Linux c编程之main函数参数解析与应用

已于 2022-11-20 14:38:39 修改
阅读量2.2k 收藏 18
点赞数 1
分类专栏： Linux C网络编程实践 文章标签： main argc argv hello world linux c
于 2022-11-16 14:17:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szkbsgy/article/details/127027406
版权

一、说明

  main函数是C语言程序的入口函数，也称为主函数，C程序都是从main函数开始执行的，必须为小写。函数原型有两种，一种带参数，一种不带参数，如下所示：

  • 带参数：int main(int argc, char *argv[])
  • 不带参数：int main(void)

在实际编程应用中，都是使用带参数的形式。不带参数的形式一般用于测试程序或demo等非正式场合。
程序中必须包含main()函数，否则编译不成功，提示错误如下：
undefined reference to `main’

二、 最简单的C程序：Hello world

2.1 示例代码

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("hello world\n");

    return 0;
}

2.2 编译

$ gcc  hello_world_main.c

2.3 运行

$ ./a.out 
hello world

2.4 Hello world 的起源

  “Hello,World!” 中文翻译为"你好，世界"， 在C语言编程中使用它做为第一个演示程序。后来程序员延用了这一习惯，在所有语言编程学习、代码工程创建、初始设备调试、第一次通信消息调试等场景中，广泛使用“hello world”作为软件工程的初步成果演示。

三、main函数参数

再来看原型：int main(int argc, char *argv[])
argc和argv是main函数的参数，argc是整型，表示参数的个数，argv是字符串数组，表示参数内容。
参数内容使用数据索引的形式进行引用。比如argv[0]、argv[1]……argv[n],意义如下：
argv[0]表示程序名称
argv[1]表示第一个参数
argv[2]表示第二个参数

示例代码：

#include <stdio.h>

int main(int argc, char *argv[])
{
    int i = 0;

    printf("argc: %d\n", argc);
    for (i = 0; i < argc; i++)
    {
        printf("argv[%d]: %s\n", i, argv[i]);
    }

    return 0;
}

运行：

不传入参数：

$ ./a.out 
argc: 1
argv[0]: ./a.out

传入一个参数：

$ ./a.out zhangsan
argc: 2
argv[0]: ./a.out
argv[1]: zhangsan

$ ./a.out zhangsan lisi
argc: 3
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: lisi

$ ./a.out zhangsan lisi 2 3
argc: 5
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: lisi
argv[3]: 2
argv[4]: 3

$ ./a.out zhangsan hello world
argc: 4
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: hello
argv[3]: world

$ ./a.out zhangsan hello\ world
argc: 3
argv[0]: ./a.out
argv[1]: zhangsan
argv[2]: hello world

关键说明：

  1. 参数以空格作为分隔符
  2. 参数个数是包含程序本身的
  3. 传入的参数无论是字符串还是数字，都按字符串引用
  4. argv[0]是带着路径的程序名
  5. 参数如果含有空格，需要使用\进行转义

四、main参数解析

  程序中直接用argv[1]、argv[2]来引用参数的话，那么传入参数位置和含义就是一一绑定的，如果传入参数的位置不对或少传参数，程序就会异常。如下示例：
示例代码：
TODO
正确传参顺序：

$ ./a.out zhangsan 18 dongdaihe 1
argv[1] name: zhangsan
argv[2] age: 18
argv[3] addr: dongdaihe
argv[4] marry: 1

顺序不一致：

$ ./a.out 18 zhangsan  1 dongdaihe
argv[1] name: 18
argv[2] age: zhangsan
argv[3] addr: 1
argv[4] marry: dongdaihe

少传参数：

$ ./a.out zhangsan dongdaihe 1
argv[1] name: zhangsan
argv[2] age: dongdaihe
argv[3] addr: 1
argv[4] marry: (null)

4.1 参数解析函数getopt

为了解决参数位置问题，可以使用getopt解决，原型如下：

#include <unistd.h>
int getopt(int argc, char * const argv[],
                  const char *optstring);
 extern char *optarg;
 extern int optind, opterr, optopt;

  getopt()函数传入命令行参数，argc和argv来源于main()函数的参数，分别表示参数个数和参数数组。以-开头的参数(argv[n])表示选项名称，通过循环调用getopt()函数可以遍历所有的选项，getopt()返回-1时，则表示参数扫描完成。
  变量optind是下一个要被处理的参数，系统初始值为1。用户可以将optind复位为1来重新开始扫描argv参数列表，或者在扫描新的参数数组时。
  getopt函数参数optstring表示支持的合法选项名称，一个字符表示一个选项，有三种用法：

  1. 如果选项后面没有冒号，表示该选项没有选项值。
  2. 如果选项后面有冒号，表示该选项有选项值，选项值为下一个argv参数
  3. 如果选项后面有两个冒号，表示该选项有一个可选的选项值，选项值要紧跟选项，中间不能有空格

getopt函数返回值：
4. 如果成功解析选项，则返回选项字符
5. 所有的参数解析完成时，返回-1
6. 如果遇到不认识的选项，则返回？
7. 如果遇到缺失参数的选项，则返回：

示例代码：

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

void usage(char *program)
{
    fprintf(stderr, "Usage: %s [-n name] [-a age] [-d addr] [-m] [-h]\n",
            program);
    printf("n: name\n");
    printf("a: age\n");
    printf("d: addr\n");
    printf("m: marry flag\n");
    printf("h: usage\n");
    printf("example: ./a.out -n zhangsan -a 18 -d dongdaihe -m\n");
}

int main(int argc, char *argv[])
{
    int opt = 0;

    while ((opt = getopt(argc, argv, "n:a:d:mh")) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
                break;
            case 'n':
                printf("name:%s\n", optarg);
                break;
            case 'a':
                printf("age:%d\n", atoi(optarg));
                break;
            case 'd':
                printf("addr:%s\n", optarg);
                break;
            case 'm':
                printf("already marry\n");
                break;
            default: /* '?' */
                usage(argv[0]);
                exit(-1);
        }
    }

    return 0;
}

运行：

$ ./a.out 
Usage: ./a.out [-n name] [-a age] [-d addr] [-m] [-h]
n: name
a: age
d: addr
m: marry flag
h: usage
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m

$ ./a.out -n zhangsan -a 18 -d dongdaihe -m
name:zhangsan
age:18
addr:dongdaihe
already marry

$ ./a.out -n zhangsan -a 18 -d dongdaihe -m -o
name:zhangsan
age:18
addr:dongdaihe
already marry
no option value

$ ./a.out -n zhangsan -a 18 -d dongdaihe -m -ohello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

缺少参数：

$ ./a.out -n zhangsan -a 18 -d
name:zhangsan
age:18
./a.out: option requires an argument -- 'd'
Usage: ./a.out [-n name] [-a age] [-d addr] [-m] [-h]
n: name
a: age
d: addr
m: marry flag
h: usage
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m

$ ./a.out -n zhangsan
name:zhangsan

$ ./a.out -h
Usage: ./a.out [-n name] [-a age] [-d addr] [-m] [-h]
n: name
a: age
d: addr
m: marry flag
h: usage
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m

关键说明：

  1. 长选项可以使用=赋值
  2. 可选参数必须使用=赋值
  3. 通常使用usage()函数来提示用户程序及参数的使用说明
  4. usage()一般在输入参数不合法或不满足要求时调用

4.2 参数解析函数getopt_long

  getopt虽然能解决参数位置问题，但以单字符为选项参数不便于用户记忆和理解，程序员编程调试时也会增加耗时。因此需要一种可理解的字符串（单词或词组)形式的选项名称。Getopt_long()函数可以解决此问题。
getopt_long原型：

#include <getopt.h>

int getopt_long(int argc, char * const argv[],
              const char *optstring,
              const struct option *longopts, int *longindex);

函数说明：
  getopt_long()函数像getopt函数一样工作，除此之外，还支持长选项，长选项以两个“-”开头，如–name.如果程序只接受长选项，可以将短选项optstring指定为""即可，但不能是NULL。长选项可以带一个参数，使用形式可以是–arg=param 或者 --arg param。
函数参数说明：

  • longopts : 指向struct option的结构体数组，数组最后一个元素要求为0.
    长参数是一个结构体，如下：
    struct option {
    const char *name;
    int has_arg;
    int *flag;
    int val;
    };
    name: 长选项的名称
    has_arg: 是否有选项值参数，取值有3种：
    no_argument： 没参数
    required_argument： 有参数
    optional_argument： 可选参数
  • flag:指定如何返回长选项的结果，有以下情况:
  1. 如果flag是NULL,则getopt_long()返回val(val一般被设置为短选项名称）
  2. 如果flag不是NULL，则flag在选项被找到时，设置为val的值

  • val: 返回值

  • longindex: 如果该参数不为空，则该值被设置为解析成功的长选项在longopts数组中的索引值

getopt_long()如果识别到是短选项时，则返回短选项字符。对长选项，如果flag是NULL，则返回val,否则返回0.错误则返回-1.
getopt_long返回值：
1.如果成功解析选项，则返回选项字符
2.所有的参数解析完成时，返回-1
3.如果遇到不认识的选项，则返回？
4.如果遇到缺失参数的选项，则返回：
5. 如果识别到是短选项时，则返回短选项字符
6. 对长选项，如果flag是NULL，则返回val,否则返回0.错误则返回-1.

示例代码：

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

static struct option long_opts[] = {
    { "help", no_argument, NULL, 'h' },
    { "name", required_argument, NULL, 'n' },
    { "age", required_argument, NULL, 'a' },    
    { "addr", required_argument, NULL, 'd' },    
    { "marry", no_argument, NULL, 'm' },    
    { "option", optional_argument, NULL, 'o' },
    { 0, 0, 0, 0 },
};

void usage(char *program)
{
    fprintf(stderr, "Usage: %s [--name name] [--age age] [--addr addr] [--marry [--help] [--option option]\n",
            program);
    printf("example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption\n");
    printf("example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello\n");
}

int main(int argc, char *argv[])
{
    int flags = 0;
    int opt = 0;
    int nsecs = 0;
    char info[32] = {0};
    int option_index = 0;

    if (argc < 2) {
        usage(argv[0]);
        exit(1);
    }

    while ((opt = getopt_long(argc, argv, "n:a:d:mho::", long_opts, &option_index)) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
                break;
            case 'n':
                printf("name:%s\n", optarg);
                break;
            case 'a':
                printf("age:%d\n", atoi(optarg));
                break;
            case 'd':
                printf("addr:%s\n", optarg);
                break;
            case 'm':
                printf("already marry\n");
                break;
            case 'o':
                if (!optarg) {
                    printf("no option value\n");
                } else {
                    printf("option value:%s\n", optarg);
                }
                break;
            default: /* '?' */
                usage(argv[0]);
                exit(-1);
        }
    }

    return 0;
}

运行：
支持短选项：

./a.out -n zhangsan -a 18 -d dongdaihe -m -ohello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

选项与值可以用空格分开，也可以用“=”

$ ./a.out --name zhangsan --age 18
name:zhangsan
age:18

$ ./a.out --name=zhangsan --age=18
name:zhangsan
age:18

可选参数：

$ ./a.out --option=6
option value:6

$ ./a.out --option
no option value

$ ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

使用说明：

$ ./a.out -h
usage: ./a.out [--name name] [--age age] [--addr addr] [--marry [--help] [--option option]
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption
example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello

$ ./a.out --help
Usage: ./a.out [--name name] [--age age] [--addr addr] [--marry [--help] [--option option]
example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption
example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello

五、实际应用

5.1 通过文件传递命令行参数

  如果程序的启动参数太多，导致启动的命令行太长，每次输入命令行参数耗时太多，也容易出现漏参数或输入错误的问题。虽然实际应用中，可以写到脚本中，避免输入问题，但同样看起来混乱，不清晰。为了解决上述问题，有一种解决方法是：将参数写到参数配置文件中，每个选项/参数为一行，命令行只传入一个带路径的配置文件名，由程序自己读取文件中参数并存储到argv数组中，再调用命令行解析函数getopt_long()进行后续解析。

源码解析：



static struct option long_opts[] = {
    { "help", no_argument, NULL, 'h' },
    { "config_file", required_argument, NULL, 'c' },
    { "name", required_argument, NULL, 'n' },
    { "age", required_argument, NULL, 'a' },    
    { "addr", required_argument, NULL, 'd' },    
    { "marry", no_argument, NULL, 'm' },    
    { "option", optional_argument, NULL, 'o' },
    { 0, 0, 0, 0 },
};

int load_cfg_file(char *cfg_file, int *argc, char *argv[])
{
    FILE *fp = NULL; 
    char buf[1024] = {0};
    char *p = NULL;

    fp = fopen(cfg_file, "r");
    if (!fp) {
        printf("open cfg file[%s] failed \n", cfg_file);
        return -1;
    }

    while (fgets(buf, sizeof(buf), fp)) {
        if (buf[0] == '#') {
            continue;
        }
        buf[strlen(buf) - 1] = '\0';
        p = (char *)malloc(strlen(buf));
        memset(p, 0, sizeof(strlen(buf)));
        memcpy(p, buf, strlen(buf));
        argv[*argc] = p;
        *argc += 1;
    }
}

void usage(char *program)
{
    fprintf(stderr, "Usage: %s [--name name] [--config_file file] [--age age] [--addr addr] [--marry [--help] [--option option]\n",
            program);
    printf("example: ./a.out -n zhangsan -a 18 -d dongdaihe -m -ooption\n");
    printf("example: ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello\n");
    printf("example: ./a.out --config_file file\n");
}


int parse_args(int argc, char *argv[])
{
    int opt = 0;
    int option_index = 0;
    int original_argc = 0;

    if (argc < 2) {
        usage(argv[0]);
        exit(1);
    }
    optind = 1;
    while ((opt = getopt_long(argc, argv, "n:a:c:d:mho::", long_opts, &option_index)) != -1) {
        switch (opt) {
            case 'h':
                usage(argv[0]);
                break;
            case 'c':
                /* already processed before, must ignore */
                break;
            case 'n':
                printf("name:%s\n", optarg);
                break;
            case 'a':
                printf("age:%d\n", atoi(optarg));
                break;
            case 'd':
                printf("addr:%s\n", optarg);
                break;
            case 'm':
                printf("already marry\n");
                break;
            case 'o':
                if (!optarg) {
                    printf("no option value\n");
                } else {
                    printf("option value:%s\n", optarg);
                }
                break;
            default: /* '?' */
                usage(argv[0]);
                exit(-1);
        }
    }

    return 0;
}

int main(int argc, char *argv[])
{
    int i = 0;
    int opt = 0;
    int option_index = 0;
    int original_argc = 0;

    if (argc < 2) {
        usage(argv[0]);
        exit(1);
    }

    original_argc = argc;
    while ((opt = getopt_long(argc, argv, "n:a:c:d:mho::", long_opts, &option_index)) != -1) {
        switch (opt) {
            case 'c':
                load_cfg_file(optarg, &argc, argv);
                break;
        }
    }

    parse_args(argc, argv);

    for (i = original_argc; i < argc; i++) {
        if (argv[i]) {
            free(argv[i]);
        }
    }
    //release argc

    return 0;
}

运行：

$ cat file.cfg 
--name=zhangsan
--age=18
--addr=dongdaihe
--marry
--option=hello

$ ./a.out  --config_file file.cfg 
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

$ ./a.out --name=zhangsan --age=18 --addr dongdaihe --marry --option=hello
name:zhangsan
age:18
addr:dongdaihe
already marry
option value:hello

文件参数+命令行参数：

$ cat file.cfg 
--name=zhangsan
--age=18
--addr=dongdaihe
--marry

$ ./a.out  --config_file file.cfg --option=hello
option value:hello
name:zhangsan
age:18
addr:dongdaihe
already marry

关键说明：

  1. 从文件中加载参数后，再次解析时要忽略配置文件参数，否则会出现死循环
  2. 加载配置文件参数时，需要分配空间
  3. 解析参数后，需要释放为文件中参数分配的空间
  4. 可以从配置文件和命令行同时传入配置参数
浪游东戴河
关注
专栏目录
Linux C编程学习--main()函数简析
知秋一叶
12-11 2310
提到C语言的函数，有太多内容要讲，今天我们要看的是main()函数。 main()函数时程序的入口点，任何程序都要有main()函数，一般大家都怎么写main()函数啊？ main(); void main(); void main(void); int main(); int main(void); int main(int argc,char * argv[]); 好像哪种都可
[Pthread] Linux上程序执行的入口--Main
Javadino的专栏
09-06 2239
    main()函数，想必大家都不陌生了，从刚开始写程序的时候，大家便开始写main(),我们都知道main是程序的入口。那main作为一个函数，又是谁调用的它，它是怎么被调用的，返回给谁，返回的又是什么？这次我们来探讨一下这个问题。1. main()函数的形式先来说说main函数的定义，较早开始写C程序的肯定都用过这样的定义void main(){}，其实翻翻C/C++标准，从来没有定义过v
C语言中main函数的参数
热门推荐
cnctloveyu的专栏
02-18 3万+
我们经常用的main函数都是不带参数的。因此main 后的括号都是空括号。实际上，main函数可以带参数，这个参数可以认为是 main函数的形式参数。Ｃ语言规定main函数的参数只能有两个， 习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为： main (argc,argv)Ｃ语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组
有关main函数参数的理解与使用
最新发布
liuty0125的博客
09-25 1211
在平时编写代码的过程中，我们会经常写main函数，这是一个程序必不可少的，main 函数是一个特殊的函数，它是程序执行的入口点，但我们往往都没有在意或使用main函数的参数，但main函数其实是有自己自带的参数类型的，只是我们一般没有用到。
linux c main函数参数
weixin_30664539的博客
01-05 98
main函数有两个参数 main(int argc,char *argv[]） 第一个是整型代表整个参数的个数； 第二个是字符型数组，argv【0】是指指令，也就是一般c程序的文件名（在Linux环境下是编译好的可执行文件名），argv【1】、argv【2】.......都是相应的参数。 例如：我编了一段程序是将file1的程序拷贝到file2中，同时我的c语言代码编译后的可执行文件名...
Linux C程序main函数参数
qq_38684512的博客
11-22 303
C程序main函数参数Window和WinMain函数Linux和标准main函数demo执行结果 Window和WinMain函数 Windows下的C程序的入口函数 不调用标准的main函数 而调用Windows特有的WinMain函数 Linux和标准main函数 Linux下调用标准的main函数 主要有三个参数 1.argc = 程序命令行参数的个数 2.argv = 命令行参数串指针数...
Linux C编程：main函数参数与递归函数解析
"这篇文档主要介绍了Linux环境下的C语言编程中的三个关键知识点：1) main函数接收命令行参数，2) 递归函数的概念及如何编写，以及3) 使用GDB进行程序调试。通过示例代码，分别展示了如何处理main函数的argc和argv...
Linux环境高级编程：main函数与命令行参数解析
"LINUX环境高级编程，主要探讨了进程管理，特别是main函数和命令行参数的使用，以及进程的启动、终止和相关概念。" 在Linux环境的高级编程中，进程管理是至关重要的部分。程序的执行通常始于`main`函数，它是每个C...
Linux并发编程：C语言fork()函数解析与应用
"本文主要探讨了在Linux环境下，如何利用C语言中的fork()函数进行并发编程，包括子进程的创建、父子进程的区别以及fork函数的使用限制和常见用途。" 在Linux操作系统中，C语言的并发编程往往依赖于内核提供的系统...
C语言入门：main函数参数解析与简单程序示例
"这篇PPT主要讲解了C语言中的main函数参数以及C语言的基本概念，包括它的历史、特点、优缺点、基本结构和GCC编译器的使用。" 在C语言编程中，`main`函数是每个程序的起点，它是程序执行的入口点。通常，`main`函数...
Linux系统中C语言编程创建函数fork()执行解析
09-05
在Linux系统中，C语言编程时常常会遇到进程间的通信问题，其中`fork()`函数扮演着重要的角色。`fork()`函数允许一个正在运行的进程（称为父进程）创建一个新的进程（称为子进程）。这个过程是通过复制父进程的大部分...
【Linux】函数与参数
ajsyipsc40270的博客
12-18 146
函数的定义函数的定义包括function命令、函数名、开/闭括号包括以及包含在一对花括号中的函数体。（1） 函数定义function fname(){Statements;}或者fname (){Statements;}或者fname() { Statements; }（2） 使用函数名即可调用函数$ fname（3） 含参数的函数调用$ fname arg1 arg2 以下是函数的访问...
linux C main()函数参数解析
dragon_cdut的博客
05-24 1771
j假设一个源文件编译生成xx.out文件，在终端传递参数到main()函数 $./xx.out val1 $./xx.out val1 val2 多个参数以此类推 void main(argc,char **argv); @param argc: 控制台传递参数个数，至少为1个，因为argv[0]=xx.out @param argv:双重指针，指向一个指针数组，argv[0]=xx.
linux下c编程main函数的参数问题
听着程序唱着歌。。。
07-22 1万+
在做linux下的应用编程时，main函数被定义成这个样子： int main(char argc,char *argv[]) 这两个参数是做什么用的呢？又怎么在程序中使用呢？ 官方的说明是：argc保存的是命令行参数的数目，而argv是指向个参数的各指针所构成的数组。 弄个测试程序测试下看看。 建一个名为test.c的c文件。 #include int main(char
main函数的参数解析
飞奔的蜗牛
07-26 2708
1。
main函数
weixin_33895016的博客
10-10 248
c程序最大的特点就是所有的程序都是用函数来装配的。main()称之为主函数，是所有程序运行的入口。其余函数分为有参或无参两种，均由main()函数或其它一般函数调用，若调用的是有参函数，则参数在调用时传递。main(){...y1=f1(x1,x2);...}f1(int a,int b){....y2=f2(x3,x4);....}f2(int m,int n){........
七、Linux文件 - main函数参数讲解、代码实现cp指令
weixin_52872520的博客
02-10 864
七、Linux文件 - main函数参数讲解、代码实现cp指令 1、main函数参数 2.cp指令的使用 3、实现cp指令 3.1实现cp指令-入门版 3.2实现cp指令-进阶版
main主函数参数解析
Half-up的博客
03-31 2012
其中，int 是主函数的返回值类型，主函数执行完后会返回一个整数值给操作系统，通常是主函数的参数列表: 主要用于命令行argc：表示命令行参数的个数（argument count），即程序被调用时在命令行中输入的参数的总数（包括程序本身），其中至少有一个参数，即程序本身。例如，输入命令 “./my_program file1.txt file2.txt”，则 argc 的值为 3。argv[]：表示命令行参数的数组。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

浪游东戴河

你就是这个世界的唯一

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

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

打赏作者

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

抵扣说明：

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

余额充值