计算机二级c语言考试复习大纲（一战到底）

目录

1.C语言关键字

1.数据类型关键字（12个）

2.控制语句关键字(12个)

3.存储类关键字(5个)

4.其他关键字(3个)

2.数据类型

2.1整型: int

1.整型变量的定义和输出

 2.2其他整型类型

 2.3字符型：char

2.4实型（浮点型）：float，double

2.5常量

2.6 C运算符的种类，运算优先级和结合性

 2.7不同数据类型之间的转换

3.输入输出函数的调用

4.选择结构程序设计

5.循环结构程序设计 

1.for循环：

 2.while循环

3. do while循环

4. break和continue语句

 6.数组的定义和引用

1.数组的定义

2.数组常见问题

3.二维数组的定义和使用

6.1 字符串和字符数组

1.创建字符串：

2.创建字符数组：

3.字符串 和字符数组区别

7.函数调用

7.1函数的初体验

1.函数的定义：

2.函数的分类：

3.函数的五要素：

7.2自定义函数的使用

1.函数的编写格式：

2.参数说明：

3.函数类型

4. 返回值

5.函数申明

6.函数的嵌套和递归        

7.3局部变量和全局变量

1.局部变量的定义

2.全局变量

8.编译预处理

8.1宏定义和调用

1. 无参数的宏定义（宏常量）

2.有参宏定义

8.2 头文件的编译预处理

9.指针

9.1地址与指针变量

1.内存地址

2.sizeof函数的计算

  3.指针

9.2指针作为函数的参数

 1.函数形参能改变实参的值。

2. 数组名做函数参数

9.3 指针的运算

1.指针能操作数组

2.指针的加减法运算

3.指针数组

10.结构体和共同体

10.1 结构体的定义

1.用typedef说明一个新类型。（起别名）

2.结构体类型和成员的引用

10.2 结构体数组

1.定义：

2.结构体数组排序：

3.结构体赋值

 10.3 共同体（联合体）

1.定义：

10.4 链表

1.定义

2.数组和链表的区别

11.位运算和进制运算

11.1.进制换算

11.2.位运算

1.按位取反~

2.位与（and） &

3.位或（or）|

4.位异或：^

5.左移 <<

6.右移 >>

11.3.位运算的应用

12.文件操作

12.1文件类型指针

12.2文件的打开与关闭

12.3.文件的读写

---

1.C语言关键字

1.数据类型关键字（12个）

char(字符型)  short（短整型）    int（整型）   long（长整型）

 float（单精度浮点型）    double（双精度浮点型 ）

unsigned（无符号） signed（有符号） 

struct（定义结构体）  union（定义联合体）  enum（枚举）  void（空类型）

2.控制语句关键字(12个)

if,else, switch, case, default，

for, do, while, break, continue, goto（无条件跳转语句）, return

3.存储类关键字(5个)

auto(局部变量),extern（声明），register（寄存器变量），static（静态变量），const（常量定义）

4.其他关键字(3个)

sizeof，typedef（数据别名），volatile

2.数据类型

2.1整型: int

1.整型变量的定义和输出

• %d：输出一个有符号的10进制int类型
• %o：输出8进制的int类型
• %x : 输出16进制的int类型，字母以小写输出
• %X : 输出16进制的int类型，字母以大写输出
• %u: 输出一个10进制的无符号数

案例1：输出输出整型变量

#include<stdio.h>
int main()
{//定义变量int a = 0;unsigned int b = 10;//调用输入函数，键盘获取值赋值给ascanf("%d",&a);//打印printf("无符号数据：%u\n",b);printf("十进制输出：%d\n",a);printf("八进制输出：%o\n",a);printf("十六进制输出：%x\n",a);printf("十六进制输出：%X\n",a);return 0;
}

 2.2其他整型类型

1.一个字节八个比特位。

• short（短整型）：2字节
• int(整型): 4个字节
• long(长整型)：Windows为4个字节
• long long(长长整型)：8个字节

2.不同操作系统所占的字节数不同，但都满足short<= int <= long。

3.注意：当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。

案例2：

#include <stdio.h>
int main()
{//短整型short a = 10;//长整型long b = 20;//长长整型long long c = 30;//输出格式printf("%hd\n",a);//10printf("%ld\n",b);//20printf("%lld\n",c);//30
}

 2.3字符型：char

