C语言结构体、结构体数组、结构体指针学习整理

已于 2023-07-21 17:17:44 修改
阅读量844 收藏 11
点赞数
分类专栏： 数据结构 # C语言练习（7月14） 文章标签： c语言 开发语言
于 2023-07-16 17:39:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53478812/article/details/131750497
版权
本文详细介绍了C语言中结构体的定义、初始化、变量赋值、数组操作、指针应用以及字节对齐规则，包括直接和间接定义结构体变量、结构体数组、结构体指针以及结构体在不同操作系统下的字节计算。示例代码涵盖了各种常见用法。
摘要由CSDN通过智能技术生成

一、结构体

格式：

struct 结构体名

{

        数据类型 成员1;

        数据类型 成员2;

        数据类型 成员3;

         ...

         数据类型 成员n;

};

格式解析：

1.struct:是结构体关键字

2.结构体名，需要满足命名规范，可以省略，与typedef结合直接定义结构体类型

3.{}不可以省略，;也不可省略

4.成员变量的数据类型可以为基本类型，构造类型，指针，空类型（void）

5.成员的个数任意

6.结构体描述时，计算机不分配空间，直到定义结构体变量计算机才分配空间，分配空间大小为各成员字节大小的总和

实例：

/*定义车的信息：品牌，单价，颜色，车牌号*/
struct Car
{
    char name[20];       //品牌
    int price;           //单价
    char color[10];      //颜色
    char id[20];         //车牌号
};

1.1 基本结构体变量

1.1.1 间接定义结构体变量及初始化

间接定义：在结构体描述完成后，通过描述的结构体类型定义变量

1）间接定义变量按顺序初始化

struct Car
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    };
struct Car car={"大众",123456,"白色","沪A1111"};

2）间接定义变量不按顺序初始化

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car car={.price=123456,.color="白色",.id="沪A1111",.name="大众"};

3）间接定义变量，单个赋值

struct Car
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    };
struct Car car;
    strcpy(car.name,"大众");    //为字符串赋值时必须使用字符串函数，不能直接赋值
    car.price=123456;
    strcpy(car.color,"白色");
    strcpy(car.id,"沪A88888");

注意：car.name="大众"，这种赋值方式是错误的，在C99标准中不允许将字符串赋值给数组，如果强行赋值，编译器会直接报语法错误： [Error] assignment to expression with array type。

4）间接定义变量，输入赋值

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car car;
    scanf("%s",car.name);
    scanf("%d",&car.price);
    scanf("%s",car.color);
    scanf("%s",car.id);

1.1.2 直接定义结构体变量及初始化

定义结构体描述的同时定义结构体变量

1） 直接定义变量按顺序初始化   

 struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car={"大众",123456,"白色","沪A1111"};

2）直接定义变量不按顺序初始化     

 struct Car
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    }car={.price=123456,.color="白色",.id="沪A1111",.name="大众"};

3）直接定义变量，单个赋值 

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car;
    strcpy(car.name,"大众");
    car.price=123456;
    strcpy(car.color,"白色");
    strcpy(car.id,"沪A88888");

4）直接定义变量，输入赋值     

struct Car
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    }car;
    scanf("%s",car.name);
    scanf("%d",&car.price);
    scanf("%s",car.color);
    scanf("%s",car.id);

5） 直接定义可以省略结构体名,称“无名结构体” 

struct
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car;

1.2 结构体数组

1.2.1 间接定义结构体数组及初始化

1）间接定义变量按顺序初始化  

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car car[3]={"大众",123456,"白色","沪A1111","大众",123456,"白色","沪A2222","大众",123456,"白色","沪A33333"};

2）间接定义变量不按顺序初始化

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car car[3]={[0]={.price=123456,.color="白色",.id="沪A1111",.name="大众"},[2]={.price=123456,.color="白色",.id="沪A2222",.name="大众"},[1]={.price=123456,.color="白色",.id="沪A3333",.name="大众"}};

3）间接定义变量，单个赋值   

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car car[3];
//第一辆车的信息
    strcpy(car[0].name,"大众");
    car[0].price=123456;
    strcpy(car[0].color,"白色");
    strcpy(car[0].id,"沪A1111");
//第二辆车的信息
    strcpy(car[1].name,"大众");
    car[1].price=123456;
    strcpy(car[1].color,"白色");
    strcpy(car[1].id,"沪A2222");
//第三辆车的信息
    strcpy(car[2].name,"大众");
    car[2].price=123456;
    strcpy(car[2].color,"白色");
    strcpy(car[2].id,"沪A3333");
    

