C语言 | 【03】基础(运算符、流程结构、字符串、数组)

小鱼儿 2022-11-06 12:56 14阅读 0赞

### 文章目录 ###

*   *  运算符与表达式
     *   *   *  运算符分类
     *  程序流程结构
     *   *   *  选择结构
             *  循环语句
             *  跳转语句
     *  数组与字符串
     *   *   *  概述
             *  冒泡排序
             *  二维数组
             *  多维数组
             *  字符数组
             *  随机数
             *  获取时间
             *  三色球案例
             *  字符串处理函数

## 运算符与表达式 ##

#### 运算符分类 ####

**类型总结**

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>算术运算符</td> 
   <td>处理四则运算</td> 
  </tr> 
  <tr> 
   <td>赋值运算符</td> 
   <td>将表达式的值赋给变量</td> 
  </tr> 
  <tr> 
   <td>比较运算符</td> 
   <td>表达式比较，返回真或假（True、False）</td> 
  </tr> 
  <tr> 
   <td>逻辑运算符</td> 
   <td>根据表达式的值返回真或假值</td> 
  </tr> 
  <tr> 
   <td>位运算符</td> 
   <td>处理数据的位运算</td> 
  </tr> 
  <tr> 
   <td>sizeof运算符</td> 
   <td>字节数长度</td> 
  </tr> 
 </tbody> 
</table>

**运算符优先级**

<table> 
 <thead> 
  <tr> 
   <th>优先级</th> 
   <th>运算符</th> 
   <th>含义</th> 
   <th>使用</th> 
   <th>方向</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><code>[]</code></td> 
   <td>数组下标</td> 
   <td>数组名[常量表达式]</td> 
   <td>左到右</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td><code>()</code></td> 
   <td>圆括号</td> 
   <td>表达式/函数名的参数表</td> 
   <td>左到右</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td><code>.</code></td> 
   <td>成员选择(对象)</td> 
   <td>对象.成员名</td> 
   <td>左到右</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td><code>-&gt;</code></td> 
   <td>成员选择(指针)</td> 
   <td>对象指针-&gt;成员名</td> 
   <td>左到右</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>-</td> 
   <td>负号</td> 
   <td>-表达式</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>~</td> 
   <td>按位取反运算符</td> 
   <td>~表达式</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>++</td> 
   <td>自增运算符</td> 
   <td>++变量名/变量名++</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>–</td> 
   <td>自减运算符</td> 
   <td>–变量名/变量名–</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>*</td> 
   <td>取值运算符</td> 
   <td>*指针变量</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>&amp;</td> 
   <td>取地址运算符</td> 
   <td>&amp;变量名</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>!</td> 
   <td>逻辑非运算符</td> 
   <td>!表达式</td> 
   <td>右到左</td> 
   <td>单目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>(类型)</td> 
   <td>强制类型转换</td> 
   <td>(数据类型)表达式</td> 
   <td>右到左</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>sizeof</td> 
   <td>长度运算符</td> 
   <td>sizeof(表达式)</td> 
   <td>右到左</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>/</td> 
   <td>除</td> 
   <td>表达式/表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>*</td> 
   <td>乘</td> 
   <td>表达式*表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>%</td> 
   <td>余数(取模)</td> 
   <td>整形表达式%整型表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>+</td> 
   <td>加</td> 
   <td>表达式+表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>-</td> 
   <td>减</td> 
   <td>表达式-表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>&lt;&lt;</td> 
   <td>左移</td> 
   <td>变量&lt;&lt;表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>&gt;&gt;</td> 
   <td>右移</td> 
   <td>变量 &gt;&gt; 表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>&gt;</td> 
   <td>大于</td> 
   <td>表达式&gt;表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>&gt;=</td> 
   <td>大于等于</td> 
   <td>表达式&gt;=表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>&lt;</td> 
   <td>小于</td> 
   <td>表达式&lt;表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>&lt;=</td> 
   <td>小于等于</td> 
   <td>表达式&lt;=表达式</td> 
   <td>左到右</td> 
   <td>双目运算符</td> 
  </tr> 
 </tbody> 
</table>

**类型转换**

>  *  自动转换(隐式转换)：遵循一定的规则，由编译系统自动完成；
>  *  强制类型转换：把表达式的运算结果强制转换成所需的数据类型；  
>     ***原则：占用内存字节数少的类型，向字节数多的类型转换，来保证精度不降低***

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70]

## 程序流程结构 ##

**概述**

> C语言支持最基本的三种程序运行结构:
> 
>  *  顺序结构:程序按顺序执行,不发生跳转。
>  *  选择结构:依据是否满足条件,有选择的执行相应功能。
>  *  循环结构:依据条件是否满足,循环多次执行某段代码。