占位一个字节。

ASCII码表：0：48 ， A：65 ，a: 97

案例3：字母大小写切换

#include <stdio.h>int main ()
{char ch;//输入一个小写字母scanf("%c",&ch);//a//在ASCII表中，A和a相差32printf("%c",ch-32);//Areturn 0;
}

2.4实型（浮点型）：float，double

实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。在C语言中，浮点型变量分为两种:单精度浮点数(float)、双精度浮点数(double)，

但是double型变量所表示的浮点数比float型变量更精确。

• float：占4个字节，31位有效数字
• double：占8个字节，63~64位有效数字

案例4：

#include <stdio.h>int main(){//单精度浮点型float pi = 3.14159;//浮点型默认保留六位小数printf("%f\n",pi);//3.141590//设置保留两位小数,会四舍五入printf("%.2f\n",pi);//3.14return 0;
}

 案例5：浮点型的输入输出

#include <stdio.h>int main(){float  pi;double a = 123.456;scanf("%f",&pi);//1.2222245//保留三位小数printf("%.3f\n",pi);//1.222printf("%lf\n",a);//123.456000return 0;
}

案例6：计算圆的面积和周长

#include <stdio.h>int main(){float pi = 3.14159;//定义半径，周长，面积float r;float s;float l;scanf("%f",&r);//2s = pi * r * r;l = 2*pi*r;printf("面积为：%.2f\n",s);//面积为：12.57printf("周长为：%.2f\n",l);//周长为：12.57return 0;
}

2.5常量

1.const修饰的变量为常量

    const float pi = 3.14;

2.使用#define定义：

#define PI 3.1415

3.定义变量是可以使用auto修饰，尽管是可以省略的

2.6 C运算符的种类，运算优先级和结合性

1.常见运算符 的分类

• 算术运算符：用于处理四则运算
• 赋值运算符:用于将表达式的值赋给变量
• 比较运算符: 用于表达式的比较,并返回一个真值或假值
• 逻辑运算符: 用于根据表达式的值返回真值或假值

与（&&）， 或（||），  非（!）

• 位运算符: 用于处理数据的位运算
• sizeof运算符: 用于求字节数长度

2.运算符优先级

优先级	运算符
1	[]   ()  .（成员选择） ->
2	-（负号）  ~  ++  --  *(指针变量)  &  !  (类型)  sizeof
3	/  * %
4	+  - （减法）
5	<<  >>
6	>  >=  <  <=
7	==   !=
8	&(按位与)
9	^（按位异或）
10	|  (按位或)
11	&& （逻辑与）
12	|| （逻辑或）
13	？（条件运算符）
14	=  /=  *=  %=  +=  -=  <<=  >>=  &=  ^=  |=
15	,(逗号运算符)

 2.7不同数据类型之间的转换

案例1：隐式转换

#include <stdio.h>int main(){int a = 1;float b = 1.233;double c;//隐式转换c = a* b;printf("%lf",c);//1.233000return 0;
}

案例2：强制转换

#include <stdio.h>int main(){int a;double b = 1.222;a = (int)b;//强制转换 不会四舍五入printf("%d\n",a);//1return 0;
}

3.输入输出函数的调用

1.print函数：

打印格式	对应数据类型·	含义
%d	int	接受整数值并将它表示为有符号的十进制整数。
%hd	short int	短整数
%hu	unsigned short	无符号短整数
%o	unsigned int	无符号8进制整数。例如：0123
%u	unsigned int	无符号10进制整数。
%x，%X	unsigned int	无符号16进制整数，x是小写,X对应的是大写
%f	float	单精度浮点数
%lf	double	双精度浮点数
%c	char	字符型:可以把输入的数字按照ASCII码相应转换为对应的字符
%%	%	输出一个百分号

2.scanf函数

&符号表示取地址。

scanf("%d",&a);

4.选择结构程序设计

1.if语句的演示：

#include <stdio.h>int main(){int score;scanf("%d",&score);if(score > 700){printf("我要上清华\n");} else if(score > 680){printf("我要上北大\n");}else{printf("我要上蓝翔\n");}return 0;
}

 2.switch语句：

