C语言学习笔记——Day 04 数组

最新推荐文章于 2024-09-30 21:45:17 发布
最新推荐文章于 2024-09-30 21:45:17 发布
阅读量253 收藏
点赞数
分类专栏： C语言学习 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49064660/article/details/119725519
版权

一、一维数组的创建和初始化 

1、什么是数组：

数组是一组相同类型元素的集合。

2、数组的创建方式：

type_t arr_name [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小。

//数组创建实例：

//代码1
int arr1[10];

//代码2
int count = 10;
int arr2[count];

//代码3
char arr3[10];
float arr4[20];
double arr5[30];

 注：数组的创建， [] 中要给一个常量才可以，不能使用变量。

3、数组的初始化：

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。

#include <stdio.h>
#include <string.h>

int main()
{
    int arr1[10] = {1,2,3};//不完全初始化,剩下的元素默认初始化为0
    char arr2[5] = {'a', 'b'};//'a','b','0','0','0'
    char arr3[5] = "ab";//'a','b','\0','0','0'
    char arr4[] = "abcdef";//'a','b','c','d','e','f','\0'
    printf("%d\n",sizeof(arr4));
    printf("%d\n",strlen(arr4));
    return 0;
}

程序运行结果：

  strlen和sizeof的区别：

①strlen是求字符串的长度，它只能是针对字符串长度。strlen是库函数，使用时必须使用头文件。
②sizeof用于计算变量，数组、类型的大小。单位是字节，sizeof是操作符。

二、一维数组的使用

对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。

#include <stdio.h>
#include <string.h>

int main()
{
    char arr[] = "abcdef";
    int i = 0;
    for(i = 0;i<strlen(arr);i++)
    {
        printf("%c ",arr[i]);
    }
    printf("\n");
    int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    int sz =sizeof(arr1)/sizeof(arr1[0]);
    int j = 0;
    for(j = 0;j<sz;j++)
    {
        printf("%d ",arr1[j]);
    }
    return 0;
}

 程序运行结果：

总结：
① 数组是使用下标来访问的，下标是从0开始。
② 数组的大小可以通过计算得到。

三、一维数组在内存中的存储

通过编写程序获得一个数组在内存中的地址。

#include <stdio.h>

int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    int i;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i =0;i<sz;i++)
    {
        printf("arr[%d] = %p\n",i,&arr[i]);
    }
    return 0;
}

  程序运行结果：

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的。

四、 二维数组的创建，初始化和使用

1、二维数组的创建：

//数组创建
int arr1[3][4];
char arr2[3][4];
double arr3[3][4];
float arr4[3][4];

 2、二维数组的初始化：

//二维数组的初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{3,4}};
int arr[][4] = {{2,3},{4,5}};

 3、二维数组的使用：

二维数组的使用也是通过下标的方式。

#include <stdio.h>

