C语言学习之路（基础篇）—— 数组和字符串（上）

た入场券 2024-04-01 15:00 80阅读 0赞

说明：该篇博客是博主一字一码编写的，实属不易，请尊重原创，谢谢大家！

## 概述 ##

在程序设计中，为了方便处理数据把具有相同类型的若干变量按有序形式组织起来——称为数组。

数组就是在内存中连续的相同类型的变量空间。同一个数组所有的成员都是相同的数据类型，同时所有的成员在内存中的地址是连续的。

**数组:** 将若干个相同数据类型的变量存放在一个连续的内存空间。数组的最小单位是元素，数组中的每一个元素都是一个变量  
  
![在这里插入图片描述][fbbc3112907d4f48ad32284953f92ab7.png]

**构造类型：** 将基本类型构建成类型。  
相同类型的数据存放在一个集合中，这种的构造类型就是数组。  
数组属于构造数据类型：

*  一个数组可以分解为多个数组元素：这些数组元素可以是基本数据类型或构造类型。

int a[10];  // 数值数组
    struct Stu boy[10]; // 结构数组

*  按数组元素类型的不同，数组可分为：数值数组、字符数组、指针数组、结构数组等类别。

int a[10]; // 数值数组
    char s[10]; // 字符数组
    char *p[10]; // 指针数组
    struct Stu boy[10]; // 结构数组

通常情况下，数组元素下标的个数也称为维数，根据维数的不同，可将数组分为一维数组、二维数组、三维数组、四维数组等。通常情况下，我们将二维及以上的数组称为多维数组。

## 一维数组 ##

### 1) 一维数组的定义和使用 ###

数组名字符合标识符的书写规定(数字、英文字母、下划线)  
数组名不能与其它变量名相同，同一作用域内是唯一的  
方括号\[\]中常量表达式表示数组元素的个数

int a[3]表示数组a有3个元素
    其下标从0开始计算，因此3个元素分别为a[0],a[1],a[2]

定义数组时\[\]内最好是常量，使用数组时\[\]内即可是常量，也可以是变量

**示例：**

#include<stdio.h>
    
    
    int main() {
        
        // 数组名和变量名定义方法一样
        //符号与[]结合代表这个是一个数组
        //数组中的元素的个数由[]里面的数值决定
        //每个元素的类型,数组名前面的类型决定
        //数值数组不能整体操作
        //数组的每一个元素都是变量,可以被改变赋值
        int i = 5;
        int num[10];
        //int sum[i]; //定义数组时,[]里面的值不能为变量,只能为常量
        num[i] = 100; //使用时,[]里面的值可以为常量也可以是变量
        for (int j = 0;  j<10; j++)
        {
        
            printf("num[%d]=%d\n", j, num[j]);
        }
        char name[2];
        name[0] = 't';
        name[1] = 'g';
        for (int k = 0; k < 2; k++)
        {
        
            printf("%c", name[k]);
        }
    	return 0;
    }

![在这里插入图片描述][bf9a8ada393b4b588d5417f49cd759bc.png]

### 2) 一维数组的初始化 ###

在定义数组的同时进行赋值，称为初始化。全局数组若不初始化，编译器将其初始化为零。局部数组若不初始化，内容为随机值。

**示例：**

#include<stdio.h>
    
    
    int main() {
        
        // 数组的初始化
        int num[5] = {
         1,2,3,4,5 };
        int sum[5] = {
         1,2 }; // 如果数组只初始化部分元素,其他元素被初始化为0
        int num2[10] = {
        0}; //将数组所有元素初始化为0
        int sum2[5] = {
         [3] = 3 }; // 给sum2数组下标为3的元素赋值3
        //int age[]; err  定义时没有告知有几个元素
        int  age[] = {
         17,18,19 };//如果定义时,[]中没有值,这个数组的元素个数由{}里面的元素个数决定
        for (int i = 0; i < 5; i++)
        {
        
            printf("%d ", num[i]);
        }
        printf("\n");
        for (int j = 0; j < 5; j++)
        {
        
            printf("%d ", sum[j]);
        }
        printf("\n");
        for (int j = 0; j < 10; j++)
        {
        
            printf("%d ", num2[j]);
        }
        printf("\n");
        for (int i = 0; i < 5; i++)
        {
        
            printf("%d ", sum2[i]);
        }
        return 0;
    }