#include <stdio.h>int main(){int a;scanf("%d",&a);//当switch遇到break表示结束switch (a) {case 1:printf("您输入的值是： 1\n");break;case 2:printf("您输入的值是： 2\n");break;default:printf("输入未知\n");break;}return 0;
}

3.三目运算符

#include <stdio.h>int main(){int a,b;scanf("%d%d",&a,&b);//三目运算符，表达式为真输出a，反之输出bprintf("最大值为： %d",a > b ? a : b);return 0;
}

5.循环结构程序设计 

1.for循环：

案例1：计算数字之和

#include <stdio.h>int main ()
{int sum = 0;for(int i = 0; i<= 100;i++){sum += i;}printf("100以内的数字和为： %d",sum);return  0;
}

案例2：找出所有与7有关的数字

#include <stdio.h>int main() {for (int i = 1; i < 100; i++) {if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7) {printf("敲桌子\n");} else {printf("%d\n", i);}}return 0;
}

 2.while循环

案例1:100到999之间的水仙花数

#include <stdio.h>int main(){int i =100;int a ,b,c;while (i<1000){//百位a = i/100;//十位b = i /10%10;//个位c = i%10;if (a*a*a + b*b*b + c*c*c == i){printf("水仙花数： %d\n",i);}i++;}return 0;
}

3. do while循环

案例1：调用函数库并实现水仙花数

#include <stdio.h>
#include <math.h>
int main(){int i =100;int a,b,c;do {a = i/100;b = i /10 %10;c = i %10;//调用math的函数库if (pow(a,3) + b*b*b + c*c*c == i){printf("水仙花数为： %d",i);//水仙花数为： 153水仙花数为： 370水仙花数为： 371水仙花数为： 407}i++;} while (i<1000);return 0;
}

4. break和continue语句

• break语句在循环当中，作用是跳出当前内循环语句，执行后面的代码。
• continue语句：立即终止本次循环，并执行下一次循环。

案例1：九九乘法表

#include <stdio.h>int main() {for (int i = 1; i < 10; i++) {for (int j = 1; j <i+1; j++) {printf("%d * %d = %d ", j, i, i * j);}printf("\n");}return 0;
}

 6.数组的定义和引用

1.数组的定义

格式：数据类型 数组名[元素个数]；

例如：

指定长度，默认填充为0。

    int arr1[10];

指定长度和赋值。 

    //定义数组时赋值int arr2[10] = {1,2,3,4,5,6,7,8,9,10};

可以不定义数组长度，直接赋值 。

    int arr3[] = {1,2,3,4,5,6,7,8,9,10};

案例1：

#include <stdio.h>int main(){int arr1[10];//定义数组时赋值int arr2[10] = {1,2,3,4,5,6,7,8,9,10};for (int i = 0; i < 10; i++) {printf("%d\n",arr2[i]);}return 0;
}

2.数组常见问题

• c语言不支持动态数组，数组必须在编译时定义长度。
• 长度支持常量定义。

案例1：冒泡排序

#include <stdio.h>int main(){int arr[10] = {22,33,55,11,565,78,1,43,8,9};int temp;for(int i = 0; i < 9; i++) {for (int j = i+1; j < 10; j++) {if (arr[i]>arr[j]){temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}for (int i = 0; i < 10; i++){printf("%d ",arr[i]);}
}

3.二维数组的定义和使用

格式：  数据类型 数组名[行][列]

案例1：

#include <stdio.h>int main(){//数据类型 数组名[行][列]int arr[2][3] ={{10,20,30},{40,50,60}};for (int i = 0; i < 2; ++i){for (int j = 0; j < 3; ++j){printf("%d ",arr[i][j]);}printf("\n");}return 0;
}

6.1 字符串和字符数组

1.创建字符串：

在定义字符串时，末尾会添加字符串结束标志\0

所以在创建字符串时，要多设置一个数组长度。

    char arr2[12] = "hello world";//创建字符串

 注意：字符串和字符创建的区别

    char ch = 'a';//创建字符

字符串的打印方式：

%s是一个占位符表示输出一个字符串遇到 \0 表示输出停止。

    //定义字符串char arr2[12] = "hello world";printf("%s",arr2);·

2.创建字符数组：

    char arr1[10] = {'h','e','l','l','o','w','o','r','l','d'};//字符数组

