03-数组和结构体

最新推荐文章于 2024-04-30 20:06:58 发布
最新推荐文章于 2024-04-30 20:06:58 发布
阅读量23 收藏
点赞数
分类专栏： # C语言提高 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_huamao/article/details/134310727
版权

一维数组的数组名

除了两种情况（sizeof和取地址步长）以外，一维数组名指向数组第一个元素的指针

// 一维数组名称
void test01()
{
    // 一维数组的名 是不是指向第一个元素的指针？
    int arr[5] = {1, 2, 3, 4, 5};
    printf("sizeof arr = %d\n", sizeof(arr));

    // 对数组名取地址
    printf("%d\n%d\n", &arr, &arr+1);

    // 第一种 对数组名称sizeof
    // 第二种 对数组名称取地址，步长是整个数组长度
    // 除了这两种情况以外，一维数组名 指向数组第一个元素指针
    int *p = arr;

    // 数组名 指针常量 int * const p
    // arr = NULL;  // 指针的指向是不可修改的
    // arr[0] = 100;   // 指针指向的值是可以修改的

    // 数组访问试试，下标可以为负数，如果指针向后偏移，负数为向前走
    p = p + 3;
    // p[-1] = *(p - 1);
    printf("arr[-1] %d\n", p[-1]);
}

一维数组名做函数参数

// 数组作形参最好用这种写法，提高了可读性，虽然用int *arr也行
void printArr(int arr[], int length)
{
    for (int i = 0; i < length; i++) {
        printf("%d ", arr[i]);
    }
    for (int i = 0; i < length; i++) {
        printf("%d ", *(arr + i));
    }
}
void test02()
{
    int arr[5] = {1, 2, 3, 4, 5};
    printArr(arr, sizeof(arr) / sizeof(arr[0]));
}

数组指针定义

// 这种最好理解，最常用
// 3.直接定义数组指针
void test03()
{
    int arr[5] = {1, 2, 3, 4, 5};
    
    // 语法 数组元素类型 (*数组指针变量名称) [元素个数]
    int (*p)[5] = &arr;
    
    // *p = arr
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, (*p)[i]);
    }
}

// 1.先定义出数组的类型，在通过类型定义出数组指针
void test01()
{
    int arr[5] = {1, 2, 3, 4, 5};

    // 这行代码使用 typedef 关键字创建了一个类型别名 ARRAY_TYPE，该
    // 别名表示了一个包含5个整数的数组类型
    typedef int(ARRAY_TYPE)[5];

    // ARRAY_TYPE* arrP就是一个指针了， 指针指向包含4个int元素的数组 与 int(*p)[4] 等价
    ARRAY_TYPE *arrP = &arr;
    // *arrP ==== arr 相当于左右两侧都加了个解引用 *arrP = *(&arr) = arr

    // 使用 arrP 访问数组元素
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, (*arrP)[i]);
    }

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i,  *((*arrP)+i));
    }
}

// 2.先定义出数组指针的类型，通过类型创建数组指针变量
void test02()
{
    int arr[5] = {1, 2, 3, 4, 5};

    typedef int(*ARRAY_TYPE)[5];

    ARRAY_TYPE arrP;
    arrP = &arr;

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, (*arrP)[i]);
    }
}

二维数组数组名

void test01()
{
    // 这种定义方式，可读性强
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 一般情况下，指向第一行数组指针
    int (*p)[3] = arr;
    // *(p+1)指向第二行第一个，然后再+2跑到6的位置
    printf("%d\n", (*(p+1))[2]);
    printf("%d\n", p[1][2]);
    // for (int i = 0; i < 3; i++) {
    //     printf("");
    // }
}

// 二维数组做函数参数
void printArr(int arrp[][3], int row, int col)
// void printArr(int (*arrp)[3], int row, int col)
{
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            printf("%d ", arrp[i][j]);

            // 可读性不高，但是需要理解
            // printf("%d ", *(*(arrp + i) + j));
        }
        printf("\n");
    }
}
void test02()
{
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    printArr(arr, 3, 3);   

    printf("sizeof(arr) = %d\n", sizeof(arr));
    printf("arr = %d \narr + 1 = %d\n", &arr, &arr + 1);

}

指针数组排序