![在这里插入图片描述][80ebd937c5894b3dac6d19071a585026.png]

### 3) 一维数组的大小 ###

**示例：**

#include<stdio.h>
    
    
    int main() {
        
    
        // 数组的大小
        int num[10] = {
         1,2,3,4,5,6,7,8,9,10 };
        printf("%d\n", sizeof(num)); // 40    10个int类型，每个int类型占4字节
        // 数组的元素个数
        int n = sizeof(num) / sizeof(num[0]);
        printf("n=%d\n", n);
        // 通过for循环打印num数组的元素
        for (int i = 0; i < sizeof(num) / sizeof(num[0]); i++)
        {
           
            printf("num[%d]=%d\n", i, num[i]);
        }
        return 0;
    }

![在这里插入图片描述][39b85d79f9414969a9a256a750c3eac8.png]

### 4) 一维数组数组名 ###

数组名是一个地址的常量，代表数组中首元素的地址。

#### 4.1 数据在内存中的地址 ####

![在这里插入图片描述][1e8b801a5dba4613bbdc0600c5f553c4.png_pic_center]

#### 4.2 数组在内存中的存储 ####

![在这里插入图片描述][c87a90ac91bd4208915531841ba5a080.png_pic_center]  
**补充：** `&` 在C语言中有两种意思，一种是取地址符，是单目运算符；另一种是位运算符，表示“按位与”，是双目运算符。  
  
**示例：**

#include<stdio.h>
    
    
    int main() {
        
    	int a[5];
    	// &a[0]  第0个元素的地址
    	printf("%u\n", &a[0]); // 19920604
    	printf("%u\n", a); // 19920604
    	// &a  整个数组地址
    	printf("%u\n", &a); // 19920604
    	printf("+++++++++++++++\n");
    	printf("%u\n", &a[0]+1); // 19920608
    	printf("%u\n", a+1); // 19920608
    	printf("%u\n", &a+1); // 19920624
    
    	return 0;
    }

![在这里插入图片描述][7759ba7388f04ec99d6c7b5a85bf39fd.png]

### 5) 强化训练 ###

#### 5.1 一维数组的最值 ####

#include<stdio.h>
    
    
    int main() {
        
    	int num[10] = {
         12,0,32,-21,432,34,87,3,-9,101 };
    	int max = num[0];
    	int min = num[0];
    	for (int i = 0; i < sizeof(num)/sizeof(num[0]); i++)
    	{
        
    		if (num[i]>max)
    		{
        
    			max = num[i];
    		}
    		else if (num[i]<min )
    		{
        
    			min = num[i];
    		}
    	}
    	printf("max=%d, min=%d", max, min); // max=432, min=-21
    	return 0;
    }

#### 5.2 一维数组的逆置 ####

int main() {
        
    	// 数组的逆置
    	// 方法1
    	int num[10] = {
         1,2,3,4,5,6,7,8,9,10 };
    	int i = 0;
    	int j = sizeof(num) / sizeof(num[0]) - 1;
    	int temp;
    
    	while (i<j)
    	{
        
    		temp = num[i];
    		num[i] = num[j];
    		num[j] = temp;
    		i++;
    		j--;
    	}
    	for (int i = 0; i < sizeof(num) / sizeof(num[0]); i++)
    	{
        
    		printf("%d ", num[i]);
    	}
    	printf("\n");
    	// 方法2
    	int a[10] = {
         1,2,3,4,5,6,7,8,9,10 };
    	int b[10];
    	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    	{
        
    		for (int j = sizeof(a) / sizeof(a[0])-1; j >=0 ; j--)
    		{
        
    			b[j] = a[i];
    			i++;
    		}
    	}
    	for (int i = 0; i < sizeof(b) / sizeof(b[0]); i++)
    	{
        
    		printf("%d ", b[i]);
    	}
    
    
    	return 0;
    }

![在这里插入图片描述][a9dcf34a0eda47f2a3e90324f3064a3a.png]

#### 5.3 冒泡法排序 ####