字符串数组的打印方式：

    //定义字符串数组char arr1[10] = {'h','e','l','l','o','w','o','r','l','d',};for(char c : arr1){printf("%c ",c);}

3.字符串 和字符数组区别

• c语言中没有字符串这种数据类型，可以通过char的数组来替代。
• 字符串一定是一个char的数组，但char的数组未必是字符串。
• 数字0(和字符‘\0’等价)结尾的char数组就是一个字符串，但如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组，所以字符串是一种特殊的char的数组。

（即：字符数组可以手动添加一个\0,使之转换为字符串。）

案例1：常见字符串的使用

    //静态字符串打印char arr[] = "hello world \n";printf("%s", arr);//不支持动态字符串打印char str[100] = {0};//scanf函数在接收数据时遇到空格或者换行表示结束scanf("%s",str);//hello worldprintf("%s",str);//helloreturn 0;

案例2：判断两个字符串是否相同

    char arr1[] = "hello world";char arr2[] = "hello world";int i =0;while (arr1[i] == arr2[i]){//判断是否到字符串尾if (arr1[i] == '\0'){printf("两个字符串相同。");return 0;}i++;}printf("两个字符串不同！");return 0;

7.函数调用

7.1函数的初体验

1.函数的定义：

用于完成特定任务的程序代码单元。

2.函数的分类：

• 系统函数，即库函数:这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。
• 用户定义函数:用以解决用户的专门需要。

3.函数的五要素：

• 头文件:包含指定的头文件
• 函数名字:函数名字必须和头文件声明的名字一样
• 功能:需要知道此函数的作用后才调用
• 参数:参数类型要匹配
• 返回值:根据需要接收返回值

案例1：调用随机数，编写一个猜数字游戏：

#include <stdio.h>
//导入头文件
#include <stdlib.h>
#include <time.h>int main() {int value, num;//为随机数//创建随机数种子，让当前系统时间作为种子数srand((unsigned int) time(NULL));//生成随机数(1到100)num = rand() % 100 + 1;while (1) {scanf("%d", &value);if (value > num) {printf("猜大了\n");} else if (value < num) {printf("猜小了\n");} else {printf("猜对了\n");break;}}return 0;
}

7.2自定义函数的使用

1.函数的编写格式：

函数名可自定义

 返回类型 函数名（形式参数列表）{

        //代码体

        //返回值

}

2.参数说明：

• 形参：在函数定义时，函数的参数没有具体的赋值，只有一个数据类型，是一个形式上的参数。
• 函数体：{}花括号里的内容。

案例1：写：一个简单的两数之和的函数调用

#include <stdio.h>
int add(int a, int b) {int sum;sum = a + b;return sum;
}int main() {int a =10;int b =5;int sum;sum = add(a,b);printf("%d",sum);//15return 0;
}

3.函数类型

• 有参函数
• 无参函数

4. 返回值

函数的返回值是通过函数中的return语句获得的，return后面的值也可以是一个表达式。

注意: 如果函数返回的类型和return语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错。

5.函数申明

三种方式。

告诉主函数有那些自定义函数

案例1：比较两数大小

#include <stdio.h>//函数声明
extern int max(int a,int b);//1.
int max(int a,int b);//2.
int max(int,int);//3.int main() {int a = 10;int b = 20;int value;value = max(a, b);printf("%d", value);//20return 0;
}
int max(int a, int b) {return a > b ? a : b;
}

案例2：函数版冒泡排序

#include <stdio.h>void BubbleSort(int arr[],int len){int temp;for (int i = 0; i < len-1; i++){for (int j = 0; j < len-i-1; j++) {if (arr[j] > arr[j+1]){temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}
}int main(){int arr[] = {1,34,66,778,9,3,355,878,312,8790,};BubbleSort(arr,10);for (int i = 0; i < 10; ++i) {printf("%d ",arr[i]);}return 0;
}

6.函数的嵌套和递归        

函数的递归调用指的是调用函数本身。

递归时，需要有函数的出口。

案例1：递归使用

#include <stdio.h>void fun(int a){//函数的出口if (a==0){return;}fun(a-1);printf("%d\n",a);
}int main(){int a = 10;fun(a);return 0;
}

7.3局部变量和全局变量

1.局部变量的定义