#### 选择结构 ####

**if语句流程**  
![>][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 1]

**if语句**

#include<stdio.h>
    
    
    int main(){ 
    
    	if (条件)
    	{ 
    		表达式;
    	}
    	// if……else
    	if (条件)
    	{ 
    		表达式;
    	}
    	else{ 
    		表达式;
    	}
    	
    	// if……else if……else
    	if(表达式)
    	{ 
    		表达式;
    	}
    	else if()
    	{ 
    		表达式;
    	}
    	else{ 
    		表达式;
    	}
    	return 0;
    }

**三目运算符**

> `表达式 ? 值1 : 值2` 若表达式为真，则返回值1，若为假则返回值2。

**switch语句**

#include<stdio.h>
    
    
    int main()
    { 
    	switch(表达式){ 
    		case 值1: 代码;break;
    		case 值2: 代码;break;
    		default: 代码;break;
    	}
    
    	return 0;
    }

***`if`与`switch`的区别***：

> `if` 判断一个区间，`switch` 判断一直值执行效率高。

#### 循环语句 ####

**while流程图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 2]  
**while语句**

#include<stdio.h>
    
    
    int main()
    { 
    	while(条件)
    	{ 
    		代码;
    	}	
    
    	// do……while
    	do
    	{ 
    		代码;
    	}while(条件);
    	return 0;
    }

**for语句**

#include<stdio.h>
    
    int main()
    { 
    	// for(初始值; 表达式; 表达式)
    	for(int i=0; i<=100; i++){ 
    		代码;
    	}	
    
    	return 0;
    }

#### 跳转语句 ####

>  *  `break`：跳出语句
>  *  `continue`：当执行到改语句时，会跳回循环
>  *  `goto`：无条件跳转

## 数组与字符串 ##

#### 概述 ####

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 3]

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

**格式**：

> `数据类型 数组名[元素个数]`
> 
>  *  元素个数：代表有多少个相同的数据类型的变量
>  *  下标从0开始

**获取数组的个数**

> `unsigned int = sizeof(数组名) / sizeof(数组元素)`

**数组内存结构**

> 使用 `&取地址`

#### 冒泡排序 ####

#include<stdio.h>
    
    int main()
    { 
    	int arr[10] = { 7, 4, 2, 3, 5, 8, 9, 6, 1, 10};
    	int len = sizeof(arr) / sizeof(arr[0]) -1;
    	for (int i=0; i<len; i++){ 
    		for (int j=0; j<len-i; j++){ 
    			if (arr[j] > arr[j+1]){ 
    				int temp = arr[j];
    				arr[j] = arr[j+1]
    				arr[j+1] = temp;
    			}
    		}
    	}
    
    
    	return 0;
    }

#### 二维数组 ####

**格式**

> `数据类型 数组名[数据长度][数据长度]`

**定义**

#include<stdio.h>
    
    int main(){ 
    
    	int arr[2][1] = { { 1},{ 2}};	// 俩行一列
    	int arr[][3] = { { 1,2},{ 1,2},{ 1,2}} // 行可省略不写
    	int arr[2][3] = { 1,2,3,4,5,6} // 阔以不用{}，1会自动分组 
    	
    
    }

#### 多维数组 ####

> 和前面的二维数组类似，就一层往一层套即可

#### 字符数组 ####

> **注意**：%s会接收字符串结束标志 `\0` 之前的所有字符，再ASCII中就是数字0

**定义**

> `char arr[9] = "hellow"` 或者 `char arr[9] = {'h', 'e', 'l', 'l', 'o', 'w'}`

#### 随机数 ####

#include<stdlib.h>
    void srand(unsigned int seed);
    // 功能：设置rand()产生随机数的随机种子
    // 参数：若每次seed()相等，则每次的随机数相等
    // 无返回值
    
    int rand(void);
    // 返回一个随机数值
    // 参数为空

**案例**

#include<stdio.h>
    #include<time.h>
    #include<stdlib.h>
    
    
    int main(){ 
    	
    	time_t MS = time(NULL);
    	srand((unsigned int)MS);
    	for (int i=0; i<10; i++){ 
    		printf("随机数：%d\n", rand());
    	}
    	return 0;
    }

#### 获取时间 ####

#include<time.h>
    time_t time(NULL);
    // 功能：获取当前系统时间
    // 参数：一般设置NULL
    // 返回值：【ms】返回一个long类型的当前系统时间值

#### 三色球案例 ####