**冒泡排序的原理是：** 从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。

![在这里插入图片描述][96e875dde59b40cc9e750c7a8b06640b.gif_pic_center]  
![在这里插入图片描述][ba02ee02a6154cec9d73b71f49582156.png]

**示例：**

#include<stdio.h>
    
    
    int main() {
        
    	// 数组的排序—冒泡排序法—从小到大
    	int a[10] = {
         2,-5,-7,1,-4,8,3,-9,6,0 };
    	int n = sizeof(a) / sizeof(a[0]);
    	for (int i = 0; i < n-1; i++) //比较的轮数
    	{
        	// 因为每次比较的次数都要减1，刚好i每次加1，所以每一轮比较的次数就是n-1-i
    		for (int j = 0; j < n-1-i; j++) // 每一轮比较的次数
    		{
        
    			if (a[j]>a[j+1])  // 交换位置
    			{
        
    				int temp = a[j];
    				a[j] = a[j + 1];
    				a[j + 1] = temp;
    			}
    		}
    	}
    	for (int i = 0; i < n; i++) 
    	{
        
    		printf("%d ", a[i]); // -9 -7 -5 -4 0 1 2 3 6 8
    	}
    	printf("\n");
    	// 数组的排序—冒泡排序法—从大到小
    	int b[10] = {
         2,-5,-7,1,-4,8,3,-9,6,0 };
    	for (int i = 0; i < sizeof(b) / sizeof(b[0]) - 1; i++) //比较的轮数
    	{
        	// 因为每次比较的次数都要减1，刚好i每次加1，所以每一轮比较的次数就是n-1-i
    		for (unsigned int j = 0; j < sizeof(b) / sizeof(b[0]) - 1 - i; j++) // 每一轮比较的次数
    		{
        
    			if (b[j] < b[j + 1])  // 交换位置
    			{
        
    				int temp = b[j];
    				b[j] = b[j + 1];
    				b[j + 1] = temp;
    			}
    		}
    	}
    	for (int i = 0; i < n; i++)
    	{
        
    		printf("%d ", b[i]); // 8 6 3 2 1 0 -4 -5 -7 -9
    	}
    
    	return 0;
    }

![在这里插入图片描述][87d1636e406c46be9af35fbe5ed3e12c.png]

## 二维数组 ##

### 1) 二维数组的定义和使用 ###

二维数组定义的一般形式是：

> 类型说明符 数组名\[常量表达式1\]\[常量表达式2\]

其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。

**int a\[3\]\[4\];**

*  命名规则同一维数组
 *  定义了一个三行四列的数组，数组名为a其元素类型为整型，该数组的元素个数为3×4个，即：  
      
    ![在这里插入图片描述][55f38af67f7c4530bfc442e5ed934b66.png]  
    ![在这里插入图片描述][ad2e9c72ed1441d39cfc71b6de404dab.png]

二维数组a是按行进行存放的，先存放a\[0\]行，再存放a\[1\]行、a\[2\]行，并且每行有四个元素，也是依次存放的。

*  二维数组在概念上是二维的：其下标在两个方向上变化，对其访问一般需要两个下标。
 *  在内存中并不存在二维数组，二维数组实际的硬件存储器是连续编址的，也就是说内存中只有一维数组，即放完一行之后顺次放入第二行，和一维数组存放方式是一样的。

**示例：**

#include<stdio.h>
    
    
    int main() {
        
    	// 定义一个3行4列的二维数组
    	int a[3][4];
    	// 二维数组的每一个元素也是一个变量
    	a[0][0] = 10;
    	a[1][1] = 20;
    	a[2][3] = 30;
    	for (int i = 0; i < 3; i++)
    	{
        
    		for (int j = 0; j < 4; j++)
    		{
        
    			printf("%d ", a[i][j]);
    		}
    		printf("\n");
    	}
    
    
    	return 0;
    }

![在这里插入图片描述][2f85399660c94140bd8b35399c849223.png]

// a数组的大小
    printf("%d", sizeof(int [3][4]));  // 48 3*4=12  12*4B(int) = 48 字节
    printf("%d", sizeof(a)); //48

### 2) 二维数组的初始化 ###

**示例：**