作用域:在函数内部，从变量定义到函数结束。

在不同函数内的局部变量可以相同。

2.全局变量

在函数外部定义变量成为全局变量。

作用域：是整个项目的所有文件。

如果在其他文件中需要使用全局变量需要做出申明： extern int a;

注意：

• 全局变量可以和局部变量重名。
• 编译器选取变量采用的是就近原则。

8.编译预处理

8.1宏定义和调用

1. 无参数的宏定义（宏常量）

 格式：#define NUM 100

在编译预处理时，在不支持c99标准的编译器上是不支持的，如果想得到了一个编译器常量，那么可以使用宏定义，将宏名替换成字符串的过程称为“宏展开”。宏定义，只在宏定义的文件中起作用。

注意：

• 宏名一般用大写，以便于与变量区别
• 宏定义可以是常数、表达式等
• 宏定义不作语法检查，只有在编译被宏展开后的源程序才会报错
• 宏定义不是C语言，不在行末加分号
• 宏名有效范围为从定义到本源文件结束
• 可以用#undef命令终止宏定义的作用域
• 在宏定义中，可以引用已定义的宏名

案例1：无参宏定义

#include <stdio.h>
//在文件编译时，将NUM替换为100
#define NUM 100
#define SUM NUM+100
int main(){printf("%d\n",NUM);printf("%d\n",SUM);return 0;
}

2.有参宏定义

没有普通函数参数压栈、跳转、返回等的开销，可以调高程序的效率。 

注意：

• 宏的名字中不能有空格，但是在替换的字符串中可以有空格
• 用括号插住每一个参数，并插住宏的整体定义
• 用大写字母表示宏的函数名
• 如果打算宏代替函数来加快程序运行速度。假如在程序中只使用一次宏对程序的运行时间没有太大提高

案例1：有参宏的使用

#include <stdio.h>
//带参数的宏一般带括号
#define SUM(x,y) (x+y)
#define MAX(x,y) ((x>y) ? (x):(y));int main(){int a = 10;int b = 20;int sum,max;sum = SUM(a,b);max =  MAX(a,b);printf("%d\n",sum);printf("%d", max);return 0;
}

8.2 头文件的编译预处理

1.#include  <> 常用于包含库函数的头文件。

2.#include  " " 常用于包含自定义的头文件。

3.理论上#include可以包含任意格式的文件(.c .h等)，但一般用于文件的包含。

9.指针

9.1地址与指针变量

1.内存地址

• 将内存抽象成一个很大的一维字符数组。
• 编码就是对内存的每一个字节分配一个32位或64位的编号(与32位或者64位处理器相关)。
• 这个内存编号我们称之为内存地址。
• 存中的每一个数据都会分配相应的地址
• char:占一个字节分配一个地址。
• int:占四个字节分配四个地址
• float、strtct、函数、数组等

案例1:获取变量的地址

#include <stdio.h>int main(){int a = 10;int b = 20;//占位符 %p 打印数据内存地址 十六进制表示printf("变量a的内存地址： %p\n",&a);//变量a的内存地址： 000000661c3ffc1cprintf("变量b的内存地址： %p\n",&b);//变量b的内存地址： 000000661c3ffc18return 0;
}

2.sizeof函数的计算

sizeof运算符:计算数据类型在内存中占的字节大小

返回值类型为unsigned int 

格式:    sizeof (数据类型)    sizeof(变量名)

案例1：演示sizeof的使用

#include <stdio.h>int main(){int a = 10;char b = 'a';//sizeof计算内存中的字节大小int len1 = sizeof(a);int len2 = sizeof(b);printf("%d\n",len1);//4printf("%d\n",len2);//1return 0;
}

  3.指针

• 内存区的每一个字节都有一个编号，这就是“地址”。
• 如果在程序中定义了一个变量，在对程序进行编译或运行时，系统就会给这个变量分配内存单元，并确定它的内存地址(编号)
• 指针的实质就是内存“地址”。指针就是地址，地址就是指针。
• 指针是内存单元的编号，指针变量是存放地址的变量。
• 通常我们叙述时会把指针变量简称为指针，实际他们含义并不一样。

指针变量的定义格式：int* p = &变量名；

案例1：指针的定义和使用