4> 间接定义变量，输入赋值        

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car car[3];
    for(int i=0;i<3;i++)
    {
        scanf("%s",car[i].name);
        scanf("%d",&car[i].price);
        scanf("%s",car[i].color);
        scanf("%s",car[i].id);
    }

1.2.2 直接定义结构数组及初始化

1）直接定义变量按顺序初始化    

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car[3]={"大众",123456,"白色","沪A1111","大众",123456,"白色","沪A2222","大众",123456,"白色","沪A33333"};

2）直接定义变量不按顺序初始化

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car[3]={[0]={.price=123456,.color="白色",.id="沪A1111",.name="大众"},[2]={.price=123456,.color="白色",.id="沪A2222",.name="大众"},[1]={.price=123456,.color="白色",.id="沪A3333",.name="大众"}};

3）直接定义变量，单个赋值   

 struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car[3];

    strcpy(car[0].name,"大众");
    car[0].price=123456;
    strcpy(car[0].color,"白色");
    strcpy(car[0].id,"沪A88888");

    strcpy(car[1].name,"大众");
    car[1].price=123456;
    strcpy(car[1].color,"白色");
    strcpy(car[1].id,"沪A88888");

    strcpy(car[2].name,"大众");
    car[2].price=123456;
    strcpy(car[2].color,"白色");
    strcpy(car[2].id,"沪A88888");

4）直接定义变量，输入赋值

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    }car[3];

    for(int i=0;i<3;i++)
    {
        scanf("%s",car[i].name);
        scanf("%d",&car[i].price);
        scanf("%s",car[i].color);
        scanf("%s",car[i].id);
    }

1.3 结构体指针

格式：

struct 结构体名 *指针变量名

1.3.1 结构体指针指向普通结构体变量的地址

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
    struct Car c={.price=123456,.color="白色",.id="沪A1111",.name="大众"};
    struct Car *p=&c;

1.3.2 结构体指针指向结构体数组的地址

struct Car
    {
        char name[20];      //品牌
        int price;          //单价
        char color[10];     //颜色
        char id[20];        //车牌号
    };
struct Car  car[3]={"大众",123456,"白色","沪A1111","大众",123456,"白色","沪A2222","大众",123456,"白色","沪A33333"};
struct Car *p=car;

1.3.3 结构体指针指向堆区空间的首地址

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct Car
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    };

//输出对去空间内存
void Output(struct Car *p,int len)
{
    for(int i=0;i<len;i++)
    {
        //printf("%s\t%d\t%s\t%s\n",(p+i)->name,(p+i)->price,(p+i)->color,(p+i)->id);
        printf("%s\t%d\t%s\t%s\n",(*(p+i)).name,(*(p+i)).price,(*(p+i)).color,(*(p+i)).id);
    }
}

//在堆区空间申请
struct Car * create()
{
    struct Car *p=(struct Car *)malloc(sizeof(struct Car)*3);//
    if(NULL == p)
    {
        return NULL;
    }
    return p;
}

//在堆区实现循环输入
void Input(struct Car *p ,int n)
{
    for(int i=0;i<3;i++)
    {
        scanf("%s",(p+i)->name);
        scanf("%d",&(p+i)->price);//(p+i)->price===>price
        scanf("%s",(p+i)->color);
        scanf("%s",(p+i)->id);
    }
}

//释放堆区空间
struct Car * free_space(struct Car *p)
{
    if(NULL==p)
    {
        return NULL;
    }
    free(p);
    p=NULL;
    return p;
}

int main(int argc, const char *argv[])
{
    struct Car *p=create();
    Input(p,3);
    Output(p,3);
    p=free_space(p);
    return 0;
}

1.4 结构体的引用

1.基本结构使用“.”进行引用，只能使用结构体变量名引用

2.结构体数组使用"."进行引用，只能使用结构体数组名引用

3.值使用".",地址使用“->”

4.结构体名表示所有信息，不可以直接打印，结构体整体引用常用于传递参数，或者元素的赋值   

struct Car
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    };
struct Car a={"大众",123456,"白色","沪A1111"};
struct Car b;
/*将a的赋值给b，方法一*/
    strcpy(b.name,a.name);
    b.price=a.price;
    strcpy(b.color,a.color);
    strcpy(b.id,a.id);
/*将a的赋值给b，方法一*/
    b=a;

1.5 typedef和结构体结合