// 交换两个整数的值
void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 选择排序函数
void selectionSort(int arr[], int n)
{
    int i, j, min_index;

    // 遍历整个数组
    for (i = 0; i < n - 1; i++)
    {
        // 假设当前未排序部分的第一个元素是最小的
        min_index = i;

        // 在未排序部分找到最小元素的索引
        for (j = i + 1; j < n; j++)
        {
            if (arr[j] < arr[min_index])
            {
                min_index = j;
            }
        }

        // 将最小元素与当前未排序部分的第一个元素交换位置
        swap(&arr[i], &arr[min_index]);
    }
}

// 字符串选择排序函数
void charselectionSort(const char *arr[], int n)
{
    int i, j, min_index;

    // 遍历整个数组
    for (i = 0; i < n - 1; i++)
    {
        // 假设当前未排序部分的第一个元素是最小的
        min_index = i;

        // 在未排序部分找到最小元素的索引
        for (j = i + 1; j < n; j++)
        {
            if (strcmp(arr[j], arr[min_index]) > 0)
            {
                min_index = j;
            }
        }

        // 将最小元素与当前未排序部分的第一个元素交换位置
        if (i != min_index)
        {
            const char *temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }

    for (int i = 0; i < n; i++)
    {
        printf("%s ", arr[i]);
    }
    printf("\n");
}
void test01()
{
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);

    printf("\n排序后的数组:\n");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
    const char *parr[] = {"ccc", "bbb", "aaa", "ddd", "fff", "eee"};
    charselectionSort(parr, sizeof(parr) / sizeof(parr[0]));

    const char **arrp = parr;
    for (int i = 0; i < sizeof(parr) / sizeof(parr[0]); i++)
    {
        printf("%s ", arrp[i]);
    }
}

结构体赋值问题以及解决

问题：挡结构体有属性创建在堆区，赋值之后，释放会导致堆区属性重复释放，并且有内存泄漏
系统提供复制->浅拷贝
解决：利用手动赋值行为，解决问题，解决方式：利用深拷贝，重新在堆区创建内存

name 定义在栈上，这样赋值没有问题

struct Person
{
    char name[64];
    int age;
};

// 一维数组名称
void test01()
{
    struct Person p1 = {"John", 10};
    struct Person p2 = {"TOM", 11};

    p1 = p2;
    printf("%s %d\n", p1.name, p1.age);
    printf("%s %d\n", p2.name, p2.age);
}

name定义在堆上，当执行p1 = p2;时，浅拷贝（逐字节拷贝）出现问题

在释放内存之前，将 p1 的内容设置为 p2，这意味着 p1.name 指向 p2.name 指向的内存，当释放 p1.name 时，也释放了 p2.name，导致重复释放内存。而且之前的p1.name内存没有被释放

![[Pasted image 20230921202614.png]]


struct Person2
{
    char *name;
    int age;
};
// 一维数组名称
void test02()
{
    struct Person2 p1, p2;
    p1.name = (char *)malloc(sizeof(char) * 64);
    strcpy(p1.name, "John");
    p1.age = 10;

    p2.name = (char*)malloc(sizeof(char) * 128);
    strcpy(p2.name, "Tom");

    if (p1.name == NULL || p2.name == NULL) {
    // 处理内存分配失败的情况
    printf("Memory allocation failed.\n");
    exit(1);
    }

    p2.age = 11;

    p1 = p2;

    printf("%s %d\n", p1.name, p1.age);
    printf("%s %d\n", p2.name, p2.age);

    if (p1.name != NULL) {
        free(p1.name);
        p1.name = NULL;
    }

    if (p2.name != NULL) {
        free(p2.name);
        p2.name = NULL;
    }
}

结构体嵌套一级指针

typedef struct Person
{
    char *name;
    int age;
}Person;

// 一维数组名称
void test01()
{
    // 二级指针，指向三个一级指针
    Person **person_ptr = (Person**)malloc(sizeof(Person*) * 3);

    for (int i = 0; i < 3; i++) {
        person_ptr[i] = (Person*)malloc(sizeof(Person));
        person_ptr[i]->name = (char*)malloc(sizeof(char)*64);
        sprintf(person_ptr[i]->name, "name_%d", i+1);
        person_ptr[i]->age = 18 + i;
    }

    for (int i = 0; i < 3; i++) {
        printf("person%d, name:%s, age:%d\n", i, person_ptr[i]->name, person_ptr[i]->age);
    }

    // 释放
    for (int i = 0; i < 3; i++) {
        printf("person%d is freed!\n", i);        
        
        if (person_ptr[i] != NULL) {
            if (person_ptr[i]->name != NULL) {
                free(person_ptr[i]->name);
                person_ptr[i]->name = NULL;
            }
            free(person_ptr[i]);
            person_ptr[i] = NULL;
        }
    }

    // 释放 person_ptr 数组本身的内存
    free(person_ptr);
}