#include <stdio.h>int main(){int a = 10;//获取变量a的内存地址int* p;//指针变量p和变量a建立关系p = &a;//打印内存地址printf("%p\n",p);//00000074e8bffa74printf("%p\n",&a);//00000074e8bffa74//打印变量的值printf("%d\n",a);//10//*p 对指针变量进行取值操作printf("%d\n",*p);//10return 0;
}

案例2： 可以通过指针变量间接改变变量的值，且在同一操作系统中指针变量所占内存大小都一致。

#include <stdio.h>int main(){int a = 10;int* p = &a;*p = 100;printf("%d\n",a);//100//所有指针变量都是操作系统的位数所占的字节数printf("整型指针在内存中占用的字节： %d\n",sizeof(int*));//整型指针在内存中占用的字节： 8printf("短整型指针在内存中占用的字节： %d\n",sizeof(short*));//8printf("长整型指针在内存中占用的字节： %d\n",sizeof(long*));//8printf("字符指针在内存中占用的字节： %d\n",sizeof(char*));//8printf("单精度浮点数指针在内存中占用的字节： %d\n",sizeof(float*));//8printf("双精度浮点型指针在内存中占用的字节： %d\n",sizeof(double*));//8return 0;}

9.2指针作为函数的参数

 1.函数形参能改变实参的值。

案例1：

#include <stdio.h>void swap(int* a,int* b){int temp = *a;*a = *b;*b = temp;
}int main(){int a = 10;int b = 20;swap(&a,&b);printf("a: %d\n",a);printf("b: %d\n",b);return 0;
}

2. 数组名做函数参数

数组名做函数参数，函数的形参会退化为指针。

数组名本身就是一个地址，指向数组的首地址。

案例1：

#include <stdio.h>void BubbleSort(int* arr,int len){int temp;for (int i = 0; i < len-1; ++i) {for (int j = 0; j < len-i-1; ++j) {if (arr[j] > arr[j+1]){temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}
}int main(){int arr[] = {1,3,54,7,3,2,5,7,1,2,1};//数组名作为函数参数时，会退化为指针BubbleSort(arr,10);for (int i = 0; i < 10; ++i) {printf("%d ",arr[i]);//1 1 2 2 3 3 5 7 7 54}return 0;
}

9.3 指针的运算

1.指针能操作数组

数组名是数组的首地址是一个常量，代表索引为0的地址值。

在将数组赋值给指针变量时 不需要取地址操作本身就是地址。

2.指针的加减法运算

• 指针计算不是简单的整数相加
• 如果是一个int *，+1的结果是增加一个int的大小
• 如果是一个char *，+1的结果是增加一个char大小

案例1：指针的综合练习

#include <stdio.h>int main(){int arr[]  = {1,2,3,4,5,6,7,8,9};//数组名是数组的首地址是一个常量printf("%p\n",&arr[0]);//0000001df93ff770printf("%p\n",arr);//0000001df93ff770//在将数组赋值给指针变量时 不需要取地址操作本身就是地址int* p =arr;printf("%d\n",arr[0]);//1//通过指针间接操作数组printf("%d\n",p[0]);//1//指针+1指向数组的下一个元素;   int* 指针+1   内存地址相当于+sizeof(int);printf("%d\n",*(p+1));//2return 0;
}

指针数组之间的步长，不同数据类型的数字指针相减都为整型 。

案例2：

#include <stdio.h>int main(){int arr[] = {0,1,2,3,4,5,6,7,8};int* p;p = &arr[3];//指针数组之间的步长，不同数据类型的数字指针相减都为整型printf("%lld\n",p-arr);//3return 0;
}

3.指针数组

指针数组，它是数组，数组的每个元素都是指针类型。

 案例1：指针数组的定义和使用

#include <stdio.h>int main() {int a = 10;int b = 10;int c = 10;int *arr[3] = {&a,&b,&c};//指针数组存储指针变量*arr[2] = 123;for (int i = 0; i < 3; ++i) {printf("%d ",*arr[i]);//10 10 123}return 0;
}

扩展：多级指针的定义和使用

#include <stdio.h>int main(){int a = 10;int b = 20;int* q =&b;//使用一级指针接收变量地址int* p = &a;//使用二级指针获取一级指针地址int** p1 = &p;//改变一级指针地址*p1 =q;//二级指针间接改变变量的地址**p1 = 123;printf("%d",*p);//123return 0;
}