typedef struct  
    {
        char name[20];     //品牌
        int price;         //单价
        char color[10];    //颜色
        char id[20];       //车牌号
    }car_t,car_arr[3],*car_p;

注意：car_t：不是变量名，是基本结构体类型别名，car_arr：不是结构体数组名，是结构体数组的别名，car_p:不是结构体指针变量名，是结构体指针的别名，当typedef和结构体结合时，结构体名可以省略不写。

1.6 结构体嵌套结构体

1.6.1 结构体嵌套普通结构

练习：定义一个学生：姓名、性别、出生日期【年月日】

typedef struct
    {
        int year,month,day;
    }Birthday;

typedef struct
    {
        char name[10];
        char sex;
        Birthday bir;
    }Stu;

Stu student={"张三",'M',2000,7,14};
    printf("%s %c %d年%d月%d日\n",student.name,studnet.sex,student.bir.year,student.bir.month,student.bir.day);

1.6.2 结构体嵌套结构体数组

练习：定义一个人的信息：姓名，性别，年龄，车辆多辆【品牌，单价】

 typedef struct
    {
        char name[10];
        int price;    
    }Car_t;

typedef struct
    {
        char name[10];
        char sex;
        int age;
        Car_t arr[2];
    }person;

person per={"张三",'M',18,"奔驰",555555,"宝马",666666};
    printf("",per.name,per.sex,per.age,per.arr[0].name,per.arr[0].price,per.arr[1].name,per.arr[1].price);

1.7 结构体字节计算

1.7.1 64位操作系统

1.结构体的总字节是各个成员字节的总和

2.结构体变量的地址是第一个成员的首地址，各个成员的地址连续

3.结构体需满足字节对齐原则

i.结构体的首地址是最宽成员的倍数

        如果最宽成员是1字节，则地址是1的倍数

        如果最宽成员是2字节，则地址是2的倍数

        如果最宽成员是4字节，则地址是4的倍数

        如果最宽成员是8字节，则地址是8的倍数

ii. 结构体总字节数是最宽成员的倍数，如果不是则填充空字节

iii.各个成员的地址偏移量是各个成员字节的倍数，如果不是则填充空字节

地址偏移量：该成员的首地址到结构体的起始地址之间的差

typedef struct
{
    int a;
    float b;
}A_t;

A_t var;
printf("&var=%p\t&var.a=%p\t&var.b=%p\n",&var,&var.a,&var.b);
printf("sizeof(A_t)=%ld\n",sizeof(A_t));    //结构体字节长度为：8

typedef struct{
    char a;
    double b;
}B_t;

B_t var1;
printf("&var1=%p\t&var1.a=%p\t&var1.b=%p\n",&var1,&var1.a,&var1.b);
printf("sizeof(B_t)=%ld\n",sizeof(B_t));    //结构体字节长度为：16

typedef struct
{
    int a;
    char b;
    float c;
    char *p;
    char d;
}C_t;

C_t c;
printf("c.a=%p\n",&c.a);
printf("c.b=%p\n",&c.b);
printf("c.c=%p\n",&c.c);
printf("c.p=%p\n",&c.p);
printf("c.d=%p\n",&c.d);
printf("sizeof(C_t)=%ld\n",sizeof(C_t));//结构体字节长度为：32

typedef struct
{
    a_str a;
    int b;
}D_t;

printf("sizeof(D_t)=%ld\n",sizeof(D_t));//12


typedef struct{
    char a;
    double b;
}E_t;

typedef struct

{
    char a;
    short b;
    E_t c;
}F_t;

printf("sizeof(F_t)=%ld\n",sizeof(F_t));//结构体字节长度为：24

1.7.2 32位操作系统

1.结构体的总字节是各个成员字节的总和

2.结构体变量的地址是第一个成员的首地址，各个成员的地址连续

3.结构体需满足字节对齐原则

i.结构体的首地址是最宽成员的倍数

        如果最宽成员是1字节，则地址是1的倍数

        如果最宽成员是2字节，则地址是2的倍数

        如果最宽成员是4字节或者8字节，则地址是4的倍数

ii. 结构体总字节数是最宽成员的倍数，如果不是则填充空字节

        如果最宽成员是4字节或者8字节，则总字节是4的倍数

iii.各个成员的地址偏移量是各个成员字节的倍数，如果不是则填充空字节

        如果最该成员是4字节或者8字节，则地址偏移量是4的倍数