#include<stdio.h>
    
    
    int main() {
        
    	// 第一种写法
    	int a[3][4] = {
         {
        1,2,3,4},{
        5,6,7,8},{
        9,10,11,12} };
    	// 第二种写法
    	int b[3][4] = {
         1,2,3,4,5,6,7,8,9,10,11,12 };
    	//定义二维数组时，不能省略列的下标，但可以省略行的下标
    	//int c[][] = { 1,2,3,4,5 }; // err  列的下标不能省略
    	// 给二维数组部分元素初始化，其他元素为0
    	int d[][3] = {
         1,2,3,4,5 };  // 只定义了列的下标为3，也就是一个一维数组有3个元素，超出3个的元素，自动添加一行，那么就是2行
    								 // 即第一行为 1,2,3 第二行为4,5,0（未初始化的元素，默认为0）
    
    	for (int i = 0; i < 2; i++)
    	{
        
    		for (int j = 0; j < 3; j++) 
    		{
        
    			printf("%d ", d[i][j]);
    		
    		}
    		printf("\n");
    	}
    	return 0;
    }

![在这里插入图片描述][dc28c1f883a84971ac5120dcc0eb5f90.png]

### 3) 二维数组的行和列 ###

#include<stdio.h>
    
    
    int main() {
        
    
    	int a[3][4] = {
         1,2,3,4,5 };
    
    	// 元素的个数
    	int n = sizeof(a) / sizeof(a[0][0]); // 二维数组的总大小除以 一个元素的大小=元素个数
    	// 数组的行
    	int line = sizeof(a) / sizeof(a[0]); // 二维数组总大小除以 一行的大小=行数
    	// 数组的列
    	int column = sizeof(a[0]) / sizeof(a[0][0]); // 二维数组一行的大小除以 一个元素的大小 = 列数
    
    	printf("%d个元素 %d行 %d列", n, line, column); // 12个元素 3行 4列
    
    	return 0;
    }

### 4) 二维数组数组名 ###

![在这里插入图片描述][9a43004ccfe2486ea94cd26dc942336a.png]  
**示例：**

#include<stdio.h>
    
    
    int main() {
        
    
    	int a[2][3];
    
    	printf("%u\n", &a[0][0]); // 7338640
    	printf("%u\n", a[0]); // 7338640
    	printf("%u\n", &a[0]); // 7338640
    	printf("%u\n", a); // 7338640
    	printf("%u\n", &a); // 7338640
    	printf("+++++++++++++++\n");
    	printf("%u\n", &a[0][0]+1); // 7338644
    	printf("%u\n", a[0]+1); // 7338644
    	printf("%u\n", &a[0]+1); // 7338652
    	printf("%u\n", a+1); // 7338652
    	printf("%u\n", &a+1); // 7338664
    	return 0;
    }

![在这里插入图片描述][10c07848605c4257b41e936b40aba4c7.png]

### 5) 强化训练 ###

**已知：** 老大的语数外成绩为80、75、 56，老二的语数外成绩为59、65、 71，老三的语数外成绩为59、63、70，老四的语数外成绩为85、45、90，老五的语数外成绩为76、77、45。  
  
![在这里插入图片描述][739e85710c1443f29bf526baf4eb774c.png]

**求1：** 各科的平均成绩

#include<stdio.h>
    
    
    int main() {
        
    	//二维数组：  五行、三列
    	//行代表人：  老大到老五
    	//列代表科目：语、数、外
    	float a[5][3] = {
         {
         80, 75, 56 }, {
         59, 65, 71 }, {
         59, 63, 70 }, {
         85, 45, 90 }, {
         76, 77, 45 } };
    	int person_line = sizeof(a) / sizeof(a[0]);  //行数  人员
    	int lesson_column = sizeof(a[0]) / sizeof(a[0][0]);  // 列数  课程
    	float lesson_aver[3] = {
        0};  // 定义一个数组，用于保存三个科目的平均分
    	int person_low[3] = {
         0 };  // 用于保存各科不及格人数
    	for (int i = 0; i < lesson_column; i++)  // 列
    	{
        	float sum = 0.0;  // 定义在行循环外好进行初始化，每一次sum的值都需要为0
    		for (int j = 0; j < person_line; j++)  // 行
    		{
        	
    			// 每一列科目分数总和
    			sum += a[j][i];  // 列不变，行变
    			lesson_aver[i] = sum / person_line;  // 每一列科目分数的总和 除以 人数也就是数组行数等到每个科目的平均分
    		}
    	}
    	// 各科的平均成绩
    	for (int i = 0; i < sizeof(lesson_aver) / sizeof(lesson_aver[0]); i++)
    	{
        
    		printf("%f\n", lesson_aver[i]);
    	}
    	return 0;
    }