10.结构体和共同体

10.1 结构体的定义

1.用typedef说明一个新类型。（起别名）

• 与#define不同，typedef仅限于数据类型，而不是能是表达式或具体的值。
• #define发生在预处理，typedef发生在编译阶段。

2.结构体类型和成员的引用

格式：结构体 结构体名称{

//结构体列表 （可以是不同数据类型 基本类型 构造类型 指针类型）

}

案例1:简单的结构体应用

#include <stdio.h>struct stu{int id;char name[21];char sex;int age;int score;char addr[51];
};int main(){struct stu stu1 = {001,"宋娟",'F',22,100,"四川省泸州市西南医科大学"};//打印结构体信息printf("%d\n",stu1.id);printf("%s\n",stu1.name);printf("%s\n",stu1.sex == 'M' ? "男":"女");printf("%d\n",stu1.age);printf("%s\n",stu1.addr);return 0;
}

10.2 结构体数组

1.定义：

存放结构体的数组

案例1：结构体数组的定义，打印遍历

#include <stdio.h>typedef struct stu student;struct stu{int id;char name[21];char sex;int age;int score;char addr[51];
};int main(){student stu[3] = {{001,"宋娟",'F',22,100,"西南医科大学"},{002,"张三",'M',21,102,"四川大学"},{003,"李四",'F',20,200,"电子科技大学"}};for (int i = 0; i < 3; ++i) {printf("%d\n",stu[i].id);printf("%s\n",stu[i].name);printf("%s\n",stu[i].sex == 'M' ? "男":"女");printf("%d\n",stu[i].age);printf("%s\n",stu[i].addr);}return 0;
}

2.结构体数组排序：

\t占八个占位符。

案例1：使用冒泡排序对结构体中的成绩属性排序

#include <stdio.h>typedef struct stu
{int id;char name[21];int age;char sex;int score;
} student;void BubbleSort(student* stu,int len){student temp;for (int i = 0; i < len-1; ++i) {for (int j = 0; j < len-1-i; ++j) {if (stu[j].score < stu[j+1].score){temp = stu[j];stu[j] = stu[j+1];stu[j+1] = temp;}}}
}int main(){student stu[3];for (int i = 0; i < 3; ++i){//录入学生信息scanf("%d %s %d,%c %d",&stu[i].id,stu[i].name,&stu[i].age,&stu[i].sex,&stu[i].score);}//排序BubbleSort(stu,3);for (int i = 0; i < 3; ++i) {printf("id: %d\t",stu[i].id);printf("姓名： %s\t",stu[i].name);printf("性别： %s\t",stu[i].sex == 'M' ? "男":"女");printf("年龄： %d\t",stu[i].age);printf("分数： %d\n",stu[i].score);}return 0;
}

3.结构体赋值

字符串赋值需要使用strcpy函数。

案例1：两个结构体之间的赋值操作

#include <stdio.h>
#include <string.h>struct stu{char name[21];int age;char sex;
};int main(){struct stu s1;struct stu s2;//字符串赋值需要使用strcpy函数strcpy(s1.name,"玉兔");s1.age = 18;s1.sex = 'M';s2 = s1;printf("姓名： %s\t",s2.name);printf("性别： %s\t",s2.sex == 'M' ? "男":"女");printf("年龄： %d\t",s2.age);
}

 10.3 共同体（联合体）

1.定义：

关键字 union

• 联合union是一个能在同一个存储空间存储不同类型数据的类型;
• 联合体所占的内存长度等于其最长成员的长度倍数，也有叫做共用体;
• 同一内存段可以用来存放几种不同类型的成员，但每一瞬时只有一种起作用;
• 共用体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有的成员的值会被覆盖;
• 共用体变量的地址和它的各成员的地址都是同一地址。

案例1：共同体的定义和使用

#include <stdio.h>//定义共用体
union test{int a;short b;float c;double d;char e;
};
int main(){union test var;var.a = 100;//存放最后一次存放的成员var.c = 3.14;//共同体最后一次赋值的数据是有效的printf("%d\n",var.a);//1078523331printf("%f\n",var.c );//3.140000return 0;
}

10.4 链表

1.定义