小钱努力学C
关注
专栏目录
C语言 结构体 数组 指针
xuesnowce的博客
10-24 1087
C语言 结构体
C语言 | 结构体数组
weixin_48669767的博客
04-30 6973
C语言结构体数组概述 一个结构体变量中可以存放一组有关联的数据，如一个学生的学号、姓名、成绩等数据，如果有10个学生的数据需要参加运算，显然应该用数组，这就是结构体数组。 结构体数组与之前介绍的数值型数组的不同之处在于每个数组元素都是一个结构体类型的数据，他们都包括各个成员项。 C语言定义结构体数组 一般形式 struct 结构体名 {成员表列}数组名[数组长度]； 先声明一个结构体类型（如struct Person），然后再用此类型定义结构体数组：结构体类型 数组名[数组长度]。 C语言使用结构体数组注
【C语言】结构体类型的数组和指针（干货满满，建议收藏！！！）
2301_81193162的博客
06-05 4567
这篇文章将讲述结构体类型的数组的定义、初始化、应用和结构体指针的使用。还会扩展scanf_s函数相关知识。
C语言详细笔记--构造数据类型（结构体数组）
最新发布
Jasmine5606的博客
08-29 595
上面语句定义了一个名为stu的数组，数组有三个元素，每个元素的类型为struct stuscoretype结构体类型。由于数组每一个元素都是结构体，因此可以将每个元素中成员的初值一次放在一对花括号内以便区分各个元素。学完结构体数组后可以试着用结构体数组解决上一节的学生三门课程平均分问题喔！本期博客到这里就结束啦~~二、结构体数组的初始化。一、结构体数组的定义。三、结构体数组的引用。
C语言的结构体指针， 数组指针
lygl35的博客
02-21 178
结构体指针的定义方法 结构体名加* 数组指针 px 是数组指针的名字，类型是char* , 宽度是4个字节 （*）[5] 是这个数组指针类型，宽度是5个字节 运行结果 一维数组指针 二维数组指针 三维数组指针 ...
C语言结构体总结
qq_45661125的博客
12-19 1384
一.什么是结构体 我们知道数组，它是一组具有相同类型的数据的集合。但在实际的编程过程中，我们往往还需要一组类型不同的数据，例如对于学生信息登记表，姓名为字符串，学号为整数，年龄为整数，所在的学习小组为字符，成绩为小数，因为数据类型不同，显然不能用一个数组来存放。在C语言中，我们可以使用结构体来存放一组不同类型的数据。 结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每...
C语言【练习结构体指针,指针数组】
C语言学习笔记
12-30 752
找出最低分数的同学，储存到h指向的结构体数组 #include<stdio.h> #include<math.h> #define N 10 #define eps 1e-4 struct stu { double num; float score; }; int main() { struct stu s[N],low[N],*Q=s,*h=low; int i;float min=100.0; for(i=0;i<N;i++) { scanf("%.
c语言调用结构体数组指针,C语言结构体、结构体数组、结构体指针的用法
weixin_35943182的博客
05-19 2214
一、结构体的定义struct student{ //struct 结构体名long studentID; //数据类型 成员名1char studentName[10]; //数据类型 成员名2int scoreMath; //数据类型 成员名3};二、结构体变量的定义1先声明结构体模板，再定义结构体变量struct student{ //struc...
c语言中结构体定义函数指针数组,C语言 结构体相干 函数 指针 数组
weixin_31659557的博客
05-20 974
C语言 结构体相关 函数 指针 数组.作者 : 万境绝尘转载请注明出处 :http://www.hanshuliang.com/?post=30.结构体概述 : 结构体是 多个 变量的集合, 变量的类型可以不同;-- 可进行的操作 : 结构体可以进行 拷贝 赋值操作, 可以作为 函数参数 和 函数返回值;1. 结构体的基本使用结构体声明 : struct 结构标记 {结构成员} 普通变量;-- ...
C语言 - 结构体、结构体数组、结构体指针和结构体嵌套
qq_44947439的博客
08-29 1713
正式：结构体是由一批数据组合而成的结构型数据。组成结构型数据的每个数据被称为结构型数据的 “成员” ，其描述了一块内存区间的大小及解释意义。通俗：结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。在C语言中，定义结构体的语法格式struct 结构体名 {类型 成员1;类型 成员2;// ...其中，结构体名是您自定义的结构体类型名称，可以根据需求进行命名。成员1成员2等表示结构体的成员变量，每个成员都有自己的类型和名称。
C语言结构体通过 scanf初始化,C语言结构体数组内带字符数组初始化和赋值
weixin_34602954的博客
05-19 3160
1.首先定义结构体数组：typedef struct BleAndTspRmtCmd{char terminal[3];char note[3];char rmtCmd[10];char cmdPropt[24];};BleAndTspRmtCmd为结构体名，可以通过这个结构体名定义其他结构体变量，structBleAndTspRmtCmdvariable；或者定义结构体数组变量，struct...
三维坐标结构体数组c语言,C语言结构体数组指针以及函数
weixin_39930252的博客
05-16 586
结构体数组指针指针变量可以指向一个结构体数组，这时指针变量的值是整个数组的首地址。设 ps 为指向结构体数组的指针变量，则 ps 也指向该结构体数组的第0个元素，ps+1指向第一个元素，ps+i则指向第i元素，这与普通数组的情况是一样的。【示例】用指针变量输出结构体数组。#include struct stu{int num;char *name;char sex;float score;} *p...
C语言 超详细 零基础入门 结构体数组 结构体指针 数据结构
我亦无他，唯手熟尔
12-08 852
尚硅谷C语言零基础入门教程（宋红康c语言程序设计精讲，含C语言考研
【C语言】结构体指针与结构体数组
Jacky_Feng的博客
10-21 1万+
一、结构体指针 与一般指针类似结构体也可以使用结构体指针进行引用使用。结构体指针的定义方式如下： struct Student stu = { 1001,"Li Lei",'M',1.87 }; //定义一个Student 的结构体变量stu struct Student *p=&stu; //定义一个Student的结构体指针变量来指向stu 当程序中定义了一个指向结构体变量的指针，就可以通过“指针名->成员变量名”的方式访问结构体变量的成员。 实例演示： #in...
结构体数组与结构体指针
xiawucha159的博客
10-06 6916
结构体数组与结构体指针 结构体变量可以使用“.”运算符，当对结构体指针使用.运算符时，一定要使用括号，因为 . 运算符的优先级是最高的，如果不使用括号，就会先执行点运算后执行 “*” 运算。注意：结构体变量名与数组名的含义是不同的，结构体变量名并不是该变量的地址，因此需要在结构体变量名前加上取址运算 “&”。lib_point是结构体的地址，也是第一个成员title的地址，虽然两个地址是相同的，但是它们的类型是不同的。疑问：既然lib是一个数组（结构体数组），那lib就是数组名，也就是数组的首地址，
结构体、指针、数组
weixin_73567058的博客
11-25 1169
1.结构体，指针都是数据类型中的一员，抛开其特殊的点， 它们其实和int char...这些无异，在定义一个变量的时候用法，格式都一样 与其他数据类型不同的是： 结构体是可以程序员自定义的，那些基本数据类型都可以作为积木构造各式各样的结构体来满足程序员的需求 创建的每一个结构体都要为其命名 以后要用到这个结构体的时候，起的名字就当作数据类型（纯C语法必须在前面加上struct关键字，cpp语法中可省略） 2.指针，顾名思义，它的功能就像一个指针一样，为计算机指向对应的内存空间
C语言中的结构体数组
章飞 _906285288的博客
01-15 4万+
C语言中的结构体数组1.结构体 数组概念 2. 结构体数组定义和初始化 3. 结构体数组的引用结构体数组的概念元素为结构体类型的数组称为结构体数组，在实际的应用过程中，经常使用结构体数组来表示具有相同数据结构的一个群体struct student{ int xh; char *name; char *sex; }stu[20]; 定义了一个结构体数组stu，共有30个
结构体数组
热门推荐
mjshldcsd的专栏
01-17 7万+
5 结构体数组 　　一个结构体变量中可以存放一组数据（如一个学生的学号，姓名，成绩等数据）。如果有10个学生的数据需要参加运算，显然应该用数组，这就是结构体数组。结构体数组与以前介绍过的数据值型数组不同之处在于每个数组元素都一个结构体类型的数据，它们分别包括各个成员（分量）项。 5.1 定义结构体数组 　　和定义结构体变量的方法相仿，只需说明其为数组即可。 　　struct
c++基础知识第九天：结构体，结构体数组，结构体指针
hm_uin的博客
11-01 610
自定义一个数据类型，然后再套用数组，指针的用法。只是里面的每一个元素还能再细分。数组用.访问，指针用->访问。
C语言结构体：变量、数组与指针定义解析
这里，`std`是一个结构体变量，`pers`是一个包含3个元素的结构体数组，而`pstd`是一个指向`struct student`类型变量的指针。这表明`pstd`可以用来存储结构体变量的地址，从而实现对结构体内容的间接访问。 **指针...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值