![在这里插入图片描述][bee97e877e0744e0a46edee798b410b9.png]

**求2：** 各科不及格的人数

#include<stdio.h>
    
    
    int main() {
        
    	//二维数组：  五行、三列
    	//行代表人：  老大到老五
    	//列代表科目：语、数、外
    	float a[5][3] = {
         {
         80, 75, 56 }, {
         59, 65, 71 }, {
         59, 63, 70 }, {
         85, 45, 90 }, {
         76, 77, 45 } };
    	int lesson_line = sizeof(a) / sizeof(a[0]);  //行数  人员
    	int person_column = sizeof(a[0]) / sizeof(a[0][0]);  // 列数  课程
    	float lesson_aver[3] = {
        0};  // 定义一个数组，用于保存三个科目的平均分
    	int person_low[3] = {
         0 };  // 用于保存各科不及格人数
    	for (int i = 0; i < person_column; i++)  // 列
    	{
        	float sum = 0.0;  // 定义在行循环外好进行初始化，每一次sum的值都需要为0
    		for (int j = 0; j < lesson_line; j++)  // 行
    		{
        	
    			// 每一列科目分数总和
    			sum += a[j][i];  // 列不变，行变
    			// 每一列科目不及格的人数
    			if (a[j][i]<60)
    			{
        
    				person_low[i]++;  // 三个元素代表三科，外循环三列，所以在遍历每一列的科目时判断小于60的那么在person_low数组中的i元素+1计数即可
    			}
    			lesson_aver[i] = sum / lesson_line;  // 每一列科目分数的总和 除以 人数也就是数组行数等到每个科目的平均分
    		}
    	}
    	// 各科的平均成绩
    	for (int i = 0; i < sizeof(lesson_aver) / sizeof(lesson_aver[0]); i++)
    	{
        
    		printf("%f\n", lesson_aver[i]);
    	}
    	// 各科的不及格人数
    	for (int i = 0; i < sizeof(person_low) / sizeof(person_low[0]); i++)
    	{
        
    		printf("%d\n", person_low[i]);
    	}
    	return 0;
    }

![在这里插入图片描述][f5f925b215234b44a9423916f88db197.png]

## 多维数组（了解） ##

### 1) 多维数组的定义和使用 ###

多维数组的定义与二维数组类似，其语法格式具体如下：

> 数组类型修饰符 数组名 \[n1\]\[n2\]…\[nn\];

**int a\[2\]\[3\]\[4\];** 定义了一个三维数组，有2个二维数组，每个二维数组有3个一维数组，每个一维数组有4个元素。  
![在这里插入图片描述][b0380ead7779492a92f4a7115b41b8f4.png]

**示例：**

#include<stdio.h>
    
    
    int main() {
        
    
    	// 定义一个三维数组，有2个二维数组，每个二维数组有3个一维数组，每个一维数组有4个元素
    	int a[2][3][4];
    
    	a[0][0][0] = 10;
    	a[0][2][3] = 20;
    	a[1][0][0] = 30;
    	a[1][2][3] = 40;
    
    	for (int i = 0; i < 2; i++)
    	{
        
    		for (int j = 0; j < 3; j++)
    		{
        
    			for (int k = 0; k < 4; k++)
    			{
        
    				printf("%d ", a[i][j][k]);
    			}
    			printf("\n");
    		}
    		printf("\n");
    	}
    	// a数组的大小
    	printf("%d\n", sizeof(int[2][3][4]));  // 96 2*3*4=24 两个二维数组[3][4]  24*4B(int) = 96 字节
    	printf("%d", sizeof(a)); //96
    
    
    	return 0;
    }