#include<stdio.h>
    #include<string.h>
    #include<time.h>
    #include<stdlib.h>
    
    int main(){ 
    
    	srand((unsigned int)time(NULL));
    	// 双色球 红色+蓝色（6+1）红球1-33 篮球1-16
    	int ball[6];
    	for (int i=0; i<6; i++){ 
    		ball[i] = rand() % 33 + 1;
    		for (int j=0; j<i; j++){ 
    			if (ball[i] == ball[j]){ 
    				i--;
    				continue;
    			}
    		}
    	}	
    	return 0;
    }

#### 字符串处理函数 ####

**gets()**

> 获取字符串。

#include<stdio.h>
    
    char *gets(str);
    // 功能：从标准输入读入字符，保存到 `str` 指定的内存空间，知道换行符或文件结尾为止
    // 参数：字符串的首地址
    // 返回值：输入的str
    int main(){ 
    
    	printf("请输入字符串：");
    	gets(str);
    	printf("输入的字符串是：%s", str);
    	
    	return 0;
    }

> **与scanf的区别**：
> 
>  *  `gets(str)` 允许输入的字符串有空格。
> 
> **注意**：
> 
>  *  该俩种方法无法知道字符串的大小，必须遇到换行符或读到文件结尾才接收输入，故易导致缓冲区溢出的情况。【需要加入：`#define _CRT_SECURE_NO_WARNINGS`】

**getchar**：

> 获取一个字符。

**puts**

> 输出字符串。

#include<stdio.h>
    
    int puts(const char*s);
    // 功能：标准设备输出字符串，自动换行
    // 参数：字符串首地址
    // 返回值：-1 or 字符串

【注意】：`scanf("%s[^\n]", str)` 输入的时候可使用空格

**fgets**

> 获取字符串。

#include<stdio.h>
    
    char fgets(char *s, int size, FILE *stream);
    // 功能：从steam指定的文件内读入字符，保存到s所指定的内存空间，直到出现换行字符，读到文件结尾。
    // 参数：s-字符串；size：指定读取字符串最大
    // stream：读取文件到末尾
    // 注意：如果是输入[stdin]的话，输入字符串长度小于指针区域大小，会自动补上 `\n\0`

**fputs**

> 输出字符串。

#include<stdio.h>
    
    char fputs(char *s, FILE *stream);
    // 功能：输出s的内容
    // 参数：s-字符指针，stream-输出流

**scanf**

>  *  可接收换行结束、空格：`scanf('%[^\n]', s)`;
>  *  划分字符：`scanf("%1d%2d%3d", &a,&b,&c)` \- 输入一串abcdef --> a bc def;
>  *  `*` 表示忽略：`scanf("%*d%s", s)` 则输入时有数字的会被去除，只保留字符 `%*c` 屏蔽字符或者`%*[屏蔽的内容【符合正则用法】]`。

**printf**

>  *  保留小数：`printf("%.2f\n", 1.314520)` 即保留俩位小数；
>  *  空格：`printf("%2d", 250)` 即再250前面多加一个空格。若再2前添加0则空格由0代替。若再前面加个负号，则空格添加再右边；
>  *  字符串截取：`printf("%.2s","abcd")` 即打印 `ab`。

**strlen()**

> 获取字符串长度。

#include<stdio.h>
    
    size_t strlen(const char *s);
    // 功能：计算指定s的长度，但不包括结束符'\0'；
    // 返回值：字符串长度 unsigned int。
    // 【注意】：strlen获取有效长度，而sizeof获取的是字符串长度。不能处理字符数组
    
    
    //eg:
    char str[] = "Hellow world";
    int len = strlen(str);
    
    printf("%d\n", len);

**strcpy**

> 拷贝字符串。

#include<stdio.h>
    
    char *strcpy(char *dest, const char *src);
    // 功能：把stc所指向的字符串复制到dest指定的空间，结束符也会复制；
    // 返回值：返回dest字符串首地址。
    
    //eg:
    char dest[20] = "hello";
    char src[] = "world";
    
    strcpy(dest, src);

**strncpy**

> 字符串长度拷贝。

#include<stdio.h>
    
    char *strncpy(char *dest, char *src, int len);
    // 功能：将stc拷贝len个长度到dest中；
    // 参数：拷贝字符串长度。
    // 【注意】：有限拷贝不会将'\0'拷贝到字符串中

**strcat**

> 连接字符串。

#include<stdio.h>
    
    char *strcat(char *dest, const char *src);
    // 功能：将src字符串连接到dest尾部，'\0'也会追加
    // 参数：dest - 目标字符串；src - 源字符串
    // 返回值：dest字符串

**strncat**

> 指定字符串个数连接。

