C语言学习笔记(二): 简单的C程序设计

左手的ㄟ右手 2023-09-24 17:51 20阅读 0赞

## 数据的表现形式 ##

### 常量 ###

在C语言中常量有以下几种：

*  **整型常量：** 0,-1,100
 *  **实型常量：** 小数形式(12.12)；指数形式(12.1e3= 12.1 × 1 0 3 12.1\\times 10^3 12.1×103)
 *  **字符常量：** 普通字符(’a’,’Z’,’\#’)；转义字符(’\\n’,’\\012’,’\\h1B’)
 *  **字符串常量：** “123”,”boy”
 *  **符号常量：** 用一个标识符来表示常量 `#define PI 3.14`

关于常量的使用要注意以下几点：

*  从常量的表示形式即可以判定其类型。
 *  不带小数点的数值是整型常量，但应注意其有效范围。
 *  在一个整数的末尾加大写字母L或小写字母l，表示它是长整型(long int)。
 *  凡以小数形式或指数形式出现的实数均是浮点型常量，在内存中都以指数形式存储。
 *  C编译系统把浮点型常量都按双精度处理，分配8个字节。

### 转义字符 ###

<table> 
 <thead> 
 <tr> 
 <th>转义字符</th> 
 <th>字符值</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td><code>\, \" \? \\</code></td> 
 <td>输出字符, " ? \</td> 
 </tr> 
 <tr> 
 <td><code>\a</code></td> 
 <td>警告(alert):产生声音或视觉信号</td> 
 </tr> 
 <tr> 
 <td><code>\b</code></td> 
 <td>退格:当前光标位置往后退一格</td> 
 </tr> 
 <tr> 
 <td><code>\f</code></td> 
 <td>换页:当前光标位置移到下一页开头</td> 
 </tr> 
 <tr> 
 <td><code>\n</code></td> 
 <td>换行:当前光标位置移到下一行开头</td> 
 </tr> 
 <tr> 
 <td><code>\r</code></td> 
 <td>回车:当前光标位置移到本行开头</td> 
 </tr> 
 <tr> 
 <td><code>\t</code></td> 
 <td>水平制表符:当前光标位置移到下个Tab位置</td> 
 </tr> 
 <tr> 
 <td><code>\v</code></td> 
 <td>垂直制表符:当前光标位置移到下个垂直制表符对齐点</td> 
 </tr> 
 <tr> 
 <td><code>\ooo</code> o表示八进制数</td> 
 <td>输出与该八进制对应的字符。如<code>\012</code>代表八进制数12(即十进制的10), 对应的ASCII码为换行符</td> 
 </tr> 
 <tr> 
 <td><code>\xhhh</code> h表示十六进制数</td> 
 <td>输出与该十六进制对应的字符</td> 
 </tr> 
 </tbody> 
</table>

### 变量 ###

一个变量由变量名、变量值和存储单元组成。变量名是指该变量的唯一标识符，用于在程序中识别该变量。变量值是该变量的实际数据值。存储单元则是存储变量值的内存区域

float a=3.14159;	//3.14159为双精度浮点常量，分配8个字节；a为float变量，分配4个字节,但是编译会发出警告,一般不影响结果的正确性，但会影响结果的精度
    float a=3.14159f;		//把此3.14159按单精度浮点常量处理，编译时不出现“警告”
    long double a = 1.23L;	//把此1.23作为long double型处理

### 常变量 ###

常变量与常量的异同是: 常变量具有变量的基本属性(有类型,存储单元)，只是不允许改变其值。

define Pi 3.1415926	//定义符号常量
    const float pi=3.1415926;	//定义常变量

### 标识符 ###

标识符就是一个对象的名字。用于标识变量、符号常量、函数、数组、类型等。

标识符只能由字母、数字和下划线3种字符组成，且第一个字符必须为字母或下划线

关于标识符要注意以下几点：

*  变量名区分大小写
 *  不能用关键字作为变量名
 *  不合法的标识符：3D64，\#33，M.D.

## 数据类型 ##

数据类型 \{ 基本类型 \{ 整型类型 \{ 基本整型 ( i n t ) : 4 字节 短整型 ( s h o r t    i n t ) : 2 字节 长整型 ( l o n g    i n t ) : 4 字节 双长整型 ( l o n g    l o n g    i n t ) : 8 字节 字符型 ( c h a r ) : 1 字节 浮点类型 \{ 单精度浮点型 ( f l o a t ) : 4 字节 双精度浮点型 ( d o u b l e ) : 8 字节 长双精度浮点型 ( l o n g    d o u b l e ) : 16 字节 枚举类型 ( e n u m ) 空类型 ( v o i d ) 派生类型 \{ 指针类型 ( ∗ ) 数组类型 ( \[ \] ) 结构体类型 ( s t r u c t ) 共用体类型 ( u n i o n ) 函数类型 \\text\{数据类型\}\\begin\{cases\} \\text\{基本类型\}\\begin\{cases\} \\text\{整型类型\}\\left\\\{ \\begin\{array\}\{c\} \\begin\{array\}\{l\} \\text\{基本整型\}\\left( int \\right) :4\\text\{字节\}\\\\ \\text\{短整型\}\\left( short\\,\\,int \\right) :2\\text\{字节\}\\\\ \\text\{长整型\}\\left( long\\,\\,int \\right) :4\\text\{字节\}\\\\ \\text\{双长整型\}\\left( long\\,\\,long\\,\\,int \\right) :8\\text\{字节\}\\\\ \\end\{array\}\\\\ \\end\{array\} \\right.\\\\ \\text\{字符型\}\\left( char \\right) :1\\text\{字节\}\\\\ \\text\{浮点类型\}\\begin\{cases\} \\text\{单精度浮点型\}\\left( float \\right) :4\\text\{字节\}\\\\ \\text\{双精度浮点型\}\\left( double \\right) :8\\text\{字节\}\\\\ \\text\{长双精度浮点型\}\\left( long\\,\\,double \\right) :16\\text\{字节\}\\\\ \\end\{cases\}\\\\ \\end\{cases\}\\\\ \\text\{枚举类型\}\\left( enum \\right)\\\\ \\text\{空类型\}\\left( void \\right)\\\\ \\text\{派生类型\}\\begin\{cases\} \\text\{指针类型\}\\left( \* \\right)\\\\ \\text\{数组类型\}\\left( \\left\[ \\right\] \\right)\\\\ \\text\{结构体类型\}\\left( struct \\right)\\\\ \\text\{共用体类型\}\\left( union \\right)\\\\ \\text\{函数类型\}\\\\ \\end\{cases\}\\\\ \\end\{cases\} 数据类型⎩⎨⎧基本类型⎩⎨⎧整型类型⎩⎨⎧基本整型(int):4字节短整型(shortint):2字节长整型(longint):4字节双长整型(longlongint):8字节字符型(char):1字节浮点类型⎩⎨⎧单精度浮点型(float):4字节双精度浮点型(double):8字节长双精度浮点型(longdouble):16字节枚举类型(enum)空类型(void)派生类型⎩⎨⎧指针类型(∗)数组类型(\[\])结构体类型(struct)共用体类型(union)函数类型

### 整形数据 ###

<table> 
 <thead> 
 <tr> 
 <th>整形数据类型</th> 
 <th>字节数</th> 
 <th>取值范围</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>int(基本整型)</td> 
 <td>4</td> 
 <td> − 2 31 ∼ ( 2 31 − 1 ) -2^{31}\sim \left( 2^{31}-1 \right) −231∼(231−1)</td> 
 </tr> 
 <tr> 
 <td>unsigned int(无符号基本整型)</td> 
 <td>4</td> 
 <td> 0 ∼ ( 2 32 − 1 ) 0\sim \left( 2^{32}-1 \right) 0∼(232−1)</td> 
 </tr> 
 <tr> 
 <td>short(短整型)</td> 
 <td>2</td> 
 <td> − 2 15 ∼ ( 2 15 − 1 ) -2^{15}\sim \left( 2^{15}-1 \right) −215∼(215−1)</td> 
 </tr> 
 <tr> 
 <td>unsigned short(无符号短整型)</td> 
 <td>2</td> 
 <td> 0 ∼ ( 2 16 − 1 ) 0\sim \left( 2^{16}-1 \right) 0∼(216−1)</td> 
 </tr> 
 <tr> 
 <td>long(长整型)</td> 
 <td>4</td> 
 <td> − 2 31 ∼ ( 2 31 − 1 ) -2^{31}\sim \left( 2^{31}-1 \right) −231∼(231−1)</td> 
 </tr> 
 <tr> 
 <td>unsigned long(无符号长整型)</td> 
 <td>4</td> 
 <td> 0 ∼ ( 2 32 − 1 ) 0\sim \left( 2^{32}-1 \right) 0∼(232−1)</td> 
 </tr> 
 <tr> 
 <td>long long(双长度)</td> 
 <td>8</td> 
 <td> − 2 63 ∼ ( 2 63 − 1 ) -2^{63}\sim \left( 2^{63}-1 \right) −263∼(263−1)</td> 
 </tr> 
 <tr> 
 <td>unsigned long long(无符号双长度)</td> 
 <td>8</td> 
 <td> 0 ∼ ( 2 64 − 1 ) 0\sim \left( 2^{64}-1 \right) 0∼(264−1)</td> 
 </tr> 
 </tbody> 
</table>

只有整型(包括字符型)数据可以加signed或unsigned修饰符，实型数据不能加。

对无符号整型数据用`%u`格式输出。`%u`表示用无符号十进制数的格式输出。如:

unsigned short price=50;	//定义price为无符号短整型变量
    printf("%u\n",price); 		//指定用无符号十进制数的格式输出

在将一个变量定义为无符号整型后，不应向它赋予一个负值，否则会得到错误的结果。

unsigned short price = -1;	//不能把一个负整数存储在无符号变量中
    printf("%d\n",price);

![image-20211206221449749][]

### 字符型数据 ###

在C语言中，字符型数据通常以ASCII码的形式存储

字符型数据包括如下几点：

* 字母: 大写英文字母A~Z，小写英文字母a~z
 * 数字: 0～9
 * 专门符号: 29个,包括：! " \# & ’ ( ) \* + , - . / : ; < = > ? \[ \\ \] ^ \_ \` \{ | \} ~
 * 空格符: 空格、水平制表符(tab)、垂直制表符、换行、换页(form feed)
 * 不能显示的字符：空(null)字符(以’\\0’表示)、警告(以’\\a’表示)、退格(以’\\b’表示)、回车(以’\\r’表示)等

在C语言中，字符型数据通常以ASCII码的形式存储

char c='?';	//定义c为字符型变量并使初值为字符′?′。′?′的ASCII代码是63，系统把整数63赋给变量c。
    printf("%d %c\n",c,c);	//用“%d”格式输出十进制整数63，用“%c”格式输出字符′?′

### 浮点型数据 ###

浮点数类型包括`float`(单精度浮点型)、`double`(双精度浮点型)、`long double`(长双精度浮点型)。

<table> 
 <thead> 
 <tr> 
 <th>类型</th> 
 <th>字节数</th> 
 <th>小数点后位数</th> 
 <th>数值范围(绝对值)</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>float</td> 
 <td>4</td> 
 <td>6</td> 
 <td> 0 以及 12 ∗ 1 0 − 38 ∼ 3.4 ∗ 1 0 38 0\text{以及}12*10^{-38}\sim 3.4*10^{38} 0以及12∗10−38∼3.4∗1038</td> 
 </tr> 
 <tr> 
 <td>double</td> 
 <td>8</td> 
 <td>15</td> 
 <td> 0 以及 2.3 ∗ 1 0 − 308 ∼ 1.7 ∗ 1 0 308 0\text{以及}2.3*10^{-308}\sim 1.7*10^{308} 0以及2.3∗10−308∼1.7∗10308</td> 
 </tr> 
 <tr> 
 <td>long double</td> 
 <td>16</td> 
 <td>19</td> 
 <td> 0 以及 3.4 ∗ 1 0 − 4932 ∼ 1.1 ∗ 1 0 308 0\text{以及}3.4*10^{-4932}\sim 1.1*10^{308} 0以及3.4∗10−4932∼1.1∗10308</td> 
 </tr> 
 </tbody> 
</table>

## 运算符与表达式 ##

下图总结了C语言中所有的运算符

![image-20211207203849094][]

<table> 
 <thead> 
 <tr> 
 <th>算数运算符</th> 
 <th>含义</th> 
 <th>举例</th> 
 <th>结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>+ - * /</td> 
 <td>加减乘除</td> 
 <td>略</td> 
 <td>略</td> 
 </tr> 
 <tr> 
 <td>%</td> 
 <td>求余运算符</td> 
 <td>a%b</td> 
 <td>a除以b的余数</td> 
 </tr> 
 <tr> 
 <td>i++ i–</td> 
 <td>在使用ｉ之后，使ｉ的值加/减1</td> 
 <td>int i=3; printf(“%d”,i++);</td> 
 <td>输出3</td> 
 </tr> 
 <tr> 
 <td>++i --i</td> 
 <td>在使用ｉ之前，使ｉ的值加/减1</td> 
 <td>int i=3; printf(“%d”,++i);</td> 
 <td>输出4</td> 
 </tr> 
 <tr> 
 <td>两个实数相除的结果是双精度实数，两个整数相除的结果为整数</td> 
 <td></td> 
 <td></td> 
 <td></td> 
 </tr> 
 </tbody> 
</table>

以下是使用算数运算符要注意的几点:

*  `%`运算符要求参加运算的运算对象为整数，结果也是整数，除数可以为0，但是被除数不能为0
 *  两个实数相除的结果是双精度实数，两个整数相除的结果为整数

### 不同类型间的混和运算 ###

*  \+、-、\*、/运算的两个数中有一个数为float或double型，结果是double型，因为系统将所有float型数据都先转换为double型，然后进行运算。
 *  如果int型与float或double型数据进行运算，先把int型和float型数据转换为double型，然后进行运算，结果是double型。
 *  字符(char)型数据与整型数据进行运算，就是把字符的ASCII代码与整型数据进行运算。如果字符型数据与实型数据进行运算，则将字符的ASCII代码转换为double型数据，然后进行运算。

### 强制类型转换 ###

强制类型转换是指在C语言中，显式地把一种数据类型转换为另一种数据类型

(double)a		//将ａ转换成double型
    (int)(x+y)		//将x+y的值转换成int型
    (float)(5%3)	//将5%3的值转换成float型
    (int)x+y		//只将x转换成整型，然后与y相加

## C语句 ##

C语句是C语言的基本单位，是C程序的最小可执行单元

常用的C语句包括：控制语句、调用语句、空语句、复合语句、赋值语句

### 控制语句 ###

以下是常用的控制语句：

*  `if()…else…`（条件语句）
 *  `for()…`（循环语句）
 *  `while()…`（循环语句）
 *  `do…while ()`（循环语句）
 *  `continue`（结束本次循环语句）
 *  `break`（中止执行switch或循环语句）
 *  `switch`（多分支选择语句）
 *  `return`（从函数返回语句）
 *  `goto`（转向语句，在结构化程序中基本不用goto语句)

### 调用语句 ###

函数调用语句由一个函数调用加一个分号构成。

printf("This is a C statement. "); //其中printf("This is a C statement. ")是一个函数调用，加一个分号成为一个语句

### 空语句 ###

只有一个分号的语句即为空语句。

可以用来作为流程的转向点(流程从程序其他地方转到此语句处)；

也可用来作为循环语句中的循环体（循环体是空语句，表示循环体什么也不做）。

### 复合语句 ###

可以用`{}`把一些语句和声明括起来成为复合语句(又称语句块)。

{
        
    	float pi=3.14159, r=2.5, area; //定义变量
    	area=pi*r*r;
    	printf("area=%f",area);
    }
    /*注意:复合语句中最后一个语句末尾的分号不能忽略不写。*/

### 赋值语句 ###

在赋值符`=`之前加上其他运算符，可以构成复合运算符

a+=3	//等价于a=a+3
    
    x*=y+8 	//等价于x=x*(y+8)
    
    x％=3	//等价于x=x％3

将一个占字节多的整型数据赋给一个占字节少的整型变量或字符变量时，只将其低字节原封不动地送到被赋值的变量（即发生“截断”）  
 \{ 浮点 → 整型变量 : 浮点取整 ( 去小数 ) , 再赋值 整型 → 单双精度变量 : 数值不变 , 以浮点数形式存储到变量中 d o u b l e → f l o a t 变量 : 双精度转化为单精度 , 取 6 ∼ 7 位有效数字 注 : 双精度数值大小不能超过单精度数值 f l o a t → d o u b l e 变量 : 数值不变 , 在内存中以 8 个字节存储 , 有效位数扩展到 15 位 字符型 → 整型变量 : 字符的 A S C I I 代码赋值给整型变量 \\begin\{cases\} \\text\{浮点\}\\rightarrow \\text\{整型变量\}:\\text\{浮点取整\}\\left( \\text\{去小数\} \\right) ,\\text\{再赋值\}\\\\ \\text\{整型\}\\rightarrow \\text\{单双精度变量\}:\\text\{数值不变\},\\text\{以浮点数形式存储到变量中\}\\\\ double\\rightarrow float\\text\{变量\}:\\text\{双精度转化为单精度\},\\text\{取\}6\\sim 7\\text\{位有效数字\}\_\{\\text\{注\}:\\text\{双精度数值大小不能超过单精度数值\}\}\\\\ float\\rightarrow double\\text\{变量\}:\\text\{数值不变\},\\text\{在内存中以\}8\\text\{个字节存储\},\\text\{有效位数扩展到\}15\\text\{位\}\\\\ \\text\{字符型\}\\rightarrow \\text\{整型变量\}:\\text\{字符的\}ASCII\\text\{代码赋值给整型变量\}\\\\ \\end\{cases\} ⎩⎨⎧浮点→整型变量:浮点取整(去小数),再赋值整型→单双精度变量:数值不变,以浮点数形式存储到变量中double→float变量:双精度转化为单精度,取6∼7位有效数字注:双精度数值大小不能超过单精度数值float→double变量:数值不变,在内存中以8个字节存储,有效位数扩展到15位字符型→整型变量:字符的ASCII代码赋值给整型变量

以下是常见的变量赋值代码：

int a,b,c=5；	//指定a,ｂ,c为整型变量，但只对c初始化，c的初值为５；相当于int a,b,c; c=5;
        
    int a=3,b=3,c=3; //对几个变量赋予同一个初值
    
    int a=b=c=3;     //错误。可以先定义，再用赋值语句，即int a,b,c; a=b=c=3;

## 数据的输入和输出 ##

数据的输入和输出是指在计算机主机环境中的输入输出操作

C语言本身不提供输入输出语句,输入和输出操作是由C标准函数库中的函数来实现的

要在程序文件的开头用预处理指令`#include`把有关头文件放在本程序中, 如下代码所示

include "c:\cpp\include\myfile.h" //按指定路径查找文件
 include "myfile.h" //源程序文件所在目录
 include <myfile.h> //C编译系统指定的include目录

### printf函数 ###

#### 定义 ####

`printf`函数是C语言中常用的输出函数，它可以将指定格式的字符串和数据通过标准输出（通常是控制台）输出到屏幕或文件

语法格式如下, 其中，`format` 参数是一个字符串，指定了输出的格式。格式字符串可以包含字符、数字、字符串和特殊字符等。后面的参数是根据格式字符串来确定输出内容的数据

printf(const char *format, ...);

<table> 
 <thead> 
 <tr> 
 <th>格式字符</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td><code>%d</code>,<code>%i</code></td> 
 <td>以带符号的十进制形式输出整数</td> 
 </tr> 
 <tr> 
 <td><code>%o</code></td> 
 <td>以八进制无符号形式输出整数</td> 
 </tr> 
 <tr> 
 <td><code>%x</code>,<code>%X</code></td> 
 <td>以十六进制无符号形式输出整数（不输出前导符0x），用x则输出十六进制数的a～f时以小写形式输出，用X时，则以大写字母输出</td> 
 </tr> 
 <tr> 
 <td><code>%u</code></td> 
 <td>以无符号十进制形式输出整数</td> 
 </tr> 
 <tr> 
 <td><code>%c</code></td> 
 <td>以字符形式输出，只输出一个字符</td> 
 </tr> 
 <tr> 
 <td><code>%s</code></td> 
 <td>输出字符串</td> 
 </tr> 
 <tr> 
 <td><code>%f</code></td> 
 <td>以小数形式输出单、双精度数，含输出6位小数</td> 
 </tr> 
 <tr> 
 <td><code>%e</code>,<code>%E</code></td> 
 <td>以指数形式输出实数，用e时指数以“e”表示(如1.2e+02)，用E时指数以“E”表示(如1.2E+02)</td> 
 </tr> 
 <tr> 
 <td><code>%g</code>,<code>%G</code></td> 
 <td>选用<code>%</code>f或<code>%e</code>格式中输出宽度较短的一种格式，不输出无意义的0。用G时，若以指数形式输出，则指数以大写表示</td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
 <tr> 
 <th>附加字符</th> 
 <th>说明</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>I</td> 
 <td>长整型整数，可加在格式符ｄ、ｏ、ｘ、ｕ前面</td> 
 </tr> 
 <tr> 
 <td>m</td> 
 <td>数据最小宽度</td> 
 </tr> 
 <tr> 
 <td>n</td> 
 <td>对实数，表示输出ｎ位小数</td> 
 </tr> 
 </tbody> 
</table>

#### 使用实例 ####

include <stdio.h>
 
 int main()
 {
 
 int num = 123;
 float pi = 3.14159265;
 char c = 'A';
 char s[] = "Hello World!";
 
 printf("整数: %d\n", num); //整数:123
 printf("小数: %.2f\n", pi); //小数:3.14
 printf("字符: %c\n", c); //字符:A
 printf("字符串: %s\n", s); //字符串: Hello World!
 
 return 0;
 }

### scanf函数 ###

#### 定义 ####

`scanf`函数是C语言中的标准输入函数，它可以从键盘读取数据，并把读取到的数据转换成指定的数据类型存储到变量中

下图是`scanf`函数的使用语法

![image-20211209202934940][]

#### 使用实例 ####

在下述代码中, 由于scanf函数只读入第一个字符串, 所以输出的是"Hello"

int main(){
        
    	char str[100];
    	scanf("%s", str);  //控制台输入: Hello World
    	printf("%s", str);	//控制台输出: Hello
    }

若想`scanf`读入一整行字符串, 可以使用如下语句

> 该语句的格式说明符`%[^\n]`的意思是读取以换行符为结尾的所有字符

scanf("%[^\n]", str);

### putchar函数 ###

#### 定义 ####

`putchar` 函数是 C 语言中的标准库函数，用于向标准输出（通常是终端）输出一个字符

#### 使用实例 ####

include <stdio.h>
 int main()
 {
 
 	char a='B',b='O',c='Y';	//定义3个字符变量并初始化
 	putchar(a);				//向显示器输出字符B
 	putchar(b);				//向显示器输出字符O
 	putchar(c);				//向显示器输出字符Y
 	putchar ('\n');			//向显示器输出一个换行符
 	return 0;
 } //运行后输出BOY

include <stdio.h>
 int main()
 {
 
 	int a=66,b=79,c=89; 
 	putchar(a);	
 	putchar(b);	
 	putchar(c);
 	putchar ('\n'); //输出整型变量(ASCII码)对应的字符
 	return 0; 
 }

### getchar函数 ###

#### 定义 ####

`getchar` 函数是 C 语言标准库中的一个输入函数。它用于从标准输入（例如键盘）读取一个字符

#### 使用实例 ####

从键盘输入一个大写字母，在显示屏上显示对应的小写字母

include <stdio.h>
 int main ()
 {
 
 	char c1,c2;
 	c1=getchar();	//从键盘读入一个大写字母，赋给字符变量c1
 	c2=c1+32;	//得到对应的小写字母的ASCII代码，放在字符变量c2中
 	printf("大写字母: %c\n小写字母: %c\n",c1,c2);	//输出c1,c2的值
 	return 0;
 }

[image-20211206221449749]: https://img-blog.csdnimg.cn/img_convert/69d760ddd2647ef7785aa3a815ab913b.png
[image-20211207203849094]: https://img-blog.csdnimg.cn/img_convert/474836b81b90bf7101ce852d29288a04.png
[image-20211209202934940]: https://img-blog.csdnimg.cn/img_convert/26155ada092f2e1af3b3f3a6535f10fe.png