![在这里插入图片描述][c92626a11a0d4058aa3ef70c6623e52e.png]

### 2) 多维数组的初始化 ###

**示例：**

#include<stdio.h>
    
    
    int main() {
        
    	// 第一种写法
    	int a[2][3][4] = {
         {
        {
        1,2,3,4},{
        5,6,7,8},{
        9,10,11,12}},  {
        {
        13,14,15,16},{
        17,18,19,20},{
        21,22,23,24}} };
    	// 第二种写法
    	int b[2][3][4] = {
         {
        1,2,3,4,5,6,7,8,9,10,11,12},{
        13,14,15,16,17,18,19,20,21,22,23,24} };
    	for (int i = 0; i < 2; i++)
    	{
        
    		for (int j = 0; j < 3; j++)
    		{
        
    			for (int k = 0; k < 4; k++)
    			{
        
    				printf("%d ", a[i][j][k]);
    			}
    		}
    		printf("\n");
    	}
    	printf("-------------------分割线-------------------\n");
    	for (int i = 0; i < 2; i++)
    	{
        
    		for (int j = 0; j < 3; j++)
    		{
        
    			for (int k = 0; k < 4; k++)
    			{
        
    				printf("%d ", b[i][j][k]);
    			}
    		}
    		printf("\n");
    	}
    
    
    	return 0;
    }

![在这里插入图片描述][c843e808af8e4515b9a22432d0e792cc.png]

[fbbc3112907d4f48ad32284953f92ab7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6fd5596da4ea4afd98ee5ce20e1864b2.png
[bf9a8ada393b4b588d5417f49cd759bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/08ff1eec3362481e922b3477b480da5a.png
[80ebd937c5894b3dac6d19071a585026.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3e42efda691b45c9ab7276000b6f9ec5.png
[39b85d79f9414969a9a256a750c3eac8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1ae29c66796a40408de3f01ebedc819d.png
[1e8b801a5dba4613bbdc0600c5f553c4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5d5dc5f641994fdcb16eb3fb36395dac.png
[c87a90ac91bd4208915531841ba5a080.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7ef9e7ae89e54d8ebde5199cc046ae80.png
[7759ba7388f04ec99d6c7b5a85bf39fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2aab0985205c49509476f45fbdac3c52.png
[a9dcf34a0eda47f2a3e90324f3064a3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2c380f8faecc47b7ba8fcfd858fa2753.png
[96e875dde59b40cc9e750c7a8b06640b.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/932e54f90fd9477983384d30a0bb9907.gif
[ba02ee02a6154cec9d73b71f49582156.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e16dd8d425d6431486e1c639b90155c8.png
[87d1636e406c46be9af35fbe5ed3e12c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/129e6063fd354c52b348b7cb4085aa66.png
[55f38af67f7c4530bfc442e5ed934b66.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/fbef269ee3e848cab126ca00e4af0517.png
[ad2e9c72ed1441d39cfc71b6de404dab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/870d8b8d7cbf4d33a4d42406abba254d.png
[2f85399660c94140bd8b35399c849223.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/053b30a655644dfab281d4a7340da5fa.png
[dc28c1f883a84971ac5120dcc0eb5f90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/16ba3504c9c84f0883760d7fd26594e9.png
[9a43004ccfe2486ea94cd26dc942336a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/bf6aff172d4c4a708098ae6493b9afd8.png
[10c07848605c4257b41e936b40aba4c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/820382425165442fad51ffc49bcec36d.png
[739e85710c1443f29bf526baf4eb774c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/41da6f2efec04ae0bc9f9d4776fc5f02.png
[bee97e877e0744e0a46edee798b410b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ebb285a9ae524df081e3569ea60d6904.png
[f5f925b215234b44a9423916f88db197.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f004982d44774cb3af213eefdec13817.png
[b0380ead7779492a92f4a7115b41b8f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/583401d49e514613a290f02cc69a9d0c.png
[c92626a11a0d4058aa3ef70c6623e52e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/649d713ad0ab4bb094681d212fc061cc.png
[c843e808af8e4515b9a22432d0e792cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/68560e49619542e5b4f0c0f2d3d54161.png