• 链表是一种常用的数据结构，它通过指针将一些列数据结点，连接成一个数据链。相对于数组，链表具有更好的动态性（非顺序存储）链式存储。
• 数据域用来存储数据，指针域用于建立与下一个结点的联系。
• 建立链表时无需预先知道数据总量的，可以随机的分配空间，可以高效的在链表中的任意位置实时插入或删除数据。
• 链表的开销，主要是访问顺序性和组织链的空间损失。

2.数组和链表的区别

数组：

• 一次性分配一块连续的存储区域。
• 优点:随机访问元素效率高
• 缺点:需要分醛一块连续的存储区域(很大区域，有可能分配失败）

链表：

• 无需一次性分配一块连续的存储区域，只需分配n块节点存储区域，通过指针建立关系。
• 优点:不需要一块连续的存储区域，删除和插入某个元素效率高
• 缺点:随机访问元素效率低

11.位运算和进制运算

11.1.进制换算

计算机存储数据的方式是以二进制进行存储的。

11.2.位运算

1.按位取反~

• 取反加一

• 最高位是0不需要修改直接转成十进制
• 如果为1需要转换，转换过程为二进制数-1取反

案例1：

#include <stdio.h>int main(){char a = 20;
/* 0001 0100* 1110 1011* 1110 1010* 1001 0101 = -21* */printf("%d\n",~a);//-21return 0;
}

2.位与（and） &

二进制都为1才为1，其他情况都是0。

案例1：

#include <stdio.h>int main(){int a = 18;int b = 52;printf("%d\n",a&b);//16return 0;
}

3.位或（or）|

有一个为1就为1，否则为0。

4.位异或：^

相同为0，不同为1.

5.左移 <<

整体左移，左侧省略，右侧补零。

二进制左移一位乘2

6.右移 >>

整体右移，右侧省略，左侧补零

二进制右移除以2

11.3.位运算的应用

1. 打开位：flag | ~flag = (1111 1111)
2. 关闭位：flag & ~flag = (0000 0000)
3. 转置位： flag ^ 0xff = flag的反码
4. 交换变量的值

案例1：使用异或交换变量

#include <stdio.h>int main(){int a = 10;int b = 20;a = a^b;b = a^b;a = a^b;printf("%d %d",a,b);//20 10return 0;
}

12.文件操作

12.1文件类型指针

1.定义

在C语言中用一个指针变量指向一个文件，这个指针称为文件指针。

c语言中有三个特殊的文件指针由系统默认打开，用户无需定义即可直接使用:

• stdin:标准输入，默认为当前终端（键盘），我们使用的 scanf、getchar函数默认从此终端获得数据。
• stdout:标准输出，默认为当前终端（屏幕），我们使用的printf、puts函数默认输出信息到此终端。
• stderr:标准出错，默认为当前终端（屏幕），我们使用的perror函数默认输出信息到此终端。

12.2文件的打开与关闭

使用fopen函数，传入两个参数（"指定路径",操作（打开方式））

返回值：成功返回文件指针，失败返回NULL

案例1：

#include <stdio.h>
int main(){//文件指针FILE* fp;//fopen(文件路径,打开方式）打开文件//打开方式  r只读方式打开u写方式打开a以追加方式打开fp = fopen("G:/a.txt","r");//对打开的文件进行判断if (fp == NULL){printf("文件打开失败");return -1;}printf("文件打开成功\n%p\n",fp);//文件打开成功//00007ffcea4dfa90//关闭文件fclose(fp);return 0;
}

12.3.文件的读写

使用fgetc函数读取字符

案例1：

#include <stdio.h>int main() {FILE *fp;char ch;fp = fopen("G:/a.txt", "r");//对打开的文件进行判断if (fp == NULL) {printf("文件打开失败");return -1;}while ((ch = fgetc(fp)) != EOF) {printf("%c ",ch);//h e l l o}fclose(fp);return 0;
}

使用fputc函数写入字符

案例2：

#include <stdio.h>int main(){FILE *fp;char ch = 'A';fp = fopen("G:/b.txt", "w");//对打开的文件进行判断if (fp == NULL) {printf("文件写入失败");return -1;}//调用写入函数fputc(ch,fp);printf("文件写入成功");fclose(fp);return 0;
}