int main()
{
    int arr[3][4] = {1,2,3,4,5,6,7,8};//三行四列数组
    int i = 0,j = 0;
    for(i = 0;i<3;i++)
    {
        for(j = 0;j<4;j++)
        {
            printf("arr[%d][%d] = %d\t",i,j,arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

 程序运行结果：

 五、二维数组在内存中的存储

打印二维数组的每个元素。

#include <stdio.h>

int main()
{
    int arr[3][4] = {1,2,3,4,5,6,7,8};//三行四列数组
    int i = 0,j = 0;
    for(i = 0;i<3;i++)
    {
        for(j = 0;j<4;j++)
        {
            printf("arr[%d][%d] = %d\t",i,j,arr[i][j]);
        }
        printf("\n");
    }
    for(i = 0;i<3;i++)
    {
        for(j = 0;j<4;j++)
        {
            printf("arr[%d][%d] = %p\t",i,j,&arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

 程序运行结果：

 通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

 六、数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就
是正确的，所以程序员写代码时，最好自己做越界的检查。

八、数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数。

比如：我要实现一个冒泡排序函数将一个整形数组排序。

//冒泡排序
#include <stdio.h>

int bubble_sort(int arr[],int sz)
{
    //确定冒泡排序的趟数
    int i = 0;
    for(i = 0;i<sz-1;i++)
    {
        //每一趟冒泡排序
        int j = 0;
        for(j = 0;j<sz-i;j++)
        {
            if(arr[j] > arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return arr;
}
int main()
{
    int arr[] = {5,7,3,9,1,4,8,2,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
    //对数组arr进行升序排列
    bubble_sort(arr,sz);//冒泡排序函数
    int i = 0;
    for(i = 0;i<sz;i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

程序运行结果：

 优化：

//冒泡排序
#include <stdio.h>

int bubble_sort(int arr[],int sz)
{
    //确定冒泡排序的趟数
    int i = 0;
    for(i = 0;i<sz-1;i++)
    {
        //每一趟冒泡排序
        int flag = 1;
        int j = 0;
        for(j = 0;j<sz-i;j++)
        {
            if(arr[j] > arr[j+1])
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag = 0;
            }
        }
    if(flag == 1)
    {
        break;
    }
    }
    return arr;
}
int main()
{
    int arr[] = {5,7,3,9,1,4,8,2,6};
    int sz = sizeof(arr)/sizeof(arr[0]);
    //对数组arr进行升序排列
    bubble_sort(arr,sz);//冒泡排序函数
    int i = 0;
    for(i = 0;i<sz;i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

程序运行结果：

 数组名是什么？

数组名是数组首元素的地址。（有两个例外： sizeof(数组名)，&数组名）

//数组名
#include <stdio.h>

int main()
{
    int arr[10] = {1,2,3,4,5};
    printf("%p\n",arr);
    printf("%p\n",&arr[0]);
    printf("%d\n",*arr);//对数组名解引用，看结果是否是arr的首元素
    printf("%d\n",sizeof(arr));//sizeof内部单独放一个数组名，数组名表示整个数组。
    printf("%p\n",&arr);//取出的是整个数组的地址。&数组名，数组名表示整个数组。
    return 0;
}

程序运行结果：

1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。
2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

arr+1表示第二个元素的地址，等效于arr[0]+1；而&arr+1表示arr最后一个元素后接着的那个地址，arr+1表示跳过整个数组，得到整个数组结束后所接着的地址。

九、数组的应用实例1：三子棋

三子棋游戏程序代码：

//三子棋游戏
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ROW 3
#define COL 3

void menu()
{
    printf("------------------------------\n");
    printf("----------1.开始游戏----------\n");
    printf("----------2.退    出----------\n");
    printf("------------------------------\n");
    return 0;
}

//初始化棋盘
void InitBoard(char board[ROW][COL],int row,int col)
{
    int i = 0,j = 0;
    for(i = 0;i<row;i++)
    {
        for(j = 0;j<col;j++)
        {
            board[i][j] = ' ';//将数组内的每个元素改写为空格
        }
    }
    return 0;
}

//打印棋盘
void Display(char board[ROW][COL],int row,int col)
{
    int i = 0,j = 0;
    for(i = 0;i<row;i++)
    {
        //打印数组行数据
        for(j = 0;j<col;j++)
        {
            if(j<col-1)
            {
                printf(" %c |",board[i][j]);
            }
            else
            {
                printf(" %c \n",board[i][j]);
            }
        }
        //打印分割行
        if(i<row-1)
        {
            int n;
            for(n = 0;n<row;n++)
            {
                if(n<row-1)
                {
                    printf("---|");
                }
                else
                {
                    printf("---\n");
                }
            }
        }
    }
    return 0;
}

void Player(char board[ROW][COL],int row,int col)
{
    int x = 0,y = 0;
    printf("玩家：\n");
    printf("请输入棋子的坐标：");
    again:
        scanf("%d%d",&x,&y);
    if(x>=1 && x<=row && y>=1 && y<=col)
    {
        if(board[x-1][y-1] == ' ')
        {
            board[x-1][y-1] = '*';
        }
        else
        {
            printf("该坐标已被占用！请重新输入：");
            goto again;
        }
    }
    else
    {
        printf("您输入的坐标超出棋盘，请重新输入：");
        goto again;
    }
    return 0;
}

Computer(char board[ROW][COL],int row,int col)
{
    int x = 0,y = 0;
    printf("电脑：\n");
    while(1)
    {
        x = rand()%row;
        y = rand()%row;
        if(board[x][y] == ' ')
        {
            board[x][y] = '#';
            break;
        }
    }
    return 0;
}

int IsFull(char board[ROW][COL],int row,int col)
{
    int i= 0,j = 0;
    for(i = 0;i<row;i++)
    {
        for(j = 0;j<col;j++)
        {
            //棋盘没满
            if(board[i][j] == ' ')
            {
                return 0;
            }
        }
    }
    //棋盘满了
    return 1;
}

char IsWin(char board[ROW][COL],int row,int col)
{
    int i;
    //玩家赢或者电脑赢
    for(i = 0;i<row;i++)
    {
        //横三行
        if(board[i][0] == board[i][1] && board[i][0] == board[i][2] && board[i][0] != ' ')
        {
            return board[i][0];
        }
        //竖三列
        else if(board[0][i] == board[1][i] && board[0][i] == board[2][i] && board[0][i] != ' ')
        {
            return board[0][i];
        }
        //对角线
        else if((board[1][1] == board[0][0] && board[1][1] == board[2][2] && board[1][1] != ' ') || (board[1][1] == board[0][2] && board[1][1] == board[2][0] && board[1][1] != ' '))
        {
            return board[1][1];
        }
    }
    //平局
    if(1 == IsFull(board,ROW,COL))
    {
        return 'Q';
    }
    //继续
    return 'C';
}

//启动游戏
void game()
{
    //定义一个数组存放玩家出棋的数据
    char board[ROW][COL] = {0};
    //初始化棋盘
    InitBoard(board,ROW,COL);
    //打印棋盘
    Display(board,ROW,COL);
    //下棋
    while(1)
    {
        //玩家
        Player(board,ROW,COL);
        //打印棋盘
        Display(board,ROW,COL);
        //判断谁赢了
        if(IsWin(board,ROW,COL) == '*')
        {
            printf("恭喜你，你赢了！\n");
            break;
        }
        else if(IsWin(board,ROW,COL) == 'Q')
        {
            printf("平局！\n");
            break;
        }
        //电脑
        Computer(board,ROW,COL);
        //打印棋盘
        Display(board,ROW,COL);
        if(IsWin(board,ROW,COL) == '#')
        {
            printf("很遗憾，你输了！\n");
            break;
        }
//        else if(IsWin(board,ROW,COL) == 'Q')
//        {
//            printf("平局！\n");
//            break;
//        }
    }
    return 0;
}

void test()
{
    int input = 0;
    srand((unsigned int)time(NULL));
    do
    {
        menu();
        printf("请选择；");
        scanf("%d",&input);
        switch(input)
        {
        case 1:
            printf("游戏开始\n");
            game();//调用game函数，启动游戏
            break;
        case 2:
            printf("退出游戏\n");
            input = 0;
            break;
        default:
            printf("输入有误，请重新输入！\n");
            break;
        }
    }while(input);
    return 0;
}

int main()
{
    test();
    return 0;
}

程序运行结果：

十、数组的应用实例2：扫雷游戏

main.c

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

menu()
{
    printf("********************\n");
    printf("****1、开始游戏*****\n");
    printf("****2、退    出*****\n");
    printf("********************\n");
    printf("********************\n");
}

void game()
{
    //雷的数据存储
    //1、布置好的雷的信息
    char mine[ROWS][COLS] = {0};//11*11
    //排查出的雷的信息
    char show[ROWS][COLS] = {0};
    //初始化
    InitBoard(mine,ROWS,COLS,'0');
    InitBoard(show,ROWS,COLS,'*');
    //打印棋盘
    //DisplayBoard(mine,ROW,COL);
    DisplayBoard(show,ROW,COL);
    //布置雷
    SetMine(mine,ROW,COL);
    DisplayBoard(mine,ROW,COL);
    //扫雷
    FindMine(mine,show,ROW,COL);

    return 0;
}

void test()
{
    srand((unsigned int)time(NULL));
    int input = 0;
    do
    {
        menu();
        printf("请选择：\n");
        scanf("%d",&input);
        switch(input)
        {
        case 1:
            game();
            break;
        case 2:
            printf("退出游戏！\n");
            input = 0;
            break;
        default:
            printf("选择错误，重新选择！\n");
            break;
        }
    }while(input);
}

int main()
{
    test();
    return 0;
}

game.c

#include "game.h"

void InitBoard(char board[ROWS][COLS],int rows,int cols,char set)
{
    int i = 0;
    int j = 0;
    for(i = 0; i < rows; i++)
    {
        for(j = 0; j < cols; j++)
        {
            board[i][j] = set;
        }
    }
}

void DisplayBoard(char board[ROWS][COLS],int row,int col)
{
    int i = 0;
    int j = 0;
    //打印列号
    for(i = 0; i <= row;i++)
    {
        printf("%d ",i);
    }
    printf("\n");
    for(i = 1; i <= row; i++)
    {
        printf("%d ",i);
        for(j =1 ; j <= col; j++)
        {
            printf("%c ",board[i][j]);
        }
        printf("\n");
    }
}

void SetMine(char board[ROWS][COLS],int row,int col)
{
    int count = EASY_COUNT;
    while(count)
    {
        int x = rand()%row+1;
        int y = rand()%col+1;
        if(board[x][y] == '0')
        {
            board[x][y] = '1';
            count--;
        }
    }
}

int get_mine_count (char mine[ROWS][COLS],int x,int y)
{
    return mine[x-1][y]+
           mine[x-1][y-1]+
           mine[x][y-1]+
           mine[x+1][y-1]+
           mine[x+1][y]+
           mine[x+1][y+1]+
           mine[x][y+1]+
           mine[x-1][y+1]-8*'0';

}

void FindMine(char mine[ROWS][COLS],char show[ROWS][COLS],int row,int col)
{
    int x = 0;
    int y = 0;
    int win =0;
    while(win < row*col - EASY_COUNT)
    {
        printf("请输入要排查雷的坐标：");
        scanf("%d%d",&x,&y);
        if(x>=1 && x<row && y>=1 && y<col)
        {
            //坐标合法
            //1、踩雷了
            if(mine[x][y] == '1')
            {
                printf("很遗憾，你踩雷了！\n");
                DisplayBoard(mine,row,col);
                break;
            }
            //2、没有踩雷，统计坐标周围有几个雷
            else
            {
                int count = get_mine_count(mine,x,y);
                show[x][y] = count + '0';
                DisplayBoard(show,row,col);
                win++;
            }
        }
        else
        {
            printf("坐标非法，请重新输入！");
        }
    }
    if(win == row*col-EASY_COUNT)
    {
        printf("恭喜你，排雷成功！");
    }
}

game.h

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

#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2

#define EASY_COUNT 10


void InitBoard(char board[ROWS][COLS],int rows,int cols,char set);
void DisplayBoard(char board[ROWS][COLS],int row,int col);
void SetMine(char board[ROWS][COLS],int row,int col);
void FindMine(char mine[ROWS][COLS],char show[ROWS][COLS],int row,int col);

四石先生
关注
专栏目录
java基础语法 --- day04 --- 数组
xrzyxbc的博客
10-12 166
数组 1.数组概述 数组是一个类型的所有数据的一个集合，并用一个数组下标来区分或指定每一个数。数组的下标是从0开始的。 数组的定义： 数组是相同类型数据的有序集合. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们. 数组的四个基本特点： 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 其元素必须是相同类型,不允许出现混合类型。 数组.
数组名 int a[5] = {1,2,3,4,5}; int *ptr = (int *)( &a + 1);
热门推荐
liuxufei1996的博客
09-04 1万+
#include &lt;stdio.h&gt; int main() { int a[5] = {1,2,3,4,5}; int *ptr = (int *)( &amp;a + 1); printf("%d, %d, \n", *(a+1), *(ptr-1) ); return 0; } result： 2 ,5 , 数组名 a 的特殊之处： &amp;a  ：   代...
随机生成一个长度为8的数组
Cinderellahh92的博客
06-03 993
new Array(8).fill(0).map(item=>item=Math.floor(Math.random() * (300- 10) + 10))
在一个有序（增序）数组中查找具体的某个数字n 与二分法查找算法
qq_49708914的博客
11-19 355
在一个有序（增序）数组中查找具体的某个数字n 在 #include<stdio.h> void main() { int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int k = 7; int i = 0; int sz = sizeof(arr) / sizeof(arr[0]);//计算元素个数 for (i = 0; i < sz; i++) { if (k == arr[i]) { printf("找到了，
C语言学习笔记——Day 03 函数
weixin_49064660的博客
08-13 287
一、函数是什么 维基百科中对函数的定义：子程序 在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method,subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。 函数的分类： 1、库函数； 2、自定义函数； 二、库函数 为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序
c语言学习笔记——数组和指针
za36mize的博客
03-20 312
1.数组的声明char name[10];int   number[200], value[5][12];name是一个长度为10的数组，其中每一个元素的类型是char。number是一个长度为200的数组，其中每一个元素的类型是int。value是一个5*12的二维数组每个元素的类型是int数组元素的下标从0开始，即name[0],number[0],value[0][0]分别表示第一个元素。数...
种子C语言学习笔记——数组
种子播放者__学习笔记
03-08 228
数组学习笔记： 数组 float candy[365]; /*内含365个float类型元素的数组*/ char code[22]; /*内含22个char类型元素的数组*/ int states[50]; /*内含50个int类型元素的数组*/ [ ]表示candy，code，states都是数组，数字表明数组中的元素个...
C语言学习笔记——循环章节
墨辰JC的博客
07-25 288
c语言循环章节的学习笔记整理！（零基础入门笔记）
C语言学习笔记——函数
JiangNan_1002的博客
01-11 1163
函数的定义、头文件、函数调用机制、函数递归调用、函数的注意事项、函数参数的传递方式、变量的作用域、static关键字、字符串中常用的系统函数、时间和日期相关函数、数学相关函数、基本数据类型和字符串类型的转换
C语言学习笔记
01-30
标题与描述均提到了"C语言学习笔记"，这意味着文档聚焦于C语言的基础知识与实践技巧。C语言是一种广泛使用的高级编程语言，以其高效性、灵活性和底层硬件控制能力著称，是许多操作系统、嵌入式系统及游戏开发的首选...
嵌入式c语言——学习笔记
weixin_54950512的博客
02-04 183
嵌入式c语言——学习笔记3 一、指针的运用 最普通的指针：int *a; 调用形式： 1、a——a指向的对象的地址 2、a——a指向的对象的值3、&a——a自身的地址 常用来作为参数，调用数组，加上一个说明数组的长度的，从而获取不定大小的数组 第二种： int a[N] //指针数组，包含N个整型指针 对应地： int (*a)[N] //数组指针，指向大小为N的数组 嵌入式编程中常见对寄存器进行读写的： 特别的： *(int*)(addr) //addr为地址，通常形式为0.
c语言如何宏定义枚举型结构体,C语言学习笔记--枚举&结构体
weixin_33767088的博客
05-25 1066
枚举枚举是一种用户定义的数据类型，它用关键字enum以如下语法格式来声明：enum 枚举类型名字 {名字0，名字1，。。。，名字n}；枚举类型名字通常并不真的使用，要用的是大括号里面的名字，因为它们就是常量符号，它们的类型是int，值则依次从0到n。如：enum color{red,yellow,green};就创建了3个常量，red的值是0，yellow的值是1，green的值是2。当需要一些可...
C语言 学习笔记—标准库
weixin_45243288的博客
11-04 391
C语言学习——标准库C 标准库 - < assert.h >C 标准库 - < ctype.h >C 标准库 - < errno.h >C 标准库 - < float.h >C 标准库 - < limits.h >C 标准库 - < locale.h >C 标准库 - < math.h >C 标准库 - < setjmp.h >C 标准库 - < signal.h >C 标准库 - < stda
C语言 | Leetcode C语言题解之第435题无重叠区间
m0_59237910的博客
09-25 659
C语言 | Leetcode C语言题解之第435题无重叠区间
总结C/C++中内存区域划分
最新发布
2301_80349538的博客
09-30 863
所以变量ptr1 ptr2 ptr3 都是在栈区的，而它们存储的是在堆区所开辟空间的地址，这个地址既不在堆区也不在栈区，它只是个地址。注意：在现代计算机程序中，地址并不直接存储在栈区或堆区。地址实际上是存储在CPU的寄存器或者内存中，然后通过指针来引用内存的位置。1、栈区 2、堆区 3、数据段（静态区） 4.代码段。int globalVar 是全局变量——放在静态区。malloc calloc等动态内存分布存放在堆区。static修饰静态变量成员——放在静态区。动态内存分布存放在堆区。
C语言中的栈
m0_59091453的博客
09-28 929
调用栈，也称为执行栈，是程序执行过程中用于存储函数调用信息的数据结构。它是一个后进先出（LIFO）的栈，其中每个元素都是一个栈帧（Stack Frame）。
C语言使用【类&对象】模拟面向对象
weixin_54859557的博客
09-25 910
C语言使用【类&对象】模拟面向对象
蓝桥杯15届C/C++B组省赛题目
m0_73096516的博客
09-19 2410
队伍 1： {a1,a2,a3}{a1​,a2​,a3​}，队伍 2：{a4,a5}{a4​,a5​}，力量值和分别为 10+9+8=2710+9+8=27 , 12+14=2612+14=26，差距为 ∣27−26∣=1∣27−26∣=1。对于路径经过的棋盘格子，按照经过的格子顺序，上面的数字组成的序列要满足：0,1,2,…,K−1,0,1,2,…例如之前有从 (0,0)(0,0) 移动到 (1,1)(1,1) ，那么再从 (1,0)(1,0) 移动到 (0,1)(0,1) 线路就会交叉。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值