结构体嵌套二级指针

在堆区分配3个老师i的指针
将3个老师分配到堆区
将老师姓名分配到堆区
老师带的学生数组分配到堆区
学生姓名分配到堆去
打印所有数据
释放

typedef struct Teacher
{
	char * name;
	char ** Students;
}Teacher;


void allocateSpace(Teacher*** teacherAyy)
{
    // 堆区分配内存
    // ts是个指针数组，指向三个指针
    Teacher **ts = (Teacher**)malloc(sizeof(Teacher*)*3);

    for (int i = 0; i < 3; i++) {
        // 给老师分配内存
        ts[i] = (Teacher*)malloc(sizeof(Teacher));

        // 给老师姓名属性分配内存和赋值
        ts[i]->name = (char*)malloc(sizeof(char) * 64);
        sprintf(ts[i]->name, "teacher_%d", i + 1);

        // 给老师带领的学生分配内存
        ts[i]->Students = (char**)malloc(sizeof(char*)*3);
        for (int j = 0; j < 3; j++) {
            ts[i]->Students[j] = (char*)malloc(sizeof(char));
            sprintf(ts[i]->Students[j], "%sstudent_%d", ts[i]->name, j + 1);
        } 
    }


    // 对三级指针解引用变为二级指针，然后赋值
    // 建立关系
    *teacherAyy = ts;

}

void printTeacher(Teacher** teacherArr)
{
    for (int i = 0; i < 3; i++)
    {
        printf("teacher_name:%s\n",teacherArr[i]->name);
        // 打印带的学生
        for (int j = 0; j < 3; j++) {
            printf("student_info->%s\n",teacherArr[i]->Students[j]);
        }
    }
    

}

void freeSpace(Teacher** teacherArr)
{
    // 释放要从下往上释放
    if (!teacherArr) {
        printf("teacherArr is none\n");
        return;
    }

    // 从下到上释放
    for (int i = 0; i < 3; i++) {
        if (teacherArr[i]->name != NULL) {
            free(teacherArr[i]->name);
            teacherArr[i]->name = NULL;
        }

        for (int j = 0; j < 3; j++) {
            if (teacherArr[i]->Students[j] != NULL) {
                free(teacherArr[i]->Students[j]);
                teacherArr[i]->Students[j] = NULL;
            }
        }
        // 释放学生数组
        free(teacherArr[i]->Students);
        teacherArr[i]->Students = NULL;

        // 释放老师
        free(teacherArr[i]);
        teacherArr[i] = NULL;
    }
}
void test01()
{
    // 教师数组创建
    Teacher ** teacherArr = NULL;

    // 分配内存
    allocateSpace(&teacherArr);

    // 打印内容
    printTeacher(teacherArr);

    // 释放,把teacherArr指向的空间释放
    freeSpace(teacherArr);
    teacherArr = NULL;
}

结构体偏移量

typedef struct Student
{
    char a;
    int b;
}Student;

// 计算偏移量
void test01()
{
    Student s1;
    Student *p;
    p = &s1;
    // 想算的属性的地址，减去首地址
    printf("b的偏移量:%d\n", (int)&(p->b) - (int)p);

    printf("b的偏移量:%lld\n", (long long)offsetof(Student, b));

}

void test02()
{
    Student s1;
    Student *p;
    p = &s1;
    p->b = 10;
    // 打印值
    long long offset = (long long)offsetof(Student, b);
    // char*的步长是1
    printf("b:%d\n", *(int*)((char*)p+offset));
    printf("b:%d\n", *(int*)((int*)p+1));
}

typedef struct Student2
{   
    char a;
    int b;
    Student s;
}Student2;
void test03()
{
    // 结构体嵌套结构体初始化
    Student2 s = {'a', 10, {'b', 2000}};
    Student2 *sp = &s;
    // 访问到2000

    // 先找到结构体s的偏移量
    int offset1 = (int)offsetof(Student2, s);
    // 再找到2000的偏移量
    int offset2 = (int)offsetof(Student, b);
    printf("属性s中的b的值为->%d\n", *(int*)((char*)sp+offset1+offset2));

    printf("属性s中的b的值为->%d\n", ((Student*)((char*)sp+offset1))->b);

}