#include<stdio.h>
    
    char *strncat(char *dest, const char *src, size_t n);
    // 功能：将src的前n个字符连接到dest的尾部，'\0'也会
    // 参数：dest - 目标字符串；src - 源字符串；n - 个数
    // 返回值：dest字符串

**strcmp**

> 比较字符串。

#include<stdio.h>
    int strcmp(const char *str1, const char *str2);
    // 功能：比较俩个字符串ASCII大小
    // 参数：字符串1， 字符串2
    // 返回值：相等 - 0；大于 - >0；小于 - <0
    
    // eg：
    char str1[] = "wo";
    char str2[] = "ni";
    
    if (strcmp(str1, str2) == ){ 
    	printf("俩字符串相等！");
    }
    else{ 
    	printf("俩字符串不同！");
    }

**strncmp**

> 比较指定字符串个数。

#include<stdio.h>
    
    int strcmp(const char *str1, const char *str2, int n);
    // 功能：比较俩个字符串前n个字符。
    // 参数：字符串1， 字符串2，n个数。
    // 返回值：相等 - 0；大于 - >0；小于 - <0。

**sprintf**

> 格式化输出。

#include<stdio.h>
    
    int sprintf(char str1, 格式化, str2 );
    // 功能：根据参数format字符串来转换格式化数据，后将结果输出到str指定的空间中，直到出现字符串结束符'\0'为止。
    // 参数：str - 字符串首地址；format - 字符串格式化。
    // 返回值：成功 - 实际格式化的字符个数；失败 - -1。
    
    // eg：
    int a = 778;
    char arr[] = "买个鸡腿";
    char dest[50];
    sprintf(dest, "%s %d", arr, a);
    printf("%s", dest);

**sscanf**

> 格式化拆分。

#include<string.h>
    #include<stdio.h>
    int sscanf(char str1, 格式化, str2 );
    
    
    // eg：
    int a;
    char arr[50];
    char dest[50] = "买个鸡腿778";
    sscanf(dest, "%s %d", arr, &a);
    printf("%s", arr);
    printf("%d", a);

**strchr**

> 查找字符在字符串中的位置。

#include<string.h>
    #include<stdio.h>
    
    char *strchr(const char *s, int c);
    // 功能：再字符串s中查找字母c出现的位置。
    // 参数：s - 字符串首地址；c - 匹配字母(字符)。
    // 返回值：成功 - 返回第一次出现c的地址。
    
    char str[] = "abcsdhghc";
    char *p = strchr(str, 'c');
    printf("%s", *p);

**strstr**

> 字符串查找。

#include<strung.h>
    #include<stdio.h>
    
    char *strstr(const char *haystack, const char *needle);
    // 功能：在字符串haystck中查找字符串needle出现的位置。
    // 参数：haystck - 源字符串首地址；needle - 匹配字符串首地址。
    // 返回值：成功 - 返回第一次出现地址；失败 - NULL。

**strtok**

> 字符串分割。

#include<strung.h>
    #include<stdio.h>
    
    char *strtok(char *str, const char *delim);
    // 功能：将字符串分割成一个个片段，当strtok在字符串中发现delim中包含分割字符时，则会将该字符改为'\0'，若连续出现多个时只替换第一个为'\0'。
    // 参数：str - 指向欲分割的字符串；delim：为分割字符串中包含的所有字符。
    // 返回值：成功 - 分割后子字符串首地址；失败 - NULL。
    // 【注意】：第一次调用时，strtok()必须给予参数字符串；往后调用则将str设置成NULL，每次调用成功则返回指向杯分割出片段的指针。
    
    // eg：
    #include<stdio.h>
    #include<string.h>
    
    int main(){ 
    
        char a[100] = "123.223.133";
        char *s = strtok(a, ".");
    
        while (s!=NULL){ 
    
            printf("%s\n", s);
            s = strtok(NULL, ".");
        }
    
        return 0;
    }
    【result】:
    	123
    	223
    	133
    	
    	Process returned 0 (0x0)   execution time : 0.021 s
    	Press any key to continue.

**atoi**

> 转换为整型。

#include<stdio.h>
    #include<stdlib.h>
    
    int atoi(const char *str);
    // 功能：atoi会扫描str，跳过前面的空格，直到数字或正负号才开始转换，而遇到数字或字符串'\0'才结束，并将结果返回。
    // 参数：str - 要转换的字符串。
    // 返回值：返回转化后的整数。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70]: /images/20221023/6cafe43fffbc43a880772aadc734038f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221023/592f991d44964d969932421458f2d60b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 2]: /images/20221023/a55cb31005e344b3b71461684faaea19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 3]: /images/20221023/9f00b72a6d0c4325b72fb539d5dfe57a.png