内存对齐

![[Pasted image 20230923204931.png]]

结构体计算内存对齐原则

  1. 第一个属性开始 从0开始偏移
  2. 第二个属性 要放在 min(该类型大小， 对齐模数) 的整数倍
  3. 所有属性计算之后，整体做二次偏移
  4. 计算结果 放在 min(该结构体中最大数据类型，对齐模数)的整数倍上
#pragma pack(show) //查看对齐模数
//#pragma pack(1) //默认对齐模数为 8  对齐模数可以改为 2的n次方


//对于自定义数据类型  内存对齐规则 如下：
//1、从第一个属性开始  偏移为0 
//2、第二个属性开始，地址要放在  该类型整数倍   与 对齐模数比  取小的值 的整数倍上
//3、所有的属性都计算结束后，整体再做二次对齐，整体需要放在属性中最大类型 与 对齐模数比 取小的值的整数倍上
typedef struct _STUDENT{
	//       对齐模数8      对齐模数1
	int a;   // 0 ~ 3        0  ~ 3
	char b;  // 4 ~ 7        4 
	double c;// 8  ~ 15      5  ~ 12
	float d; // 16 ~ 19      13 ~ 16
}Student;


void test01()
{
	Student s;
	printf("size of =  %d\n", sizeof(Student));

	// printf("对齐模数：%zu\n", alignof(s.a));  // 打印int类型的对齐模数
    // printf("对齐模数：%zu\n", alignof(s.b)); // 打印double类型的对齐模数
    // printf("对齐模数：%zu\n", alignof(s.c));   // 打印char类型的对齐模数
}


//当结构体嵌套结构体时候，只需要看子结构体中最大数据类型就可以了
typedef struct _STUDENT2{
	char a; //  0 ~  7
	Student b;  // 8 ~ 31
	double c;   // 32 ~ 39
}Student2;


void test02()
{
	printf("size of =  %d\n", sizeof(Student2));

}
lhlc67
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构讲义-数组和结构体.pdf
11-06
数据结构讲义-数组和结构体.pdf
C语言 - 结构体、结构体数组、结构体指针和结构体嵌套
qq_44947439的博客
08-29 1457
正式：结构体是由一批数据组合而成的结构型数据。组成结构型数据的每个数据被称为结构型数据的 “成员” ，其描述了一块内存区间的大小及解释意义。通俗：结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。在C语言中，定义结构体的语法格式struct 结构体名 {类型 成员1;类型 成员2;// ...其中，结构体名是您自定义的结构体类型名称，可以根据需求进行命名。成员1成员2等表示结构体的成员变量，每个成员都有自己的类型和名称。
C语言--结构体数组和结构体指针
樊小辫的博客
08-16 3万+
 结构体是我们自己定义的一种新的数据类型, 同样可以有结构数组和结构指针。  1.结构体数组 具有相同结构体类型的变量构成的数组，称为结构体数组。与普通数值型数组的不同之处在于每个数组元素都是一个结构体变量，它们都分别包含各个成员项。 定义结构体数组一般形式是 struct 结构体名 { 成员列表 }数组名[数组长度]; 或者： 先声明一个结构体类型，然后再定义结构体数组 结构...
【C++】结构体应用案例 1 - 结构体数组嵌套结构体数组
深入挖掘，筑基为先；知其然，知其所以然。
04-16 1262
结构体数组嵌套结构体数组的暴力美学 ！
结构体&结构体数组
热门推荐
pl0020的博客
08-16 13万+
1、结构体的定义 struct 结构体类型名 ｛ 类型名 成员名; 类型名 成员名; …… ｝; 先声明结构体类型，再定义结构体变量名 声明结构体类型，不分配空间 定义结构体类型变量，就要分配内存空间 1）结构体被分配的内存空间 struct student { int num;//4字节 char name[20];//20字节 char sex;//1...
C语言学习笔记---结构体数组初始化
HXYDJ的博客
11-04 2万+
  既然结构体是一种数据类型，那么它也可以定义为数组的形式。比如要描述一本书的信息，可以将书的名称，作者，价格这些信息用一个结构体来描述，在使用的过程中不可能只描述一本书，所以就需要使用一个结构体数组来描述多本书的信息。   首先声明一个结构体。 struct book { char title[30]; char author[30]; float value; };   接下来定义结构变量，直接定义一个结构数组，在定义的时候初始化。 struct book books[3]={
C语言-数组、结构体与指针的综合应用实验报告
01-09
1、给设计一种结构体，用来保存学生信息（包括学号、姓名、三科成绩、平均成绩）。除平均成绩外，各项数据均由键盘输入。现在要求输入若干学生的信息，并实现以下功能：（可以使用数组或链表实现） 1）计算学生的...
C语言的博大精深之数组和结构体的赋值操作
07-18
最近在看关于队列调度的内核实现代码时，发现奇怪的赋值语句，写此文章记录下。
cpp代码-结构体数组，结构体嵌套的调用 小测答案及思路
07-14
cpp代码-结构体数组，结构体嵌套的调用 小测答案及思路
C#中byte数组和c++结构体的转换
03-13
在写C#TCP通信程序时，发送数据时，只能发送byte数组，处理起来比较麻烦不说，如果是和c++等写的程序通信的话，很多的都是传送结构体，在VC6.0中可以很方便的把一个char[]数组转换为一个结构体，而在C#却不能直接把...
Codeforces Round 941 (Div. 2) （A~D）
weixin_61825750的博客
04-28 700
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 118
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 449
Golang | Leetcode Golang题解之第56题合并区间
4/26发布发布：缺了好几次的作业，矩形法+二分法求下面方程根+顺序查找n+程序填空，补一下还有八九没做，炸8412 字不是干的，哈哈哈
2201_75637762的博客
04-26 1236
eps：用于定义逼近的精度，即当x1和x2的差小于eps时，认为找到了根。x1和x2：用于二分法的初始区间，这里选择的是[-10, 10]。y1和y2：分别是x1和x2处函数的值。这个程序通过二分法在一个给定的区间内寻找三次方程的根。它首先检查函数在区间端点的值的符号，然后使用二分法逐步缩小区间，直到找到满足精度要求的根或确定区间内没有根为止。okll测试数据：3 4 7 12 24 78 9 15 80 45第一次运行程序输入测试数据 12。
算法~本质
最新发布
sweet_Mary的博客
04-30 257
数据结构分为数组和链表，数据结构的目的是提升增删改查的效率。算法的本质是基于这两种数据结构进行高效穷举。2.如何聪明地穷举？--并查集/贪心/KMP）数组--二分搜索/双指针/滑动窗口/前缀+差分。二叉树系列（回溯算法+动态规划）eg.求二叉树最大深度。2. 分解问题计算答案。2.分解问题计算答案。eg.二叉树前缀遍历。
代码随想录算法训练营Day25 | 216.组合总和III、17.电话号码的字母组合 | Python | 个人记录向
Python基本算法
04-27 638
回溯算法：216.组合总和III、17.电话号码的字母组合。
c入门基础题（3）
梦昼初
04-26 891
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
【C++中的模板】
Z15255808023的博客
04-27 728
本片内容主要是C++中模板的有关知识，主要讲述了模板及其实用和注意事项，请耐心观看。相必我们大家都听说过泛型编程这个概念：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。简单的说就是编写一种可以在多种数据类型上都能用的代码。比如说，你写一次代码，就可以在很多不同的数据类型上使用，而不需要为每种数据类型都重新写一遍相同逻辑的代码。它能让编程变得更简单、更灵活。
使用rust学习基本算法（四）
weixin_40539956的博客
04-27 983
对于一个包含n个顶点的图，其邻接矩阵是一个n×n的矩阵，记为A。如果顶点i和顶点j之间存在一条边，则矩阵中的元素A[i][j]表示这条边的权重；如果不存在边，则A[i][j]的值通常设为0（对于无权图）或某个特定的非负值，如无穷大（对于有权图），表示两个顶点之间没有直接的连接。
数组和结构体数组可以互换吗
05-25
不可以直接互换，因为数组和结构体数组是两种不同的数据类型。 数组是一组具有相同数据类型的元素的集合，这些元素在内存中是连续存储的。而结构体数组是由一组结构体类型的元素组成的集合，每个元素都包含多个字段...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值