嵌入式 on ynhugo

01test_01day

Thu, 16 Feb 2023 08:03:05 +0800

01test_01day

====================================
2022-6-30
====================================

一.课程介绍

 物联网嵌入式方向
 拉齐基础
 Linux基础		(终端的使用/命令/编译器/编辑器/软件安装/服务搭建)
 Linux下的C语言	
 数据结构			(链表/栈式/队列/树/哈希表)
 ----------------------------------------------------------
 Linux下的高编		(文件IO/信号/进程/线程/通信/网络socket)
 QT(图形化界面开发)	
 ----------------------------------------------------------
 智能终端设备		(单片机<裸板驱动开发>)
 STM32F103RBT6
 边缘计算设备		(高端ARM开发板)

二.安装开发环境

 1.双系统
 1)系统盘
 软碟通 + 镜像
 2)需要在电脑硬盘上预留100G空间
 2.安装虚拟机
 1)虚拟机软件
 VMWare
 2)镜像
 网易镜像 清华镜像
 3.分区
 注意:一定要手动分区
 8192Mb			交换分区(虚拟内存)
 把剩余空间的一半	/home
 把剩余空间		/

三.介绍终端

 在Linux下一切皆文件

 终端上的命令可以代替鼠标的所有操作
 1.打开终端的方式
 1)鼠标右键->打开终端
 2)显示应用程序->全部->打开终端
 3)快捷键
 ctrl + alt + t
 2.设置终端
 1)修改终端字体字号
 2)修改终端配色方案
 3.终端提示符
 root@zack-machine:/home/zack#
 @之前的位置		当前登陆终端的用户
 @				分割符号
 @之后 :之前		主机名
 :				分割符号
 :之后 #或$之前	当前终端所在目录的路径
 如果出现的是~指的是家目录
 每个用户都会有自己的家目录
 用户			家目录的路径
 root		/root		//超级用户
 zack		/home/zack
 tom			/home/tom
 jerry		/home/jerry
 root是超级用户所以它的家目录是/root
 其他用户属于普通用户所以家目录是/home/和用户名同名的目录	
 # 或者 $			用来提示用户级别
 #			代表当前登陆终端的用户是超级用户
 $			代表当前登陆终端的用户是普通用户
==================================
关键词
1.根目录
 是Linux最根本的路径
2.家目录
 取决于用户
 root用户的家目录		/root
 普通用户的家目录		/home/和用户名同名的目录
3.桌面
 桌面在家目录中
 root用户的桌面		/root/桌面
 普通用户的桌面			/home/和用户名同名的目录/桌面
 
 cd /桌面				ERROR
 cd /home/桌面		ERROR
 cd /home/zack/桌面	Bingo
 cd ~/桌面			Bingo

4.绝对路径和相对路径
 绝对路径 : 从根目录出发,一层一层递进
 /home/zack/桌面
 如果显示出来的路径最左边是 / 那么这个路径就是绝对路径
 相对路径 : 除了绝对路径都是相对路径
 ~/桌面
 如果显示出来的路径最左边不是 / 那么这个路径就是相对路径
 在显示的路径中只有最左边出现的是 / 才是根目录的意思
 之后再出现的/都是指的什么什么目录之下
==================================


==================================
练习
1.zack@abc-test:~$
 zack		用户名
 abc-test	主机名
 ~			家目录(/home/zack)
 $			普通用户
2.abc@abc-test:~$
 /home/abc
3.tom@abc-test:/home/zack#
4.jerry@abc-test:/$
==================================

 4.终端执行的简单命令
 终端提示符 $ 命令
 终端提示符 $ 命令 选项
 终端提示符 $ 命令 参数
 终端提示符 $ 命令 选项 参数
 cd		(改变目录/切换目录)
 1) cd			回到家目录
 2) cd 目录名		切换到该目录中(已有的目录名)
 3) cd 路径		可以是绝对的也可以是相对的,但必须是正确的路径
 4) cd ..		切换到上一级目录
 ls		(显示文件名)
 1) ls			显示当前目录下的文件名
 2) ls 文件名		可以显示文件名
 3) ls 目录名		可以显示该目录下的文件名
 4) ls -a		可以显示所有文件包括隐藏文件
 (在Linux中以.开头的文件都是隐藏文件)
 .			表示的是当前目录
 ..			表示的是上一级目录
 5) ls -l		以长格式显示文件内容
 -rwxrwxr-x 1 zack zack 8352 6月 22 20:20 a.out
 drwxrwxr-x 4 zack zack 4096 12月 27 2021 east
part.1		文件的类型
 在Linux下一共有7种文件类型
 -		普通文件
 d		目录文件
 c		字符设备文件
 b		块设备文件
 s		网络套接字文件
 p		管道文件
 l		链接文件(符号链接文件)
part.2		文件的权限
 普通的权限
 rwx				rwx				r-x
 文件所有者权限		文件所属组权限		其他用户权限
 7				7				5
 r	可读			4
 w	可写			2
 x	可执行		1
 -	该处无权限	0
part.3		文件链接数

part.4		文件所属者

part.5		文件所属组

part.6		文件字节数

part.7		文件最后修改时间

part.8		文件名

 pwd			显示当前所在目录的绝对路径
 
 touch		(创建普通文件)
 1) touch 文件名			创建普通文件
 2) touch 已有的文件名		会修改文件最后修改时间
 3) touch 文件名 文件名		创建多个文件
 mkdir		(创建目录文件)
 1) mkdir 目录名			创建目录文件
 2) mkdir 已有的目录名		报错
 3) mkdir 目录名 目录名		创建多个目录
 rm			(删除文件)
 1) rm 普通文件的文件名		删除普通文件
 2) rm -r 目录文件名		删除目录文件(-r递归的操作)
 (-f强制的操作)
 3) rm *.c				删除所有以.c结尾的文件
 注意 : rm -rf *
 cp			(拷贝文件)
 1) cp 源文件文件名 目标文件文件名
 2) cp -r 源目录名 目标目录名	(-r是递归的操作)
 mv			(剪切文件/移动文件/改名字)
 1) mv 源文件文件名 目标文件文件名
 注意 : 剪切目录时不需要加 -r 的操作
 cat			(查看普通文件的文件内容)
 tar			(压缩和解压缩的命令)
 压缩
 tar cvf 最终生成的压缩包的名字.tar 压缩的文件
 解压缩
 tar xvf tar包的名字
 tar xvf tar包的名字 -C 目录
 (默认会解压缩到当前目录下)
 -C	是用来指定目录的
=====================================

作业

1.把今天讲过的内容复习一遍(千万不要小看复习的力量)
2.重装虚拟操作系统
3.查找如何查看文件大小
=====================================
小操作
1.打开终端 ctrl + alt + t
2.打开终端标签页 ctrl + shift + t
3.切换终端标签页 ctrl + pgup/pgdn
4.临时放大终端字体 ctrl + shift + +
5.临时缩小终端字体 ctrl + -
6.终端清屏 ctrl + l / clear
7.查看历史命令 history
8.终端复制 鼠标选中就是复制
9.终端粘贴 鼠标中轴按键
10.终端中多敲tab,可以补齐
=====================================

01test_02day

Thu, 16 Feb 2023 08:03:05 +0800

01test_02day

==================================
2022-7-1
==================================

一.温故知新

 1.演示了一遍安装虚拟操作系统的步骤
 1)虚拟机软件->VMWare
 2)Ubuntu的镜像->网易镜像 清华镜像
 3)需要手动分区
 4)安装软件之前需要切换软件源
 2.终端
 1)修改了终端的字体字号
 2)终端的配色方案
 3)分析终端提示符
 4)命令
 cd
 ls
 pwd
 touch
 mkdir
 rm
 cp
 mv
 cat
 tar

二.编辑器与编译器

 编辑器是用来编写程序的
 编译器是用来编译程序的
 在Linux环境中编辑器有很多种 : gedit vi vim emacs
 在Linux环境中编译器有很多种 : gcc cc arm-linux-gcc
 主要讲 vim 和 gcc 的使用
 1.编辑器vim的使用
 vim之所以被称之为强大的编辑器是因为本身支持很多的模式
 命令模式 命令行模式(底行模式) 编辑模式(插入模式) 可视 可视块 可视行
 注意 : 不要使用vim打开目录文件
 注意 : 用vim编写完成的文件内容要用正常的保存退出方式,不要直接关闭终端
 否则会生成交换文件(交换文件是隐藏文件)
 vim hello.c
 |
 按iIoOaA			V		按:
 编辑模式<----------命令模式---------->命令行模式
 --------->		<---------	
 按esc					按esc或者删掉:

 命令行模式的操作
 w		保存
 q		退出
 wq		保存并且退出

 大家在终端中,执行 vim ~/.vimrc
 先进入到编辑模式
 set ai
 set si
 set ts=4
 set sw=4
 set nu
 保存退出

 2.编译器gcc
 注意 : gcc编译器不检查段错误(操作内存不当引起的)
 gcc hello.c
 1)编译之后终端什么提示都没有,代表程序没有语法错误,会生成可执行文件
 2)编译之后终端报出警告,代表程序有些问题,但不是致命的,会生成可执行文件
 3)编译之后终端报出错误,代表程序100%有问题,并且是致命的,
 不会生成可执行文件
 默认的可执行文件的名字是a.out
 
 指定可执行文件的名字
 gcc -o 可执行文件名 .c文件

 要求大家在编译程序时加入-Wall选项,可以把所有警告列出
 gcc -Wall hello.c

 3.执行可执行文件
 ./a.out

三.man手册(帮助手册)

 有困难,找男人
 man 你要查找的东西
 在man手册界面中键盘上下按键可以翻阅
 按 q 键可以退出man手册

=====================================
作业
1.修改自己的vim配置文件
=====================================

#include <stdio.h>
/*
#include
面试题
1.在C语言中以#开头的内容都是预处理
2.从.c文件编译成可执行程序,需要经历哪些阶段?
 预处理->编译->汇编->链接
3.在C语言中预处理都包含哪些操作?
 文件包含 宏定义 条件编译
4.在包含头文件时可以使用双引号或者尖括号,有啥区别?
 尖括号 : 默认会从指定的目录(/usr/include)中查找头文件,
 如果找不到会报错
 双引号 : 默认会从当前目录中查找头文件,
 如果找不到再从指定目录中查找头文件,
 如果再找不到报错
stdio.h		标准输入输出的头文件
*/
int main(void)
/*
 main函数(也叫做主函数)
 main函数是程序的入口
 当执行可执行文件时,会从main函数进入,按照从上往下的顺序
 逐行逐行执行代码,最后从main函数退出
*/
{
 printf("Hello World!");
 /*
 printf是一个函数(功能)
 是用来打印输出的(可以把双引号引起来的内容打印到终端中)
 由于printf函数是别人实现的功能,所以需要包含人家的头文件
 */
}

/*
1.在C语言中有字符串,有没有字符串类型?
 没有字符串类型
printf("Hello World!");
 在C语言中双引号引起来的内容叫做字符串
 字符串都是由一个一个单一的字符组成的
 在C语言中单引号引起来的内容叫做字符
 字符串最后都有一个结束标志'\0'(尾0)
例子:
 "a" 和 'a'
 不一样,"a"是字符串,'a'是字符
 "a"是由'a' + '\0'组成
======================================	
 "0" 和 '0' 和 0
 不一样."0"是字符串,'0'是字符,0是整数
 "0"是由'0' + '\0'组成
练习:
在终端中打印出一个 %
*/

1
2
3
4
5
6
7
8


#include <stdio.h>

int main(void)
{
	printf("%");
	//printf("Hello World!");
	//printf('Hello World!');
}

/*
printf打印输出的特殊内容->转义字符
转义字符也是字符
 转义字符是由一个 \ + 某一个东西组成的
 转义字符除了有ASCII值以外还有另外的一层含义
ASCII(描述的就是字符和数字的对应关系)
常用的ASCII表一共有128个字符(对应数字0 - 127)
记住特殊的ASCII值
 字符	ASCII值
 '\0'	0
 '\n'	10
 '0'		48
 'A'		65
 'a'		97
转义字符
 字符	ASCII值		含义
 '\0'	0			字符串的结束标志
 '\n'	10			换行符
 会把光标换到下一行行首的位置
 '\r'	13			回车符
 会让光标回到当前行行首的位置
 '\t'	9			水平制表符
 会补一个tab
 '\v'	11			垂直制表符
 光标会换到下一行当前列的位置
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>

int main(void)
{
	printf("123\v456\v789\v");
	printf("123\t456\t789\t");
	//printf("sdlpmdaspmdpasmdpasmoHello World!\r");
	//printf("Hello World!\n");
	//printf("Hello\0World!");
	//printf("%");
	//printf("Hello World!");
	//printf('Hello World!');
}

/*
printf打印输出的特殊内容->标准化输出格式
 标准化输出格式只是一种输出格式,并不是字符
 是由一个 % + 某一个东西组成的
 %叫做占位符
 %d		十进制整数输出
 %o		八进制输出
 %x		十六进制输出
 %f		小数输出(默认打印输出小数点后六位)
 %.2f	默认输出小数点后2位
 %c		单一字符输出
 %s		字符串输出
 %p		输出地址
 %%		打印一个百分号
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	//printf("%d", 9527);
	//printf("%x\n", 100);
	//printf("%o\n", 100);
	//printf("%f\n", 3.14);
	//printf("%.2f\n", 3.14);
	//printf("%c\n", '%');
	//printf("%%\n");
	//printf("%s\n", "Hello");
	//printf("%f\n", 100);
	//printf("%d\n", 3.14);
	printf("%c-%d\n", 100, 'A');
}

01test_03day

Thu, 16 Feb 2023 08:03:05 +0800

01test_03day

===================================
2022-7-4
===================================

一.温故知新

 嵌入式方向
 需要使用Linux环境(红帽 centos Ubuntu SUSE ...)
 虚拟机安装虚拟操作系统
 熟悉环境->终端的熟悉
 打开终端的方式
 终端提示符
 常用命令
 cd ls pwd touch mkdir rm cp mv cat tar
 编辑器和编译器
 vim gcc
 ./a.out
 #include <stdio.h>
1.在C语言中以#开头的内容是预处理的操作
2.预处理都包含哪些操作
 条件编译 宏定义 文件包含
3.把.c文件编译成可执行文件,需要包含哪些操作?
 预处理->编译->汇编->链接
4.头文件包含可以使用尖括号或者双引号,有啥区别?


 int main(void)
 {
 printf("Hello World!");
 在C语言中双引号引起来的内容是字符串
 字符串是由一个一个单一的字符组成,最后有一个结束标志'\0'
 ASCII
 '\0'	0
 '\n'	10
 '0'		48
 'A'		65
 'a'		97
 标准化输出格式
 %d %o %x %f %c %s %p %%
 }
 printf("%d\n", 3.14);
 printf("%f\n", 100);
 
 printf("%.2f\n", 3.14);

 printf("3.14\n");

运算符

算术运算符	+ - * / %
关系运算符	> < == >= <= !=
逻辑运算符	&& || !
赋值运算符	= += -= *= /= %= <<= >>= &= ...
位运算符		<< >> & | ~ ^
条件运算符	? :
下标运算符	[]
分量运算符	. ->
指针运算符	& *
强制类型转换	(数据类型)
求字节大小	sizeof()
自增自减运算符	++ --

变量

1.变量的含义
 变量就是用来存储数据的
 (数据会存在内存中<以二进制补码的形式存储>)
2.变量的定义
 数据类型 变量名	;
 char		c	;
 int			i	;
 float		f	;
 1)基本的数据类型
 整型	有符号/无符号	short int long
 实型	有符号			float(单精度) double(双精度)
 字符型	有符号/无符号	char
 2)通过sizeof测试数据类型占用空间的大小
 注意 : sizeof不是函数,是一个运算符
 sizeof运算的结果是以字节为单位
 1个字节(byte) = 8个位(bit)
 1个字 = 2/4个字节
 注意使用sizeof运算符测试出来的结果并不是唯一的
 和硬件以及操作系统的位数有关(和32bit或者64bit有关)
 3)数据类型的大小以及范围在头文件中有记录
 /usr/include/limits.h
 4)变量命名的要求
 1>变量名是以数字 字母 下划线组成,但是不能以数字开头
 2>变量名区分大小写
 int a, A;//a和A是两个变量
 3>变量名不能和C语言的关键字重复
 4>变量名要做到见名生义
3.变量的初始化
 数据类型	变量名	=	数值	;
 char		c		=	'A'		;
 int			i		=	9527	;
 float		f		=	3.14	;
4.变量的定义和变量的初始化的区别
 变量的定义 : 只是给变量分配相应的存储单元,
 变量的初始值是垃圾值
 变量的初始化 : 除了给变量分配相应的存储单元,
 并且会给变量赋初始值
注意 : 以后写程序定义的变量一定要有初始化
5.变量的使用规则
 1)变量一定是先定义再使用
 2)便于编译时检查错误,不同类型的变量有不同的运算要求
 3)当变量在定义时,将来在内存中占用的大小就已经决定了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>

int main(void)
{//char short int long float double
	printf("sizeof(char) = %ld\n", sizeof(char));
	printf("sizeof(short) = %ld\n", sizeof(short));
	printf("sizeof(int) = %ld\n", sizeof(int));
	printf("sizeof(long) = %ld\n", sizeof(long));
	printf("sizeof(float) = %ld\n", sizeof(float));
	printf("sizeof(double) = %ld\n", sizeof(double));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>

int main(void)
{
	float f = 3.14;

	printf("f = %d\n", f);

	//int i = 100;

	//printf("i = %f\n", i);

	return 0;
}

scanf函数的使用

 函数功能 : 用来进行录入的函数(可以接收键盘录入的数值)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>

int main(void)
{
	int a = 9527;

	printf("a = %d\n", a);
//需求:定义三个变量,通过scanf函数录入年月日
	scanf("%d", a);
	//scanf("%d\n", &a);
	//printf("请输入a变量的值:");
	//scanf("%d", &a);
/*
注意:
	1.在scanf函数的双引号中只写标准化输出格式即可
	2.在scanf函数的双引号中千万不要加换行符
	3.在scanf函数的双引号之后,写的参数必须是地址
*/
	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <stdio.h>

int main(void)
{
	int year = 0, month = 0, day = 0;

	printf("请输入年-月-日 : ");
	scanf("%d,%d,%d", &year, &month, &day);
	printf("%d年%d月%d日!\n", year, month, day);

	return 0;
}

算术运算符

 +		加法
 -		减法
 *		乘法
 /		除法(取商)
 %		除法(取余)
注意 : 
除法运算中除数不能为0
 a ➗ b = c ...... d
a	被除数
b	除数
c	商
d	余
-------------------------
如果a < b, c = 0, d = a
面试题
1.两个变量值的交换
 1)可以定义第三个中间变量,通过三个变量和两个数值可以交换
 2)可以通过算术运算符完成交换
2.
 atoi()
 "123"->123
 itoa()
 9527->"9527"
 1->'1'
 1 + '0' = '1'
 char arr[5] = {0};
 arr[0] = 9527 / 1000 = 9 + '0' = '9'
 arr[1] = 9527 / 100 % 10 = 5 + '0' = '5'
 arr[2] = 9527 / 10 % 10 = 2 + '0' = '2'
 arr[3] = 9527 % 10 = 7 + '0' = '7'
 arr[4] = '\0';

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>

int main(void)
{
	int a = 13, b = 7;
	int c = 0;

	printf("a + b = %d\n", a + b);
	printf("a - b = %d\n", a - b);
	printf("a * b = %d\n", a * b);
	printf("a / b = %d\n", a / b);
	printf("a %% b = %d\n", a % b);
	
	/*
	printf("c = %d\n", c);
	c = a + b;
	printf("c = %d\n", c);
	c = a - b;
	printf("c = %d\n", c);
	c = a * b;
	printf("c = %d\n", c);
	c = a / b;
	printf("c = %d\n", c);
	c = a % b;
	printf("c = %d\n", c);
*/
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0;
	int tmp = 0;

	scanf("%d-%d", &a, &b);//13 - 7 

	printf("a = %d b = %d\n", a, b);

	a = a + b;// a = 13 + 7 = 20
	b = a - b;// b = 20 - 7 = 13
	a = a - b;// a = 20 - 13 = 7

/*	
	tmp = a;//把变量a的值赋值给tmp变量
	a = b;//把变量b的值赋值给a变量
	b = tmp;//把变量tmpb的值赋值给b变量
*/
	printf("a = %d b = %d\n", a, b);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 0;

	scanf("%d", &i);//9527
	//录入一个4位的正整数

	printf("千位 : %d\n", i / 1000);//9
	printf("百位 : %d\n", i / 100 % 10);//5
	printf("十位 : %d\n", i / 10 % 10);//2
	printf("个位 : %d\n", i % 10);//7

	return 0;
}

关系运算符

 >		是否大于
 <		是否小于
 ==		是否相等(一个等号是赋值运算符)
 >=		是否大于等于
 <=		是否小于等于
 !=		是否不等于
注意:
一个表达式经过关系运算符的运算,最终会生成真假值
 0为假,非0为真(默认的真值是1)
一般关系运算符的运算会配合分支语句和循环语句一起使用
 分支语句和循环语句就是用运算之后的真假值做操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int main(void)
{
	int a = 13, b = 7;

	printf("a > b = %d\n", a > b);
	printf("a < b = %d\n", a < b);
	printf("a == b = %d\n", a == b);
	printf("a >= b = %d\n", a >= b);
	printf("a <= b = %d\n", a <= b);
	printf("a != b = %d\n", a != b);

	return 0;
}

逻辑运算符

 &&		逻辑与(全真才为真,有假就是假)
 表达式1 && 表达式2
 表达式1		表达式2		整体
 真			真			真
 真			假			假
 假			真			假
 假			假			假
 ||		逻辑或(全假才为假,有真就是真)
 表达式1 || 表达式2
 表达式1		表达式2		整体
 真			真			真
 真			假			真
 假			真			真
 假			假			假
 !		逻辑非(真假互换)
 !(表达式)
 表达式		整体
 真			假
 假			真
====================================
 表达式1 && 表达式2
 如果表达式1为真,会执行表达式2的内容
 如果表达式1为假,不会执行表达式2的内容

 表达式1 || 表达式2
 如果表达式1为真,不会执行表达式2的内容
 如果表达式1为假,会执行表达式2的内容
====================================
已知有三个变量a b c存储的是非负的正整数
1.列出满足可以构成三角形的条件

2.已知a b c满足构成三角形的条件,列出满足构成直角三角形条件

3.已知a b c满足构成三角形的条件,列出满足构成等腰三角形条件

4.已知a b c满足构成三角形的条件,列出满足构成等边三角形条件
====================================

1
2
3
4
5
6


#include <stdio.h>

int main(void)
{
	return 0;
}

01test_04day

Thu, 16 Feb 2023 08:03:05 +0800

01test_04day

===================================
2022-7-5
===================================

一.温故知新

 变量
 1.变量的含义
 变量就是用来存储数据
 2.变量的定义
 数据类型	变量名	;
 基本数据类型
 整型		有符号/无符号	short int long
 实型		有符号		float double
 字符型	有符号/无符号	char
 sizeof是一个运算符,不是函数
 sizeof(数据类型/变量名),以字节为单位
 /usr/include/limits.h
 变量名
 
 3.变量的初始化
 数据类型	变量名	=	数值	;
 int		a		=	100	;
 float	f		=	3.14;

 4.变量的使用规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


-----------------------------
scanf
scanf("", );
-----------------------------
运算符
算术运算符	+ - * / %(取余 取模)
关系运算符	> < == >= <= !=
逻辑运算符	&& || !
a b c
a + b > c && a + c > b && b + c > a
a * a + b * b == c * c || a * a + c * c == b * b ||
b * b + c * c == a * a
a == b || a == c || b == c
a == b && a == c
赋值运算符	= += -= *= /= ...

作业
1.把今天讲过的内容完整的复习一遍
2.使用条件运算符和分支语句各解决一遍求闰年问题
3.输入三个值判断这三个值是否构成三角形
(是否是直角 等腰 等边 普通 不能)	
4.输入三个整数x,y,z,请把这三个数由从小到大输出
5.输入相应的字符打印相应的语句(默认不区分大小写)
输入a,打印	钟薛高18块钱
输入b,打印	梦龙8块钱
输入c,打印	老冰棒1块钱
输入d,打印	雪莲0.5块钱
================================
录入成绩
0 ~ 59	打印	不及格
60 ~ 69 打印 及格
70 ~ 79 打印 中
80 ~ 89 打印 良
90 ~ 100 打印 优秀

赋值运算符

 = += -= *= /= %= <<= >>= &= |=
 int a;
 a = 9527;
先把赋值运算符右边的项进行计算,再赋值给赋值运算符左边的项
 左边的项也叫做(左值)
具有存储能力的都可以做左值(变量\指针\数组成员...)
常量(整数\字符\字符串...)不能做左值

设x为int型变量,则执行以下语句后
x = 10;
x += x -= x - x;
x = x + (x -= x - x)
x = x + (x = x - (x - x))
x的值为？20

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>

int main(void)
{
	int a = 100;

	printf("a = %d\n", a);
	
	a += 2;// => 等价于 a = a + 2
	
	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>

int main(void)
{
	int a = 100;

	printf("a = %d\n", a);
	
	a *= 2 + 3;
	/*
		a = a * (2 + 3);
	*/
	
	printf("a = %d\n", a);

	return 0;
}

条件运算符(? :)

 也是C语言中唯一的一个三目运算符
 part.1 ? part.2 : part.3;
 如果part.1为真,则会执行part.2的内容,略过part.3
 如果part.1为假,则会执行part.3的内容,略过part.2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0;
	int max = 0;

	scanf("%d-%d", &a, &b);

	max = a > b ? a : b;

	printf("max = %d\n", max);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0;
	int max = 0;

	scanf("%d-%d", &a, &b);

	max = a>b?printf("a = %d\n", a):printf("b = %d\n", b);
/*
如果a > b为真, max = printf("a = %d\n", a);
如果a > b为假, max = printf("b = %d\n", b);
注意:max获取的并不是变量的值,而是printf函数的返回值

max = a > b ? a : b;
如果a > b为真, max = a;
如果a > b为假, max = b;
*/
	printf("max = %d\n", max);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0, c = 0;
	int max = 0, max1 = 0;

	scanf("%d-%d-%d", &a, &b, &c);
	//max = a > b ? a : b;
	//使用条件运算符求三个变量中的最大值
	
	max = (a > b) ? (a>c?a:c) : (b>c?b:c);

/*
	max1 = a > b ? a : b;
	max = max1 > c ? max1 : c;
	
	max = a > b ? a : b;
	max = max > c ? max : c;
*/

	printf("max = %d\n", max);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int year = 0;

	scanf("%d", &year);
//通过条件运算符判断year是闰年还是平年
/*
	能被4整除但是不能被100整除或者能被400整除
	就是闰年
	2022 2020 2000 1900(平年)
*/

	return 0;
}

强制类型转换运算符

 (数据类型)
 可以把目标的数据类型临时的转换成你想转换的数据类型
注意 : 强制类型转换运算符并不会修改本身的数据类型
注意 : 尤其是以后转换指针时使用比较多

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <stdio.h>

int main(void)
{
	float f = 3.14;

	printf("f = %d\n", (int)f);

	return 0;
}

自增自减运算符

 ++ --
无论是自增还是自减,所改变的数量级都是1
注意 : 
 如果自增的运算自己为独立的一条语句,
 那么a++和++a没有任何区别,都是自增1
 
 如果自增的运算和别的语句一起来使用,那么就有区别了
 a++ : 先使用a的值做操作,再自增
 ++a : 先自增,再使用a的值做操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int a = 0;

	printf("a++ = %d\n", a++);
	printf("做完a++之后a的值是%d\n", a);

	a = 0;

	printf("++a = %d\n", ++a);
	printf("做完++a之后a的值是%d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0;
	
	//a++ && b++ ? printf("Hello\n") : printf("World\n");
	//a++ && ++b ? printf("Hello\n") : printf("World\n");
	//++a && ++b ? printf("Hello\n") : printf("World\n");
	++a || b++ ? printf("Hello\n") : printf("World\n");
	
	printf("a = %d b = %d\n", a, b);

	return 0;
}

分支语句->if

1.if是C语言的关键字
2.if的结构
语句1
if(条件)
{
 语句2
}
语句3
语句1->条件的判断(真)->语句2->语句3->结束
 |
 (假)->语句3->结束
3.if...else的结构
语句1
if(条件)
{
 语句2
}
else
{
 语句3
}
语句4
语句1->条件的判断(真)->语句2->语句4->结束
 |
 (假)->语句3->语句4->结束
4.多分支结构
语句1
if(条件1)
{
 语句2
}
else if(条件2)
{
 语句3
}
else if(条件3)
{
 语句4
}
else
{	
 语句5
}
语句6
语句1->条件1的判断(真)->语句2->语句6->结束
 |
 (假)->条件2的判断(真)->语句3->语句6->结束
 |
 (假)->条件3的判断(真)->语句4->语句6->结束
 |
 (假)->语句5->语句6->结束
注意
1.if else都是C语言的关键字
2.if关键字之后必须要加小括号,小括号内部必须要写条件,不能空者
3.在if(条件)之后可以加分号
 if(0);
 {
 printf("Hello World!\n");
 }
 等价于
 if(0)
 {
 ;
 }
 {
 printf("Hello World!\n");
 }
4.在if(条件)之下可以不写大括号
(以后写代码即使if的语句只有一条,也要加上大括号)
 if(0)
 printf("Hello\n");
 printf("World!\n");
 等价于
 if(0)
 {
 printf("Hello\n");
 }
 printf("World!\n");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 0;

	scanf("%d", &i);

	if(i < 100)
	{

		printf("Hello World!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 0;

	scanf("%d", &i);

	//if(i % 2 == 0)//!(i % 2)
	if(!(i % 2))
	{
		printf("%d这个值是偶数!\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>

int main(void)
{
	int i = 0;

	scanf("%d", &i);

	//if(i % 2 == 0)//!(i % 2)
	if(!(i % 2))
	{
		printf("%d这个值是偶数!\n", i);
	}
	else
	{
		printf("%d这个值是奇数!\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>

int main(void)
{
	int year = 0;

	scanf("%d", &year);

	if((year%4==0 && year%100!=0) || (year%400==0))
		//2022 2020 2000 1900
	{
		printf("%d这一年是闰年!\n", year);
	}
	else
	{
		printf("%d这一年是平年!\n", year);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);

	if(a > b)
	{
		printf("Hello World!\n");
	}
	else if(a < b)
	{
		printf("Hello Beijing!\n");
	}
	else
	{
		printf("Hello Changping!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <stdio.h>

int main(void)
{
	if(0)
		printf("Hello\n");
		printf("World!\n");

	return 0;
}

练习
键入一个整数x,
如果小于3则执行x+3操作,
如果大于等于3则执行3*x+9
如果大于9则执行9*x-10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <stdio.h>

int main(void)
{
	int x = 0;

	scanf("%d", &x);
	if(x < 3)
	{
		printf("x + 3 = %d\n", x + 3);
	}
	else if(x > 9)
	{
		printf("9 * x - 10 = %d\n", 9 * x - 10);
	}
	else
	{
		printf("3 * x + 9 = %d\n", 3 * x + 9);
	}
/*
	if(x < 3)
	{
		printf("x + 3 = %d\n", x + 3);
	}
	else if(x >= 3 && x <= 9)
	{
		printf("3 * x + 9 = %d\n", 3 * x + 9);
	}
	else
	{
		printf("9 * x - 10 = %d\n", 9 * x - 10);
	}
*/
	return 0;
}

输入三个值判断这三个值是否构成三角形
(是否是直角 等腰 等边 普通 不能)

1
2
3
4
5
6
7


#include <stdio.h>

int main(void)
{

	return 0;
}

01test_05day

Thu, 16 Feb 2023 08:03:05 +0800

01test_05day

==================================
2022-7-6
==================================

一.温故知新

 赋值运算符	= += -= *= /= ...
 a += 1 => a = a + (1)
 条件运算符	? :
 part.1 ? part.2 : part.3;
 强制类型转换	(数据类型)
 求字节大小	sizeof
 自增自减		++ --
 变量名++;
 ++变量名;
 -----------------------
 分支结构
 if else
 if(条件)
 {
 语句
 }
 else if(条件)
 {
 语句
 }
 else if(条件)
 {
 语句
 }

=======================================
homework
1.
(1)打印4 * 5 的 *
例:
*****
*****
*****
*****
(2).打印i * j 的 * (i j 键盘接收)
 例:i = 4, j = 5
 //4-5 5-6
 *****
 *****
 *****
 *****
(3).打印i * j 的 * 边框(i j 键盘接收)
 例: i = 4, j = 5
 *****
 * *
 * *
 *****
2.打印99乘法表
 1 * 1 = 1
 1 * 2 = 2 2 * 2 = 4
 *
 **
 ***
 ****

3.计算1+2+3+4+5+...+n, n是从键盘输入的自然数

// 穷举
4.要将5张100元的大钞票,换成等值的50 20 10 5小钞票,每种面值至少一张,要多少张,有多少种换法

5.有1、2、3、4 4个数字,能组成多少个互不相同且无重复的三位数呢

6.有这样的一个等式,xyz+yzz=532,编程求x y z的值

7.计算1^2 + 2^2 + 3^2 + ... +10^2的结果
(1的平方 + 2的平方)

8.输入20个人的成绩,输出不及格的人数(0<=score<60 为不及格)

9.随机产生100个三位随机数,找出其中能被 3 5 7整除的数

10.打印0~100以内所有的质数
(只能被1 和 本身整除的数)

11.猜数游戏(随机产生一个1000以内的数,去猜,
 如果大了打印猜的大了,
 如果小了打印猜的小了,
 如果正确打印对的
 直到猜对了再结束,每次打印必须打印出猜的次数)

12. 把11修改成,程序开始时,先输入需要猜的数的范围n
例:(想要猜数的范围是(0~10000) 那么变量n接收键盘上10000
 范围都是从0开始)

13.
----------------------------
a + b - 9 = 4
+	-	-	
c -	d * e = 4
/	*	-
f + g - h = 4
=	=	=
4	4	4
求a b c d e f g h (0 ～ 12范围内)//除法指的是整除 c % f == 0
只有一种答案
14.求1+12+123+...前N项之和,其中N是从键盘输入的数(N取值范围（1~9）)
 n = 5;
 sum = 1 + 12 + 123 + 1234 + 12345;

15.爱因斯坦出了一道这样的数学题,有一条长阶梯,若每步跨2阶,则最后剩1阶,若每步跨3阶,则最后省2阶,若每步跨5阶,则最后剩4阶,若每步跨6阶，则最后剩5阶只有每次跨7阶,最后才正好1阶不剩,请问在这条阶梯最少多少阶

16.设N是一个4位数,它的9倍恰好是它的反序数
 例:1234 反序数是4321

17.求s = a + aa + aaa + aaaa + ... + aa...a的值,其中a是1~9的一个数字(不超过十项)
例:a = 3; s = 3 + 33 + 333;

18.“百钱百鸡”问题,百钱买百鸡,公鸡1个3块钱,母鸡1个2块钱，小鸡3个一块钱,问公鸡,母鸡,小鸡各多少个

19.打印三角形	(画8个三角形)
* * * * *
 * * * *
 * * *
 * *
 *
6_1.打印三角形
 录入n,n是直角三角形的高
 例:	n = 3
 * 
 * * * 
 * * * * *
 n = 4
 * 
 * * * 
 * * * * * 
* * * * * * * 

20.猴子吃桃问题,有一天一只猴子摘了一些桃子,它吃掉一半,又吃了一个,第二天也是这样,到了第十天,只有一个桃子了,求猴子摘了多少桃子

21. 4 5 6 7总共能组成多少个不能被4整除的4位数

22.求n!(n的阶乘)

/*
三角形
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


#include <stdio.h>

int main(void)
{
	int a = 0, b = 0, c = 0;//使用a b c变量表示三角形的三个边

	scanf("%d-%d-%d", &a, &b, &c);//通过scanf函数录入三个边
	/*if error*/
	
	if((a+b>c) && (a+c>b) && (b+c>a))//罗列普通三角形的条件
	{
		if((a*a+b*b==c*c) || 
		(a*a+c*c==b*b) || 
		(b*b+c*c==a*a))//罗列直角三角形的条件
		{
			printf("可以构成直角三角形!\n");
		}
		else if(a==b || a==c || b==c)//罗列等腰三角形的条件
		{
			if(a==b && a==c)//罗列等边三角形的条件
			{
				printf("可以构成等边三角形!\n");
			}
			else
			{
				printf("可以构成等腰三角形!\n");
			}
		}
		else
		{
			printf("可以构成普通三角形!\n");
		}
	}
	else
	{
		printf("不能构成三角形!\n");
	}

	return 0;
}

/*
 从小到大打印
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <stdio.h>

int main(void)
{
	int x = 0, y = 0, z = 0;
	int tmp = 0;

	scanf("%d-%d-%d", &x, &y, &z);
	//x获取三个值中的最小值 z获取三个值中的最大值

	if(x > y)
	{
		tmp = x;
		x = y;
		y = tmp;
	}

	if(x > z)
	{
		tmp = x;
		x = z;
		z = tmp;
	}

	if(y > z)
	{
		tmp = y;
		y = z;
		z = tmp;
	}

	printf("%d<%d<%d\n", x, y, z);

	return 0;
}

/*
输入相应的字符打印相应的语句(默认不区分大小写)
输入a,打印	钟薛高18块钱
输入b,打印	梦龙8块钱
输入c,打印	老冰棒1块钱
输入d,打印	雪莲0.5块钱
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <stdio.h>

int main(void)
{
	char c = 0;//用来接收录入的字符

	scanf("%c", &c);

	if(c == 'A' || c == 'a')//if(c == 65 || c == 97)
	{
		printf("钟薛高18块钱\n");
	}
	else if(c == 'B' || c == 'b')
	{
		printf("梦龙8块钱\n");
	}
	else if(c == 'C' || c == 'c')
	{
		printf("老冰棒1块钱\n");
	}
	else if(c == 'D' || c == 'd')
	{
		printf("雪莲0.5块钱\n");
	}
	else
	{
		printf("录入失败,请重新录入!\n");
	}

	return 0;
}

分支语句

 switch(也有程序员会叫做开关语句)
1.switch case default都是C语言的关键字
2.switch语句的结构
 语句1;
 switch(变量)
 {
 case 整常量1: 语句2;
 case 整常量2: 语句3;
 default : 语句4;
 }
 语句5;
语句1->变量和整常量1是否相等->语句2->语句3->语句4->语句5->end
 |
 不相等->变量和整常量2是否相等->语句3->语句4->语句5->end
 |
 不相等->语句4->语句5->end
3.整常量就是整数或者可以表示为整数的内容(字符)
4.在同一个switch...case结构中整常量不能重复
5.在switch语句中加入break关键字
 语句1;
 switch(变量)
 {
 case 整常量1: 语句2; break;
 case 整常量2: 语句3; break;
 default : 语句4; break;
 }
 语句5;
语句1->变量和整常量1的判断->语句2->break->语句5->结束
 |
 (不相等)->变量和整常量2的判断->语句3->break->语句5->结束
 |
 (不相等)->语句4->break->语句5->结束
6.在switch语句中执行break会跳出switch语句
输入相应的字符打印相应的语句(默认不区分大小写)
输入a,打印	钟薛高18块钱
输入b,打印	梦龙8块钱
输入c,打印	老冰棒1块钱
输入d,打印	雪莲0.5块钱

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>

int main(void)
{
	int i = 0;

	scanf("%d", &i);

	switch(i)
	{
		case 1 : printf("111111\n");
		case 2 : printf("222222\n");
		case 3 : printf("333333\n");
		case 4 : printf("444444\n");
		default: printf("ERROR!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>

int main(void)
{
	char i = 0;

	scanf("%c", &i);

	switch(i)
	{
		case 'a' : printf("1111111111111\n");
		case 'b' : printf("2222222222222\n");
		case 'c' : printf("3333333333333\n");
		case 'd' : printf("4444444444444\n");
		default: printf("ERROR!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>

int main(void)
{
	char i = 0;
	char c = 'a';

	scanf("%c", &i);

	switch(i)
	{
		case 'b' : printf("1111111111111\n");
		case 'b' : printf("2222222222222\n");
		case 'c' : printf("3333333333333\n");
		case 'd' : printf("4444444444444\n");
		default: printf("ERROR!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	char c = 0;

	scanf("%c", &c);

	switch(c)
	{
		case 'a' :
		case 'A' : printf("钟薛高18块钱\n"); break;
		case 'b' :
		case 'B' : printf("梦龙8块钱\n"); break;
		case 'c' :
		case 'C' : printf("老冰棒1块钱\n"); break;
		case 'd' :
		case 'D' : printf("雪莲0.5块钱\n"); break;
		default : printf("ERROR\n"); break;
	}

	return 0;
}

/*
录入成绩
0 ~ 59	打印	不及格
60 ~ 69 打印 及格
70 ~ 79 打印 中
80 ~ 89 打印 良
90 ~ 100 打印 优秀
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>

int main(void)
{
	int score = 0;

	scanf("%d", &score);
	//if error

	switch(score / 10)
	{
		case 0..5 : printf("不及格!\n"); break;
		case 6 : printf("及格!\n"); break;
		case 7 : printf("中!\n"); break;
		case 8 : printf("良!\n"); break;
		case 9 :
		case 10: printf("优秀!\n"); break;
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>

int main(void)
{
	char score = 0;

	scanf("%c", &score);
	//if error

	switch(score)
	{
		case '0' ... '9': printf("Hello World!\n"); break;
		case 'd' ... 'f': printf("Hello Beijing!\n"); break;
	}

	return 0;
}

循环语句

1.for是C语言的关键字
2.for循环的使用方法
语句1
for(循环变量的赋值; 循环变量的控制; 循环变量的变化)
{
 循环的语句
}
语句2
 语句1
 |
 V
 循环变量的赋值
 |
 V
 |--------循环变量的控制<---------
 |				|			循环变量的变化
 V				V				^
 假				真				|		
 |		循环的语句------->-------
 |
 ----------------
 |
 V
 语句2
在循环中不要改变循环变量的值否则会影响循环次数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int i = 0;//循环变量

	for(i = 0; i < 5; i += 1)
	{
		printf("i = %d\n", i);
	}

	//for(i = 10; i < 5; i++)
	//{
	//	printf("Hello World!\n");
	//}

	//for(i = 0; i < 5; i++)
	//{
	//	printf("Hello World!\n");
	//}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 0;//循环变量

	for(i = 0; i < 10; i++)
	{
		//printf("%d\n", i++);
		printf("%d\n", ++i);
	}

	printf("==== i = %d\n", i);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
//打印0 ~ 100以内奇数
int main(void)
{
	int i = 0;

	for(i = 1; i < 100; i+=2)
	{
		printf("%d\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
//求1+2+3+...+100? 5050
int main(void)
{
	int i = 0;
	int sum = 0;

	for(i = 1; i <= 100; i++)
	{
		sum += i;// sum = sum + i
	}

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
//求水仙花数(把水仙花数打印出来)
//xyz == x*x*x + y*y*y + z*z*z
int main(void)
{
	int i = 100;
	int b = 0, s = 0, g = 0;

	for(i = 100; i < 1000; i++)
	{
		b = i / 100;
		s = i / 10 % 10;
		g = i % 10;
		if(i == (b*b*b) + (s*s*s) + (g*g*g))
			printf("i = %d\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
//求水仙花数(把水仙花数打印出来)
//xyz == x*x*x + y*y*y + z*z*z
int main(void)
{
	int i = 1;
	int b = 0, s = 0, g = 0;

	for(b = 1; b < 10; b++)
	{
		for(s = 0; s < 10; s++)
		{
			for(g = 0; g < 10; g++)
			{
				if((b*b*b)+(s*s*s)+(g*g*g)==b*100+s*10+g)
					printf("%d%d%d\n",b,s,g);
			}
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main(void)
{
	int hour = 0, min = 0, sec = 0;
//1s = 1000ms = 1000000us = 1000000000ns
	for(hour = 0; hour < 24; hour++)
	{
		for(min = 0; min < 60; min++)
		{
			for(sec = 0; sec < 60; sec++)
			{
				system("clear");
				printf("%02d : %02d : %02d\n", hour,min,sec);
				sleep(1);
			}
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <unistd.h>

int main(void)
{
	int i = 0;	

	for(i = 0; i < 5; i++)
	{
		printf("%d", i);
		sleep(1);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;

	for(i = 0; i < 4; i++)//管理行
	{
		for(j = 0; j < 5; j++)//管理列
		{
			printf("[%d %d]", i, j);
		}
		printf("\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;

	for(i = 0; i < 4; i++)//管理行
	{
		for(j = 0; j < 5; j++)//管理列
		{
			printf("*");
		}
		printf("\n");
	}

	return 0;
}

/*

1
2
3
4
5


*
* *
* * *
* * * *
* * * * *

*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;

	for(i = 1; i < 10; i++)//管理行
	{
		for(j = 1; j <= i; j++)//管理列
		{
			printf("%d X %d = %2d ", j, i, i * j);
		}
		printf("\n");
	}

	return 0;
}

01test_06day

Thu, 16 Feb 2023 08:03:05 +0800

01test_06day

===================================
2022-7-7
===================================

一.温故知新

 分支语句
 switch case default
 switch(变量)
 {
 case 整常量1 : 语句1; break;
 case 整常量2 : 语句2; break;
 case 整常量3 : 语句3; break;
 default : 语句4; break;
 }

 跳转语句
 break
 如果使用在switch语句中会跳出switch
 
 循环语句
 for(循环变量的赋值; 循环变量的控制; 循环变量的变化)
 {
 循环的语句
 }

 for循环的变形
 1.
 for(; ;)这是一个死循环
 或者
 for(表达式1; ;表达式2)也是一个死循环
 等价于
 for(表达式1; 1;表达式2)
 2.嵌套循环
 int i = 0, j = 0;

 for(i = 0; i < 3; i++)
 {
 for(j = 0; j < 4; j++)
 {
 
 }
 }
 3.int i = 0, j = 0;
 for(i = 0, j = 10; i < 5 && j > 5; i++, j--)

================================================

homework

1.
(1)打印4 * 5 的 *
例:
*****
*****
*****
*****
(2).打印i * j 的 * (i j 键盘接收)
 例:i = 4, j = 5
 //4-5 5-6
 *****
 *****
 *****
 *****
(3).打印i * j 的 * 边框(i j 键盘接收)
 例: i = 4, j = 5
 *****
 * *
 * *
 *****
2.打印99乘法表
 1 * 1 = 1
 1 * 2 = 2 2 * 2 = 4
 *
 **
 ***
 ****


3.计算1+2+3+4+5+...+n, n是从键盘输入的自然数

// 穷举
4.要将5张100元的大钞票,换成等值的50 20 10 5小钞票,每种面值至少一张,要多少张,有多少种换法

5.有1、2、3、4 4个数字,能组成多少个互不相同且无重复的三位数呢

6.有这样的一个等式,xyz+yzz=532,编程求x y z的值

7.计算1^2 + 2^2 + 3^2 + ... +10^2的结果
(1的平方 + 2的平方)

8.输入20个人的成绩,输出不及格的人数(0<=score<60 为不及格)

9.随机产生100个三位随机数,找出其中能被 3 5 7整除的数

10.打印0~100以内所有的质数
(只能被1 和 本身整除的数)

11.猜数游戏(随机产生一个1000以内的数,去猜,
 如果大了打印猜的大了,
 如果小了打印猜的小了,
 如果正确打印对的
 直到猜对了再结束,每次打印必须打印出猜的次数)

12. 把11修改成,程序开始时,先输入需要猜的数的范围n
例:(想要猜数的范围是(0~10000) 那么变量n接收键盘上10000
 范围都是从0开始)

13.
----------------------------
a + b - 9 = 4
+	-	-	
c -	d * e = 4
/	*	-
f + g - h = 4
=	=	=
4	4	4
求a b c d e f g h (0 ～ 12范围内)//除法指的是整除 c % f == 0
只有一种答案

14.求1+12+123+...前N项之和,其中N是从键盘输入的数(N取值范围（1~9）)
 n = 5;
 sum = 1 + 12 + 123 + 1234 + 12345;

15.爱因斯坦出了一道这样的数学题,有一条长阶梯,若每步跨2阶,则最后剩1阶,若每步跨3阶,则最后省2阶,若每步跨5阶,则最后剩4阶,若每步跨6阶，则最后剩5阶只有每次跨7阶,最后才正好1阶不剩,请问在这条阶梯最少多少阶

16.设N是一个4位数,它的9倍恰好是它的反序数
 例:1234 反序数是4321

17.求s = a + aa + aaa + aaaa + ... + aa...a的值,其中a是1~9的一个数字(不超过十项)
例:a = 3; s = 3 + 33 + 333;

18.“百钱百鸡”问题,百钱买百鸡,公鸡1个3块钱,母鸡1个2块钱，小鸡3个一块钱,问公鸡,母鸡,小鸡各多少个

19.打印三角形	(画8个三角形)
* * * * *
 * * * *
 * * *
 * *
 *
6_1.打印三角形
 录入n,n是直角三角形的高
 例:	n = 3
 * 
 * * * 
 * * * * *
 n = 4
 * 
 * * * 
 * * * * * 
* * * * * * * 


20.猴子吃桃问题,有一天一只猴子摘了一些桃子,它吃掉一半,又吃了一个,第二天也是这样,到了第十天,只有一个桃子了,求猴子摘了多少桃子

21. 4 5 6 7总共能组成多少个不能被4整除的4位数

22.求n!(n的阶乘)

 电子版的口算卡
随机生成10道100以内的 [加 减 乘 除 取余] 数学题 回答正确的加10分错误不加分(把正确结果打印出来) 然后显示最后成绩。(不用float类型)	
1>	操作数随机 2>	运算符随机
gcc 1.c		当执行./a.out之后,先清屏
23 + 70 = 93
Bingo!	+10分
79 * 97 = 0
Error!	==== 7663
...
总分 70分

做完的同学,如果觉得没有必要修改了,修改成以自己名字命名的.c文件,可以交给组长
组长收齐后,打包,发到组长的微信群里
17:30之前交齐

作业:

1.把这一周讲过的内容复习一遍
2.循环之后的22道练习题
3.有时间可以做做pdf里面的编程题
4.虚拟机做快照

/*
* * * * *
* * * *
* * *
* *
*
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;
	int n = 0;

	scanf("%d", &n);//通过scanf函数录入边长

	for(i = 0; i < n; i++)
	{
		for(j = 0; j < n - i; j++)
		{
			printf("* ");
		}
		printf("\n");
	}

	return 0;
}

/*
* * * * *
# * * * *
# # * * *
# # # * *
# # # # *
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;
	int n = 0;

	scanf("%d", &n);//通过scanf函数录入边长

	for(i = 0; i < n; i++)
	{
		for(j = 0; j < n; j++)
		{
			if(j < i)
				printf(" ");
			else
				printf("* ");
		}
		printf("\n");
	}

	return 0;
}

/*
*
* *
* * *
* * * *
* * * * *
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;
	int n = 0;

	scanf("%d", &n);//通过scanf函数录入边长

	for(i = 0; i < n; i++)
	{
		for(j = 0; j <= i; j++)
		{
			printf("* ");
		}
		printf("\n");
	}

	return 0;
}

/*
# # # # *
# # # * *
# # * * *
# * * * *
* * * * *
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;
	int n = 0;

	scanf("%d", &n);//通过scanf函数录入边长

	for(i = 0; i < n; i++)
	{
		for(j = 0; j < n; j++)
		{
			if(j < n - i - 1)
				printf(" ");
			else
				printf("* ");
		}
		printf("\n");
	}

	return 0;
}

/*
 *
 * * *
 * * * * *
 * * * * * * *
* * * * * * * * *
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;
	int n = 0;

	scanf("%d", &n);//通过scanf函数录入边长

	for(i = 0; i < n; i++)
	{
		for(j = 0; j < n + i; j++)
		{
			if(j < n - i - 1)
				printf(" ");
			else
				printf("* ");
		}
		printf("\n");
	}

	return 0;
}

/*
* * * * * * * * *
 * * * * * * *
 * * * * *
 * * *
 *


 * 
 * * * 
 * * * * * 
 * * * * * * * 
* * * * * * * * * 
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>

int main(void)
{
	int i = 0, j = 0;
	int n = 0;

	scanf("%d", &n);//通过scanf函数录入边长

	for(i = 0; i < n; i++)
	{
		for(j = 0; j < 2 * n - i - 1; j++)
		{
			if(j < i)
				printf(" ");
			else
				printf("* ");
		}
		printf("\n");
	}

	return 0;
}

01test_07day

Thu, 16 Feb 2023 08:03:05 +0800

01test_07day

===================================
2022-7-8
===================================

循环语句(while)

while(是C语言的关键字)
1.while循环的使用
语句1
while(循环条件)
{
 循环的语句
}
语句2
 -------<----------<------
 |						^
 V						|
语句1->循环条件的判断(真)->循环的语句-->|
 |
 (假)->语句2->结束

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 1;
	int sum = 0;

	while(i <= 100)
	{
		sum += i++;
	}

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 1;
	int sum = 0;

	while(i <= 100)
	{
		sum += i++;
	}

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <unistd.h>

int main(void)
{
	int i = 10, j = 10;

	while(i-- || j--)
	{
		printf("i = %d j = %d\n", i, j);
		sleep(1);
	}

	printf("=== i = %d j = %d\n", i, j);

	return 0;
}

循环语句(do…while)

do...while循环(也是C语言的关键字)
语句1
do
{
 循环的语句
}while(循环的条件);
语句2
 --------<-----------<--------
 |							^
 V							|
语句1->循环的语句->循环条件的判断(真)--->
 |
 (假)->语句2->结束
while循环是先执行循环条件的判断,再执行循环的语句
do...while循环是先执行循环的语句,再执行循环条件的判断

while循环可以一次也不执行循环的语句
do...while循环至少会执行一次循环的语句

do...while : 在写底层内核驱动时,使用do...while循环做超时处理

*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>

int main(void)
{
	int i = 1;
	int sum = 0;

	do
	{
		sum += i++;
	}while(i <= 100);

	printf("sum = %d\n", sum);
	
	return 0;
}

随机函数

rand()		:	产生随机数(非负的正整数)的函数
 rand() % 1000; [0 ~ 999]以内的随机数
 随机产生5位数
 rand() % 90000;			[0 ~ 89999]
 rand() % 90000 + 10000;	[10000 ~ 99999]
 随机产生-50 ~ 50的随机数
 rand() % 100;			[0 ~ 99]
 rand() % 100 - 50;		[-50 ~ 49]
srand();	:	随机种子(可以保证每一次执行程序时,随机数可变)
 srand在调用时需要传参,参数是可变的因子
time();		:	时间种子(获取当前时间的秒数)
 time(NULL);
getpid();	:	进程种子(获取当前进程的ID号)

注意 : srand()函数在程序中值调用一次即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int num = 0;
	
	printf("num = %d\n", num);

	num = rand();
	
	printf("num = %d\n", num);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

int main(void)
{
	int i = 0;
	int num = 0;
	
	//srand(time(NULL));
	srand(getpid());

	for(i = 0; i < 5; i++)
	{
		num = rand() % 100 - 50;
		printf("num = %d\n", num);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


/*
猜数游戏
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main(void)
{
	int T = 0;//用于保存随机数
	int guess = 0;//用于保存录入的数
	int i = 0;//循环变量
	
	srand(getpid());//随机种子
	T = rand() % 1001;//保存随机数

	for(i = 1; ; i++)
	{
		scanf("%d", &guess);
		if(T > guess)
			printf("[%d]	Small!\n", i);
		else if(T < guess)
			printf("[%d]	Big!\n", i);
		else
		{
			printf("[%d]	Bingo!\n", i);
			break;
		}
	}


	return 0;
}

02linux_01day

Thu, 16 Feb 2023 08:03:05 +0800

02linux_01day

=================================
2022-7-11
=================================

一.介绍

 上课时间(课前阅读单词 | 随机抽取学生复述昨天讲过的内容)
 09:00 - 12:00
 13:30 - 17:30
 18:30 - 20:30

 周一 到 周五
 节假日以及周六周日休息(周六有自习室)

 课程安排
 预科		通过预科时间把大家的基础拉平
 --------------------------------
 Linux基础	(环境安装\命令\软件安装\权限管理\用户管理\服务搭建)
 Linux下C语言	(变量\运算符\分支语句\循环\跳转\数组\函数\指针\)
 (复合型数据类型\预处理\文件IO)
 数据结构		(链表\栈式存储结构\队列式存储结构\树存储结构\哈希表)
 ---------考试以及项目-------------	
 APUE		(标准IO\系统调用IO\信号\进程\线程\进程间通信)
 (网络套接字TCP/UDP)
 C++/QT		()
 ---------考试以及项目-------------
 智能终端		单片机开发(裸板驱动)
 ---------------项目--------------
 边缘计算		高端芯片的开发(带操作系统的驱动)
 ---------------项目--------------
 就业环节		压力面试\压力笔试

二.Linux环境的安装

 环境的安装
 1.双系统
 准备
 1)把笔记本的硬盘分出空白的空间(100G)
 2)系统盘
 (光盘安装\U盘安装\网络安装)
 2.虚拟机
 准备
 1)虚拟机软件(vmware\vboxs)
 2)镜像(开源的镜像网站)
 3.注意:无论是双系统的安装还是虚拟操作系统的安装,分区需要选择手动分区
 例如:分了100G的空间
 8192Mb			交换空间
 剩余的一半空间		/home
 剩余的所有空间		/

三.Linux的历史

 在市面上的电子产品的万年历的功能
 1.RTC的功能可以查找基准时间
 1)1900年1月1日	这一天是星期一
 2)1970年1月1日	计算机元年
 3)2000年1月1日	千禧年(千年虫)
 2.计算机元年
 在美国一家通讯公司,AT&T公司(马刺队)
 AT&T公司里面有个实验室叫做贝尔实验室
 丹尼斯.里奇(C语言之父)用闲置的电脑写了一个游戏--太空旅行
 丹尼斯.里奇和肯.汤姆逊使用BSPL语言(B语言)在机器上写通用程序
 觉得B语言不好用,所以创立了C语言
 
 丹尼斯.里奇和肯.汤姆逊写了系统,叫做UNIX
 
 美国加州学院伯克利分院一个教授通过UNIX写了一个minix,用于教学
 这个教授的学生林纳斯,写了Linux

 3.可以在电脑上查询信息
 uname -a	查询内核版本以及操作系统版本

四.Linux系统的认知

 windows			Linux
 500G
 C D E F			/(根目录)
 4棵树			1棵树
 /(根目录)
 bin			存放的是二进制的文件(命令)
 boot		存放的是用来引导内核的文件
 dev			存放的是各种设备文件
 etc			存放的是配置文件
 home		存放的是普通用户的家目录
 lib			存放的是各种库文件(动态库和静态库)
 media		用来挂载存储介质或者媒体介质的文件
 mnt			系统默认可以使用的挂载的目录
 proc		动态的目录(不能用于存储文件)
 (系统内核的信息\进程的信息\内存映射的信息)
 root		超级用户的家目录
 sbin		存放系统的二进制文件
 sys			存放系统的文件
 usr			存放的是应用程序\头文件

五.终端的使用

 1.终端的打开
 1)通过鼠标右键->打开终端
 2)在Ubuntu左下角有显示应用程序->全部->终端
 3)快捷键ctrl + alt + t
 4)打开终端之后打开终端的标签页
 ctrl + shift+ t		//打开标签页
 ctrl + pgup/pgdn	//切换标签页
 注意 : 有同学电脑的键盘上的pgup和pgdn和别的按键在一起
 有可能在切换标签页的时候需要使用shift或者fn
 2.终端提示符
 zack@zack-CSTG:~/桌面/2022-6-29_UEA/02linux$ 
 在@之前		当前登陆这个终端的用户名
 @			分割符号
 在@之后,:之前	主机名
 :			分割符号
 在:之后		当前终端所在目录的路径
 路径分为绝对路径和相对路径
 绝对路径 : 从根目录出发.一层一层递进的目录就是绝对路径
 相对路径 : 除了绝对路径都是相对路径
 在路径中 ~ 指的是家目录的意思
 每个用户都会有家目录
 root用户		/root
 zack用户		/home/zack
 tom用户		/home/tom
 #或者$		用户的身份识别
 #		代表的是超级用户
 $		代表的是普通用户
 3.修改终端提示符的长度
 1)需要修改配置文件
 注意:
 如果修改/etc/下边的配置文件,会影响所有用户
 如果修改家目录下边的配置文件,会影响当前用户
 2)把原有的配置文件拷贝一个备份
 cp ~/.bashrc ~/bashrctest
 3)修改配置文件
 vim ~/.bashrc
 -------------------------
 1>找到要修改的位置,大约在60行左右
 2>PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
 3>把 \h\[\033[00m\]: 删掉		代表不再显示主机名
 4>把 \w 修改成 \W				代表目录路径只显示最后一级
 5>保存退出
 6>sync						代表同步一下信息

六.命令

 在Linux下一切皆文件,任何东西在Linux环境中都是以文件形式存在的

 在终端提示符之后可以录入命令 或者 可执行文件 或者 程序
 终端提示符	命令
 终端提示符	命令 + 选项
 终端提示符	命令 + 参数
 终端提示符	命令 + 选项 + 参数
 注意 : 命令 选项 参数之间需要用空格隔开
 命令 --help	可以查看命令的帮助手册

 cd		(切换目录/改变目录/进入目录)
 1.cd + 目录		//可以切换到该目录中
 如果目录不存在,会提示报错
 2.cd + 路径		//可以切换到该路径中
 可以是绝对路径或者相对路径,但是必须是一个正确的路径
 3.cd 直接回车		//可以直接回到家目录
 4.cd + ..		//可以切换到上一级目录
 ls		(显示当前目录下的文件名)
 1.ls 直接回车		//显示当前目录下的文件名
 2.ls + 文件名		//显示当前目录下该文件的文件名
 3.ls + 目录名		//显示该目录下的文件名
 4.ls + -a		//显示所有文件包括隐藏文件
 //在Linux环境下以.开头的文件都是隐藏文件
 //任何目录都有来两个默认的隐藏文件
 //. 代表当前目录	.. 代表上一级目录
 5.ls + -i		//显示文件inode号
 //文件是存储在硬盘中的,在Linux文件系统中
 //是通过inode号来管理文件的
 //在硬盘的同一分区中,文件inode号不会重复
 6.ls + -l		//使用较长格式显示文件信息
-rw-r--r-- 1 zack zack 8980 7月 9 15:51 examples.desktop
drwxr-xr-x 2 zack zack 4096 7月 9 16:26 公共的
 part.1			文件的类型(在Linux环境中一共有7种文件类型)
 -		普通文件
 d		目录文件
 c		字符设备文件
 b		块设备文件
 p		管道文件
 s		网络套接字文件
 l		链接文件(符号链接文件)
 part.2			文件的权限(分为基本权限和特殊权限)
 rw-			r--			r--
 文件所属者	文件所属组	其他用户
 字符表示		数字表示		含义
 r			4			可读
 w			2			可写
 x			1			可执行
 -			0			该处无权限
 part.3			文件链接数
 part.4			文件所属者
 part.5			文件所属组
 part.6			文件的字节数
 part.7			文件最后修改时间
 part.8			文件名
 pwd		(可以显示当前目录所在的绝对路径)
 touch	(创建普通文件)
 1.touch + 文件名			//创建以文件名命名的普通文件
 如果文件名已经存在,不会修改文件内容,只会修改文件最后修改时间
 如果加已存在的目录名,不会修改文件内容,只会修改文件最后修改时间
 2.touch + 文件名 + 文件名	//可以创建多个文件
 注意 : 文件名与文件名之间用空格隔开
 3.touch + {1..20}.c		//可以创建1.c ... 20.c
 touch + {a..z}.c	//可以创建a.c ... z.c
 touch + {A..Z}.c	//可以创建A.c ... Z.c
 4.touch + 路径/文件		//在该路径下创建新的文件
 注意 : 路径可以是相对路径或者绝对路径,但是必须是正确的路径
 mkdir	(创建目录文件)
 1.mkdir + 目录名				//创建以目录名命名的目录
 注意 : 不能加已有的目录名,会报错
 2.mkdir + 目录名 + 目录名		//创建多个目录
 注意 : 目录名与目录名之间用空格隔开
 3.mkdir + {a..z}dir			//创建adir ... zdir
 4.mkdir + 路径/目录名			//可以在该路径下创建目录文件
 注意 : 可以是绝对路径或者相对路径,但是必须是正确的路径
 rm		(删除文件)
 1.rm + 文件名				//删除文件(普通文件)
 2.rm + -r + 目录名		//删除目录文件
 -r	代表递归的操作
 3.rm *.c				//删除当前目录下所有以.c结尾的文件
 rm file*			//删除当前目录下以file开头的文件
 rm -r dir*			//删除当前目录下以dir开头的文件
 4.rm + 路径/目录名		//删除该目录下的该文件
 注意 : 路径可以是绝对路径或者相对路径,但是必须是正确的路径
 注意 : 在根目录中千万不要执行 sudo rm -rf *
 cat		(查看普通文件的文件内容)
 1.cat + 普通文件的文件名
 2.cat + 路经/普通文件的文件名
 注意 : 路径可以是绝对路径或者相对路径,但是必须是正确的路径
 ----------------------------
 cat		把所有的文件内容打印输出到终端中
 less	从文件的起始位置开始显示,可以通过鼠标滚轮或者键盘上下键翻阅
 按q退出
 more	从文件的起始位置开始显示(显示百分比)
 s向下翻阅		b向上翻阅		q退出
 head	默认查看文件的前10行
 tail	默认查看文件的末尾10行
 ----------------------------
 cp		（拷贝文件）
 1.cp + 源文件名 + 目标文件名	//把源文件的文件内容拷贝到目标文件中
 如果目标文件名已存在,源文件的文件内容会覆盖目标文件的文件内容
 如果目标文件名不存在,会新建以目标文件名命名的文件,
 然后把源文件的文件内容会覆盖目标文件的文件内容
 2.cp + 源文件名 + 目录名		//会把源文件拷贝到目录中
 3.cp + -r + 源目录 + 目标目录	//会把源目录拷贝到目标目录中
 如果目标目录已存在,会把源目录拷贝到目标目录内
 如果目标目录不存在,会新建目标目录,并且把源目录内的文件拷贝到目标目录中
 
 mv		(剪切文件\移动文件\改名字)
 1.mv + 源文件名 + 目标文件名	//剪切文件内容
 如果目标文件名不存在,就是把源文件改名字
 如果目标文件名已存在,也是把源文件改名字,不过会替代掉重名的文件
 注意 : mv在操作目录文件时不需要加 -r 的操作

 tar		(压缩与解压缩)
 1.tar cvf 最终生成的压缩包的名字.tar 要压缩的文件		//用来压缩的
 2.tar xvf 压缩包的名字.tar		//会把压缩包默认解压缩到当前目录下
 3.tar xvf 压缩包的名字.tar -C 路径
 //会把压缩包解压缩到指定目录中
--------------------------------
作业 : 
1.把今天讲过的内容完完整整的复习一遍
2.抽时间自己安装一遍虚拟操作系统
3.查找ls加什么选项可以查看目录名
--------------------------------

02linux_02day

Thu, 16 Feb 2023 08:03:05 +0800

02linux_02day

=================================
2022-7-12
=================================

一.温故知新

 1.介绍
 2.课程安排
 3.Ubuntu的Linux操作系统
 4.介绍Linux由来
 5.介绍Linux系统的根目录
 6.终端的使用
 7.常用的命令
 cd ls(-a\-i\-l) pwd touch mkdir 
 cat(less more head tail)
 cp mv rm tar
drwxr-xr-x 14 root root 4096 9月 16 2021 var
lrwxrwxrwx 1 root root 30 7月 11 08:56 vmlinuz -> boot/vmlinuz-5.4.0-121-generic
 part.1		文件类型(7种文件类型)
 -	普通文件
 d	目录文件
 c	字符设备文件
 b	块设备文件
 p	管道文件
 s	网络套接字文件
 l	链接文件(符号链接文件)
 part.2		文件权限
 rwx			r--			-wx
 文件所属者	文件所属组	其他用户
 7			4			3
 r	4	可读
 w	2	可写
 x	1	可执行
 -	0	该处无权限

二.命令的补充

 在Linux环境中有两种链接文件(硬链接 和 符号链接)
 ln		(创建链接文件<既可以创建硬链接,也可以创建符号链接>)
 1.ln + 源文件名 + 目标文件名		//创建了硬链接文件
 -------------------------------------------------
 源文件和目标文件共用同一个文件inode号
 任意修改一个文件的文件内容,另外的一个文件也会发生改变
 移动或者删除源文件对于硬链接文件不会有影响
 会改变文件的硬链接数
 -------------------------------------------------
 2.ln + -s + 源文件名 + 目标文件名	//创建符号链接文件
 -------------------------------------------------
 符号链接文件类似于windows环境下的快捷方式
 源文件和符号链接文件使用文件inode号不同
 任意修改一个文件的文件内容,另外的一个文件也会发生改变
 移动或者删除源文件对于符号链接文件会有影响
 -------------------------------------------------
 3.总结
 硬链接
 创建方式 : ln 源文件 目标文件
 其实硬链接就是一个文件拥有多个文件名
 源文件和硬链接文件可以在相同目录中也可以在不同目录中
 注意:
 1)修改源文件或者硬链接文件,对于另外一个文件也会发生修改
 2)移动或者删除源文件或硬链接文件,对于另外一个文件没有影响
 3)硬链接文件不占用存储空间
 4)不能对于目录文件进行创建硬链接文件
 (即便是超级用户也不行,在Linux环境中目录是有硬链接的)
 (但是是系统默认创建出来的,用户是创建不了的)
 (. 就是当前目录的硬链接, .. 就是上一级目录的硬链接)
 5)硬链接文件不能跨系统分区或者文件系统
 符号链接
 创建方式 : ln -s 源文件 目标文件
 符号链接文件类似于windows环境下的快捷方式
 符号链接文件内部保存的是源文件的文件名或者路径
 注意 : 
 1)符号链接文件会占用存储空间,保存的是链接的文件的文件名或者路径
 2)符号链接文件是一个独立的文件,它的存在不依赖于源文件
 3)如果移动 重命名 删除源文件,对于符号链接文件会有影响
 虽然受影响,但是链接关系依然存在
 
 find		(查找文件)
 1.find -name 文件名		//通过文件名查找文件
 
 grep		(检索文件内容<针对文件内容进行过滤>)
 1.grep '过滤的内容' 过滤文件的文件名	//从该文件中过滤相关的内容
 2.grep '^root' 过滤文件的文件名	//从该文件中过滤相关的内容
 //^代表查找过滤的内容出现在行首
 3.grep 'bash$' 过滤文件的文件名	//从该文件中过滤相关的内容
 //$代表查找过滤的内容出现在行尾

三.帮助手册

 1.命令 --help				//可以查阅命令的帮助手册
 2.如果查找函数可以使用man手册	//有困难,找男人
 1)man 要查找的内容			//默认是从第一本man手册开始查找
 2)man man				//可以查阅如何使用man手册
 1 可执行程序或 shell 命令
 2 系统调用(内核提供的函数)
 3 库调用(程序库中的函数)
 4 特殊文件(通常位于 /dev)
 5 文件格式和规范，如 /etc/passwd
 6 游戏
 7 杂项(包括宏包和规范，如 man(7)，groff(7))
 8 系统管理命令(通常只针对 root 用户)
 9 内核例程 [非标准
 3)man 数字 查找的内容		//可以指定打开某一本手册
 man 3 printf
 man 3 sleep
 4)man -f 查找的内容		//把man手册中所有有关查找的内容列出
 ------------------------
 在man手册中,按 q 可以退出man手册
 在man手册中,查找关键字可以用 /查找的关键字
 按 n 从上往下查找,按 N 从下往上查找
 ------------------------

四.Linux环境中软件的安装

 注意 : 
 1.在安装软件时,需要访问/etc /sys /usr /var...目录
 有些目录普通用户没有权限访问,所以在安装软件时需要加 sudo
 提升用户权限
 2.在使用sudo时,需要在终端中录入密码,在终端中录入密码是取消回现的
 1.从软件源安装软件(必须可以链接外网)
 前提准备:需要更换软件源
 显示应用程序->软件和更新->下载自->其他站点->腾讯/阿里/华为/清华
 在安装软件时可以先更新软件源 : 
 sudo apt-get update
 sudo apt-get upgrade
 可以加入 -y 的选项		默认选择yes
 sudo apt-get install 安装软件的名字 -y
 ------------------------
 可以做的实验,可以安装
 sl
 ifconfig
 fbset
 ------------------------
 sudo apt-get autoremove 要卸载的东西
 删除已安装的软件包,不会删除依赖的软件包,会保留配置文件
 注意:慎用(容易把图形化界面搞崩溃)
 sudo apt-get remove 要卸载的东西
 删除已安装的软件包,不会删除依赖的软件包,会保留配置文件
 sudo apt-get purge
 删除已安装的软件包,也会删除依赖的软件包
 sudo apt clean
 会把/var/cache/apt/archives目录中的所有.deb的包
 清除掉
 2.从官网下载官方的软件包进行安装
 (Ubuntu->从官网上下载.deb结尾的软件包)
 (Red Hat->从官网上下载.rpm结尾的软件包)
 sudo dpkg -i xxxxx.deb		//安装软件
 sudo dpkg -l 软件名			//确定软件包的名字
 sudo dpkg -r 软件名			//删除软件
 sudo dpkg -p 软件名			//清除信息
 ------------------------
 可以做的实验,可以安装
 VNC Viewer
 WPS
 百度网盘
 网易云音乐
 向日葵
 腾讯会议
 星际译王
 ------------------------
 QQ				不推荐
 搜狗输入法		不推荐
 ------------------------
 3.从官网下载源码包进行安装
 1)从官方网站下载源码包(一般来说就是tar包)
 2)把源码包进行解压缩(tar -xvf)
 3)./configure		//检查编译环境是否缺少需要的库
 4)make -j4			//编译源码(-j4调动所有硬件资源)
 5)sudo make install	//安装软件
 ------------------------
 可以做的实验,可以安装
 MPlayer
 ------------------------
--------------------------------
作业 : 
1.把今天讲过的内容完完整整的复习一遍
2.尝试使用其他的查找方法,查找文件
--------------------------------

02linux_03day

Thu, 16 Feb 2023 08:03:05 +0800

02linux_03day

=================================
2022-7-13
=================================

一.温故知新

 命令的补充
 ln						//用来创建链接文件
 ln 源文件 目标文件			//创建的是硬链接文件
 ln -s 源文件 目标文件		//创建的是符号链接文件

 find					//查找文件

 grep					//检索文件内容

 man手册的使用

 Ubuntu系统软件的安装
 1.sudo apt-get install
 2.从官网下载软件包,进行安装
 sudo dpkg -i
 3.从官网下载源码包,进行安装
 ./config
 make -j4
 make install

二.编辑器和编译器

 1.编辑器(编写程序)
 vi vim gedit emacs
 vim : 是vi编辑器的高级版本
 注意 :
 1.vim后边需要加文件名
 2.vim除了可以打开文件以外也可以创建文件
 3.保存退出,不要直接关闭终端,否则会生成交换文件
 vim 文件名
 |
 按iIoOaA		V	按 :
编辑模式(插入)<-----命令模式----->命令行模式(底行)
 ----->		<-----
 按 esc			删除 :
 1)在命令模式下的操作
 1>光标的定位
 h(向左) j(向下) k(向上) l(向右)
 gg			光标回到首行
 G			光标回到末行
 23G			光标定位到第23行
 /要找的内容	光标直接定位到出现要找的内容的位置
 (n向下查找 N向上查找)
 2>文本的编辑
 yy			复制(把光标所在行的内容进行复制)
 p			粘贴(把复制的内容粘贴到光标所在行的下面)
 P			粘贴(把复制的内容粘贴到光标所在行的上面)
 dd			剪切/删除(把光标所在行的内容进行剪切)
 3yy			复制3行内容
 3dd			剪切/删除3行内容
 3p			粘贴3次(粘贴到光标所在行的下面)
 3P			粘贴3次(粘贴到光标所在行的上面)
 ygg			从首行到光标所在行进行复制
 yG			从光标所在行到末行进行复制
 x			删除光标所在位置的内容
 D			从光标所在位置到行末进行删除
 u			撤销(undo)
 ctrl + r	重做(redo)
 r			替换(只能替换一个字符)
 3>模式的切换
 iIoOaA		进入编辑模式(插入模式)
 :			进入命令行模式(底行模式)
 v			进入可视模式
 --------------------------------
 调整代码格式
 a.	进入到可视模式中
 b.	把需要调整格式的代码通过上下键选中
 c.	按 = 进行调整
 注意 : 让张老师调代码,先把代码格式调整好了
 --------------------------------
 V			进入可视行模式
 ctrl+v		进入可视块模式
 --------------------------------
 块插入
 a.ctrl + v进入到可视块模式
 b.通过上下键选择要插入的块
 c.进入编辑模式(I在选择的块前插入A在选择的块后插入)
 d.录入要插入的内容
 e.按两下 esc
 块删除
 a.ctrl + v进入到可视块模式
 b.通过上下键选择要删除的块
 c.按 d 进行删除
 块替换
 a.ctrl + v进入到可视块模式
 b.通过上下键选择要替换的块
 c.按 r 进入替换的操作
 d.录入要替换的字符
 --------------------------------
 R			进入替换模式
 2)在编辑模式下的操作
 1>文本补齐的功能
 ctrl + p
 3)在命令行模式下的操作
 1>保存退出
 :w			保存
 :q			退出
 :wq			保存并且退出
 :q!			强制退出
 :wqa		保存所有文件,退出所有文件
 2>查找和替换
 :3,7 s/root/zack/	
 把3-7行第一次出现的root替换成zack
 :3,7 s/root/zack/g
 把3-7行出现的所有的root替换成zack
 g	代表的是全局的意思
 :% s/root/zack/g
 把全文出现的所有的root替换成zack
 %	代表的是全文的意思
 4)修改vim的配置文件
 vim /etc/vim/vimrc		会影响所有用户
 vim ~/.vimrc			会影响当前用户
 可以从网上找各种vim的配置方法
 5)使用vim打开多个文件
 注意 : 不要用vim一次性打开多个文件,否则vim会崩溃
 vim -O 多个文件		//以纵向的标签栏打开多个文件
 vim -o 多个文件		//以横向的标签栏打开多个文件
 可以使用ctrl + w(两下)切换文件
 vim -p 多个文件		//以标签页的形式打开多个文件	
 可以使用ctrl + alt + pgup/pgdn切换文件
 2.编译器
 在X86环境中有gcc编译器和cc编译器
 gcc编译器依赖于cc编译器
 在ARM环境中需要使用交叉编译工具链 : arm-linux-gcc
 X86环境和ARM环境会有大端格式和小端格式的区分
 --------------------------------------------
 设计一套程序,测试当前环境是大端格式和小端格式
 --------------------------------------------
 
 gcc .c文件
 1.编译之后什么都没有提示,代表程序没有语法错误,会生成可执行文件
 2.编译之后报出警告,代表程序有点问题,但是不是致命的错误,
 也会生成可执行文件
 3.编译之后报出错误,代表程序有致命的问题,不会生成可执行文件
 默认生成的可执行文件的名字是a.out
 以 ./a.out 的方式执行可执行文件
 gcc hello.c -o hello	//可以指定生成的可执行文件的文件名
 gcc -Wall hello.c		//可以列出所有警告

三.用户管理

 1.用户的分类
 功能上区分 : 超级用户 和 普通用户
 超级用户是在安装Linux操作系统时自动创建的用户
 普通用户是由超级用户或者普通用户创建出来的
 范围上区分 : 本地用户 和 网络用户
 创建在本地计算机上的用户是本地用户
 创建在远端服务器上的用户是网络用户
 2.用户创建的描述
 注意 : 虽然都是Linux操作系统,但是不同公司有不同区别
 当创建用户时,伴随着会创建一系列的东西
 1)系统会为新创建的用户分配一个唯一的编号,叫做UID
 2)系统会为新创建的用户,创建一个同名的组,
 并且分配一个唯一的编号,叫做GID
 3)系统会把新创建的用户加入到同名的组中,这个组也叫做这个用户的主组
 4)系统会在/home/目录中创建一个同名的目录,作为新用户的家目录使用
 5)系统会把/etc/skel目录中的文件拷贝到新用户的家目录中,
 作为基础的配置文件进行使用
 6)系统会把新用户的信息记录到/etc/passwd文件中
 查看/etc/passwd文件
 注意:
 1>/etc/passwd文件中每一行就是一个用户的信息
 2>/etc/passwd文件中每个信息通过 : 分割
 root:x:0:0:root:/root:/bin/bash
 1>root		代表的是用户名
 2>x			代表的是密码(密码移到了/etc/shadow文件)
 3>0			代表的是UID
 ----------------------
 UID : 0			是超级用户
 UID : 1 - 499	是系统用户
 UID : >= 500	是普通用户
 ----------------------
 4>0			代表的是GID
 5>root		代表对于该用户的描述
 6>/root		代表该用户的家目录
 7>/bin/bash	代表该用户登陆Linux终端时使用的命令解释器
 7)系统会把用户的密码记录到/etc/shadow文件中			
 查看/etc/shadow文件
zack:$6$1bVyc6zY$GrJ/9j8jngCDD54QkuDEgZqQJnlWV.MG2ngEFvHkQ dLlkC7AINt6jsm74f8FZvFRuWK5zcz1kf29/LnzakCkd/:19182:0:9999 9:7:::
 1>zack		代表的是用户名
 2>$6$		代表的是加密之后的密码
 3>19182		上次更改密码的日期(从1970-1-1开始算)
 4>0			最短的密码期限(按天算,0代表无最短期限)
 5>99999		最长的密码期限(按天算)
 6>7			密码的警告期限
 8)系统会把新用户的组的信息记录到/etc/group文件中
 3.用户的创建
 sudo useradd 用户名			//创建用户(用户名不能重复)
 sudo passwd 用户名			//修改用户的密码
 sudo su 用户名				//切换用户
 ctrl + d					//结束当前终端用户的登陆
 sudo userdel 用户名			//删除用户(只删除用户)
 sudo userdel -r 用户名//除了删除用户,伴随着会删除创建的东西

四.文件权限的管理

 1.文件权限的介绍
 在Linux操作系统中用户访问的任何文件都是有权限的
 权限可以分为基本权限和特殊权限
 1)基本权限
 rwx				rw-				r--
 文件所属者的权限	文件所属组的权限	其他用户的权限
符号	数字	含义		对于普通文件的影响		对于目录文件的影响
r	4	可读		是否可以读取文件内容	是否可以列出目录的子文件
w	2	可写		是否可以修改文件内容	是否可以创建或删除子文件
x	1	可执行	是否可以执行文件内容	是否可以访问目录内容
 2)修改文件的权限
 sudo chmod 权限 文件名		//修改文件的权限
 //由于权限的表示方法有符号表示和数字表示,所以本身修改权限的方法有很多
 //如果修改目录的权限想要影响子文件或者子目录,需要加-R
 sudo chmod -R 权限 文件名
 1>使用符号表示法
 rwx				rw-				r--
 文件所属者的权限	文件所属组的权限	其他用户的权限
 u				g				o
 u	表示文件所属者的权限
 g	表示文件所属组的权限
 o	表示其他用户的权限
 a	表示所有用户的权限
 u+r 
 sudo chmod g-w 文件名
 o=x
 2>使用数字表示法
 数字表示法也叫做八进制表示法
 sudo chmod 456 test
 //test的文件所属者是r--
 //test的文件所属组是r-x
 //test的其他用户是rw-
 3)修改文件的属主和属组
 sudo chown 名字 文件		//用来修改文件的属主
 sudo chown .名字 文件		//用来修改文件的属组
 sudo chown 名字.名字 文件	
 //既修改文件的属主也修改文件的属组
==============================================
实验
1.创建用户			sudo useradd tom
2.修改用户密码			sudo passwd tom
3.创建家目录			sudo mkdir /home/tom
 (tom目录创建之后本来属于root用户)
4.拷贝模板配置文件		sudo cp /etc/skel/.* /home/tom
5.修改家目录的属主属组	sudo chown -R tom.tom /home/tom
6.修改命令解释器		sudo vim /etc/passwd
 把tom用户的命令解释器修改成/bin/bash
 保存退出
7.切换用户->做实验
==============================================

02linux_04day

Thu, 16 Feb 2023 08:03:05 +0800

02linux_04day

=================================
2022-7-14
=================================

一.温故知新

 1.编辑器
 vim
 命令模式
 光标的定位
 h j k l gg G 3G /string(n N)
 文本的编辑
 yy p P dd u ctrl+r r x D
 模式的切换
 iIoOaA
 :
 v
 V
 ctrl + v
 编辑模式
 文本的补齐
 ctrl + p
 命令行模式
 w q wq q! wqa 
 3,6 s/srcname/destname/
 g %
 可视模式
 代码格式的调整
 可视行模式
 可视块模式
 块插入
 块删除
 块替换
 替换模式
 2.编译器
 gcc->cc
 a.out
 gcc hello.c -o hello
 gcc -Wall
 3.用户管理
 sudo useradd 用户名
 sudo passwd 用户名
 sudo userdel 用户名
 -r
 4.权限管理
 基本权限和特殊权限
符号	数字	含义		对于普通文件的影响			对于目录文件的影响
r	4	可读		是否可以读取文件内容		是否可以列出子文件
w	2	可写		是否可以修改文件内容		是否可以创建或删除子文件
x	1	可执行	是否可以执行文件内容		是否可以访问该目录

二.文件的特殊权限

 无论是suid sgid 还是 sticky,影响的都是可执行的权限
 所以加入特殊的权限将来会出现在 x 的位置
 suid	u+s		4
 sudo chmod u+s 文件名
 如果文件本身的user权限中有x权限,那么u+s之后,s是小写的
 如果文件本身的user权限中没有x权限,那么u+s之后,S是大写的
 一般来说只会在可执行命令中加入u+s的权限
 特性 : 拥有suid权限的命令,任何用户在使用这个命令时,
 都会拥有这个命令的所有者的权限来执行
 (简单来说就是在执行命令时,以命令所有者的权限来运行)
 sgid	g+s		2
 sudo chmod g+s 文件名
 如果文件本身的group权限中有x权限,那么g+s之后,s是小写的
 如果文件本身的group权限中没有x权限,那么g+s之后,S是大写的
 一般来说只会在目录文件中加入g+s的权限
 特性 : 拥有sgid权限的目录,任何用户在该目录下创建的文件
 都会继承该目录的属组
 (无论是普通用户还是超级用户,在g+s的目录下创建文件都会修改属组)
 sticky	o+t		1
 sudo chmod o+t 文件名
 如果文件本身的other权限中有x权限,那么o+t之后,t是小写的
 如果文件本身的other权限中没有x权限,那么o+t之后,T是大写的
 一般来说只会在目录文件中加入o+t的权限
 特性 : 拥有sticky权限的目录,当其他用户想要删除文件时,
 只能删除自己创建的文件
 (当超级用户进入到o+t权限的目录中,可以删除所有文件)
 没有特殊权限		0

三.削减权限umask

 当创建文件时,本身文件的权限过大,需要通过umask的值削减文件的权限
 在终端中录入 umask 可以查看当前umask值
 也可以修改umask数值 : umask 0022
 修改的umask的数值越大,创建的文件的权限越小
 在Linux系统中,默认创建的普通文件的权限是0666,
 0666 - 0002 = 0664(rw-rw-r--)
 在Linux系统中,默认创建的目录文件的权限是0777,
 0777 - 0002 = 0775(rwxrwxr-x)

四.进程的简介

 其实用户在操作系统中做的任何的操作都需要有进程的支持
 进程 : 其实是一个程序运行时的一个过程
 一个进程可以创建出多个子进程的
 主进程 : 父进程
 创建出的进程 : 子进程
 可以调用函数 : fork()
 僵尸进程 : 当父进程创建出子进程,子进程去工作,当子进程做完任务之后
 父进程没有给子进程收尸,子进程会变成僵尸进程
 孤儿进程 : 当父进程创建出子进程,子进程去工作,如果父进程提前结束了
 没有人管理子进程,子进程会变成孤儿进程

程序运行----->主进程----->父进程-->等待子进程结束-收尸->程序结束
 |						|
 fork()					|
 |						|
 子进程---->做工作----->结束(仆街)

 ps		//可以查看进程
 ps -aux	//查看所有进程信息
 当系统启动之后首先会创建一个进程PID为1叫做初始进程(init)
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
 USER		运行该进程的用户
 PID			进程ID号
 %CPU		CPU的占用百分比
 %MEM		内存的占用百分比
 VSZ			占用虚拟内存
 RSS			占用实际内存
 TTY			进程运行的终端
 STAT		进程的状态
 R		运行状态
 s		进程组,下面会有子进程
 S		睡眠状态(可以中断)
 D		睡眠状态(不可中断)
 Z		僵尸状态
 X		死掉的进程
 ...
 START		启动的时间
 TIME		占用CPU的时间
 COMMAND		进程名
 
============================================
./a.out

int max(int a, int b)
{
 return a > b ? a : b;
}

int add(int a, int b)
{
 return a + b;
}

int main(void)
{
 add(13, 7);
 max(13, 7);

 return 0;
}

 return 0;	函数正常运行
 > 0			函数有异常
 < 0			函数有错误

一个进程会有虚拟内存4Gb,实际上只占用了实际内存的4Kb
----------------------------
面试题
 1.C语言的程序会把内存分为几个区?
 5大区
 (栈区 堆区 常量区 全局区 代码区)
 char *p = "Hello World!";
 static
----------------------------

 1Gb		Kernel(内核)
 ----------------------
 3Gb		环境变量/命令行参数
 栈区(从上往下分配)
 空白空间
 堆区(从下往上分配)
 常量区(.RO<只读>)
 全局区(.bss .data)
 代码区(.text)
================================

03c_01day

Thu, 16 Feb 2023 08:03:05 +0800

03c_01day

==============================
2022-7-14
==============================

面试题
1.在C语言中以 # 开头的操作是预处理的操作
2.预处理阶段会有哪些操作?
 3个操作,文件包含 条件编译 宏定义
3.从.c文件编译成可执行程序需要经历哪些阶段?
源程序 被预处理过的源文件 汇编文件 目标文件
hello.c-------->hello.i----->hello.s----->hello.o--->a.out
 预处理 编译 汇编 链接
4.包含头文件时使用尖括号或者双引号的区别?
 尖括号 : 默认从指定目录中查找头文件(/usr/include),
 如果找不到报错
 双引号 : 默认从当前目录中查找头文件,如果找不到再从
 指定目录中查找头文件(/usr/include),
 如果再找不到报错
5.C语言中有字符串但是没有字符串类型

#include <stdio.h>
/*
main函数(主函数) : 是程序的入口
当执行可执行程序时,从main函数进入,
按照从上往下的顺序逐行逐行执行代码,
最后从main函数退出

在刚开始写程序时,
多问问自己为什么要写这一行代码?
写这一行代码要干什么?
*/
/*
函数的返回值类型 函数名(参数列表)//该处参数指的是形式参数
{
 程序的代码
}

*/
int main(void)
{
 printf("Hello World!");
/*
 调用了printf函数
 printf函数的功能 : 
 可以把双引号引起来的内容打印输出到终端上
 在C语言中双引号引起来的内容叫做字符串
 在C语言中单引号引起来的内容叫做字符
 字符串是由一个一个单一的字符串组成的,
 最后会有一个结束标志尾0('\0')
 --------------------------------
 "0"		这是一个字符串,是由'0' + '\0'组成
 '0'		这是一个字符,ASCII值48
 '\0'	这是一个字符,并且是一个转义字符,是尾0,ASCII是0
 0		这是一个整数0
*/
}

/*
其实字符就是把计算机世界中的数字和日常生活中的符号
进行一一对应
printf函数
 1.转义字符(除了有数字的对应关系以外还有额外的含义)
 字符	ASCII值		额外的含义
 '\0'	0			字符串的结束标志
 '\n'	10			换行符
 '\r'	13			回车符
 '\t'	9			水平制表符
 '\v'	11			垂直制表符
 2.标准化输出格式
 %d	十进制整数(%03d)
 %x	十六进制输出
 %o	八进制输出
 %f	小数输出(%.2f)
 %c	字符输出
 %s	字符串输出
 %p	地址输出
 %%	打印百分号本身
 3.VT控制码
 可以控制打印输出的属性		
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;

	for(i = 30, j = 47; i <= 37 && j >= 40; i++, j--)
	{
		printf("\33[%dm\33[%dmHello World!\33[0m\n",i ,j);
	}

	return 0;
}

03c_02day

Thu, 16 Feb 2023 08:03:05 +0800

03c_02day

==============================
2022-7-15
==============================

一.温故知新

 权限的补充(特殊的权限)
 suid	u+s	(可执行的命令文件中加入u+s)
 sgid	g+s	(目录文件中加入g+s)
 sticky	o+t	(目录文件中加入o+t)
 
 umask值
 666 - 0002 = 664 
 777 - 0002 = 775
 
 进程的介绍
 ps -aux
 kill PID

Linux下的C语言

#include <stdio.h>

int main(void)
{
 printf("Hello World!");
}

函数的返回值类型	函数名	(参数列表)
{
 代码
}
int					main	(void)
{
 printf("Hello World!");
}

'\0'	'\n'	'\r'	'\t'	'\v'
ASCII(常用ASCII表有128个字符<又补充到了256个字符>)
'\0'	0
'\n'	10
'0'		48
'A'		65
'a'		97
标准化输出格式
 %+某一个东西
 %d
 %c
 %f
 %s
 %p
 %%
 %o
 %x
VT控制码

变量

1.变量的含义
 变量是用来存储数据的
 (会把数据存储到内存中<以二进制补码的形式存储>)
2.变量的定义
 数据类型	变量名	;
 1)基本数据类型
 整型	有符号/无符号	short int long
 实型	有符号			float double
 字符型	有符号/无符号	char
 2)通过sizeof运算符进行测试
 测试出的结果以字节为单位
 1字节 = 8位
 sizeof(char) = 1
 sizeof(short) = 2
 sizeof(int) = 4
 sizeof(long) = 8
 sizeof(float) = 4
 sizeof(double) = 8
 测试的结果并不唯一,会随着硬件或者操作系统有所变化
 3)变量名的命名要求
 1>变量名是由数字 字母 下划线组成,但不能以数字开头
 2>变量名是区分大小写的
 3>变量名不能与C语言的关键字重复
 4>变量名要做到见名生义
3.变量的存储
 char c = 13;
 //将来会把十进制整数13转换成8位的二进制的数据存储到
 //c变量所占用的1个字节的存储空间中

 0 0 0 0 1 1 0 1
 在二进制数据中,最左边的是最高位
 在二进制数据中,最右边的是最低位
 第7位	0
 第6位	0
 第5位	0
 第4位	0
 第3位	1
 第2位	1
 第1位	0
 第0位	1
 如果是有符号类型,最高位是符号位,其余位是数据位
 第7位		符号位	(0代表正数 1代表负数)
 第6-0位		数据位

 unsigned char c = 13;
 无符号的数据类型所以范围是[0 ~ 255]
 
 float f = 3.2;
 有符号的数据类型
 float在内存中占用4个字节存储空间(32bit)
 第31位		符号位
 第30位		浮点偏移量的位
 第29-23位	整数位
 第22-0位	小数位
 f = 3.2
 000000011
 0.2 * 2 = 0.4	0
 0.4 * 2 = 0.8	0
 0.8 * 2 = 1.6	1
 0.6 * 2 = 1.2	1
 0.2 * 2 = 0.4	0

 变量会存储在内存中,以二进制补码的形式进行存储
原码 : 把操作数从别的进制转化成二进制,就是原码
 程序员要的是原码(printf打印出的数据是原码数据)
补码 : 如果操作数为正,那么原码等于补码
 如果操作数为负,那么原码不等于补码,需要转换
 无论是原码转换成补码,还是补码转换成原码,公式都一样
 除了符号位不变,其他位按位取反,再加1
 计算机要补码(计算机在计算的时候需要用补码计算)
为什么使用补码存储数据?
 1)保证0的唯一性
 2)为了保证加法运算的合理
 1-1 -> 1 + (-1) 
 0001 + 1001 = 1010 = -2
 0001 + 1111 = 0000 = 0

存储

二转十

进制间转换

按位取反

4.变量的初始化
 数据类型	变量名	=	数值	;
 char		c		=	13		;
 int			a		=	9527	;
 float		f		=	3.14	;
5.变量的定义和变量的初始化有什么区别?
 变量的定义 : 只是在内存中分配了相应的存储单元,
 存储空间中是垃圾值
 变量的初始化 : 除了在内存中分配了相应的存储单元,
 也在存储空间中保存了初始值
 注意 : 当你定义变量时一定要有初始化
6.变量的使用规则
 1)变量要先定义再使用
 (把变量的定义放到main函数的开头的位置)
 2)不同类型的变量有不同的运算要求
 3)变量在定义时在内存中占用的空间大小就已经确定了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	printf("sizeof(char) = %ld\n", sizeof(char));
	printf("sizeof(short) = %ld\n", sizeof(short));
	printf("sizeof(int) = %ld\n", sizeof(int));
	printf("sizeof(long) = %ld\n", sizeof(long));
	printf("sizeof(float) = %ld\n", sizeof(float));
	printf("sizeof(double) = %ld\n", sizeof(double));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = -1;

	printf("c = %p\n", c);
	//%p可以打印出变量在内存中是如何存储的
/*
	c = 0xff;//1111 1111	
char c = -1;
原码	1 0 0 0 0 0 0 1
补码	1 1 1 1 1 1 1 1
*/

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = -13;

	printf("c = %p\n", c);
	//%p可以打印出变量在内存中是如何存储的
/*
	c = 0xff;//1111 1111	
char c = -1;
原码	1 0 0 0 0 0 0 1
补码	1 1 1 1 1 1 1 1

char c = -128;
原码	1 0 0 0 0 0 0 0
补码	1 0 0 0 0 0 0 0
0x80

char c = -13;
原码	1 0 0 0 1 1 0 1
补码	1 1 1 1 0 0 1 1
	c = 0xf3
*/

	return 0;
}

面试题
1.进制之间转换
 八进制<------->二进制<-------->十六进制
 ^
 |
 V
 十进制
 1)十进制转换成二进制	除以2取余
 2)二进制转换成十进制	2的n次方
2.除了常用进制以外,笔试题会考三进制 五进制 七进制 十五进制
============================================
作业:
1.把今天讲过的内容完完整整的复习一遍
2.多做一些进制之间转换的题目
============================================
int i = 100;
int i = 'a';
char c = 13;
char c = 'A';//char = 1/4int

scanf函数

函数功能 : 用来接收键盘录入的函数
 scanf("%d", &i);
注意:
 1.在scanf函数的双引号中只写标准化输出格式即可
 2.在scanf函数的双引号中不要加换行符
 3.在scanf函数的双引号之后需要的是地址
gcc编译器是不检查段错误(由于操作内存不当引起的)的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;

	printf("i = %d\n", i);
	
	printf("请输入变量i的值:");
	//scanf("%d\n", &i);
	scanf("%d", i);

	printf("i = %d\n", i);

	return 0;
}

算术运算符

 +	加法
 -	减法
 *	乘法
 /	除法(取商)
 %	除法(取余/取模)
注意 : 
 除法运算中,除数不能为0
 int a = 13, b = 7, sum = 0;
 sum = a + b;
 sum = a - b;
 sum = a * b;
 sum = a / b;//a所在的位置是被除数,b所在的位置是除数
 sum = a % b;//a所在的位置是被除数,b所在的位置是除数
如果在除法运算中,被除数 小于 除数, 商是0, 余数是被除数本身
 sum = 7 / 13;// sum = 0
 sum = 7 % 13;// sum = 7

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 7, b = 13;

	printf("a + b = %d\n", a + b);
	printf("a - b = %d\n", a - b);
	printf("a * b = %d\n", a * b);
	printf("a / b = %d\n", a / b);
	printf("a %% b = %d\n", a % b);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int sum = 0;

	scanf("%d", &sum);
	//通过scanf函数为sum变量录入4位的正整数
	//atoi();		itoa();
	/*	itoa();
		9527 -> "9527"
		9527 / 1000 = 9 + '0' = '9'
		9527 / 100 % 10 = 5 + '0' = '5'
		9527 / 10 % 10 = 2 + '0' = '2'
		9527 % 10 = 7 + '0' = '7'
	*/
	printf("千位 : %d\n", sum / 1000);
	printf("百位 : %d\n", sum / 100 % 10);
	printf("十位 : %d\n", sum / 10 % 10);
	printf("个位 : %d\n", sum % 10);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 0, b = 0;
	int tmp = 0;

	scanf("%d-%d", &a, &b);

	printf("a = %d b = %d\n", a, b);
	//通过某种方法交换a和b的值
	/*
	tmp = a;
	a = b;
	b = tmp;
	*/

	a = a + b;//a = 13 + 7 = 20
	b = a - b;//b = 20 - 7 = 13
	a = a - b;//a = 20 - 13 = 7

	printf("a = %d b = %d\n", a, b);

	return 0;
}

关系运算符

 >		是否大于
 <		是否小于
 ==		是否相等
 >=		是否大于等于
 <=		是否小于等于
 !=		是否不等于
一个表达式经过关系运算符的运算,最终会生成真假值
 0为假,非0为真
 默认的真值是1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	printf("13 > 7 = %d\n", 13 > 7);
	printf("13 < 7 = %d\n", 13 < 7);
	printf("13 == 7 = %d\n", 13 == 7);
	printf("13 >= 7 = %d\n", 13 >= 7);
	printf("13 <= 7 = %d\n", 13 <= 7);
	printf("13 != 7 = %d\n", 13 != 7);

	return 0;
}

逻辑运算符

 &&	逻辑与	表达式1 && 表达式2
 全真才为真,有假就是假
 ||	逻辑或	表达式1 || 表达式2
 全假才为假,有真就是真
 !	逻辑非	!(表达式)
 真假互换
 表达式1 && 表达式2
 如果表达式1为真,会执行表达式2的内容
 如果表达式1为假,不会执行表达式2的内容
 表达式1 || 表达式2
 如果表达式1为真,不会执行表达式2的内容
 如果表达式1为假,会执行表达式2的内容
-----------------------
1.罗列一下判断是否是闰年的条件
(能被4整除但是不能被100整除 或者 能被400整除)
(year % 4 == 0 && year % 100 != 0) || (year%400==0)
2.罗列三角形的条件(普通 直角 等腰 等边)
 a b c
 a + b > c && a + c > b && b + c > a
 a * a + b * b == c * c ||
 a * a + c * c == b * b ||
 b * b + c * c == a * a
 a == b || a == c || b == c
 a == b && a == c
-----------------------

1
2
3
4
5
6
7
8


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


	
#	赋值运算符
		= += -= *= /= %= <<= ...
	会把赋值运算符右边的项先进行计算,
		再赋值给赋值运算符左边的项(左值)
	a += 1;	//	a = a + 1;
	int a = 10;
	a *= 2 + 3;// a = a * (2 + 3);
	a = 50
	```C
	#include <stdio.h>
	#include <stdlib.h>
	
	int main(int argc, char *argv[])
	{
	
		return 0;
	}

条件运算符

 也是C语言唯一的一个三目运算符
 ? :
 part.1 ? part.2 : part.3;
如果part.1为真,会执行part.2的内容
如果part.1为假,会执行part.3的内容

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 0, b = 0;
	int min = 0;

	scanf("%d-%d", &a, &b);

	min = a < b ? a : b;

	printf("min = %d\n", min);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int year = 0;

	scanf("%d", &year);

(year%4==0&&year%100!=0)||(year%400==0)?printf("%d年是闰年\n", year) : printf("%d年是平年\n", year);

	return 0;
}

强制类型转换

 (数据类型)
 可以把操作的内容临时的强制转换成某种数据类型
 将来会在底层内核驱动大量使用强制类型转换的运算符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	float f = 3.14;

	printf("f = %d\n", (int)f);

	return 0;
}

自增自减运算符

 ++	自增
 --	自减
 如果a++或者++a自己为独立的一条语句,执行时没有区别
 如果和别的语句一起使用,会有区别
 a++ : 先使用a的值做操作,再自增
 ++a : 先自增,再使用a的值做操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 0;

	printf("a++ = %d\n", a++);

	a = 0;

	printf("++a = %d\n", ++a);

	return 0;
}

注意 : 作为嵌入式开发工程师,2的0次方 ~ 2的10次方
在底层内核驱动中做位运算需要保证是在无符号的环境中进行运算
位运算符
 <<		按位左移
 会把操作数的二进制位,每一位都进行左移的操作
 在某种程度上来说,按位左移相当于是乘法运算
 左移多少位就相当于乘以2的多少次方
 char c = 13;
 c <<= 3;//c * 2的3次方 = 13 * 8 = 104
 >>		按位右移
 会把操作数的二进制位,每一位都进行右移的操作
 在某种程度上来说,按位右移相当于是除法运算(取商)
 右移多少位就相当于 / 2的多少次方,取商
 &		按位与
 全1才是1,有0就是0
 |		按位或
 全0才是0,有1就是1
 ~		按位取反(每一位都要取反)
 0变成1,1变成0
 ^		按位异或
 相同为0,不同为1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = 13;//00001101

	printf("c = %d\n", c);
	
	//c = c << 2;//00110100->32+16+4=52
	//c = c << 3;//01101000->64+32+8=104
	c = c << 8;

	printf("c = %d\n", c);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = 13;//00001101

	printf("c = %d\n", c);
	
	c = c >> 2;//00000011

	printf("c = %d\n", c);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char a = 13, b = 7;
	char c = 0;

	printf("c = %d\n", c);
	
	c = a & b;
/*
	a	0 0 0 0 1 1 0 1
	&
	b	0 0 0 0 0 1 1 1
	=
	c	0 0 0 0 0 1 0 1
*/
	
	printf("c = %d\n", c);
	
	c = a | b;
/*
	a	00001101
	|
	b	00000111
	=
	c	00001111
*/	
	printf("c = %d\n", c);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = 13;//00001101

	printf("c = %d\n", c);
	c = ~c;		//11110010->-114
	printf("c = %d\n", c);

	return 0;
}

char c = 13;
原码	0 0 0 0 1 1 0 1
补码	0 0 0 0 1 1 0 1
~
补码	1 1 1 1 0 0 1 0
原码	1 0 0 0 1 1 1 0
 c = -14
char c = -13;	c = ~c;
原码	1 0 0 0 1 1 0 1
补码	1 1 1 1 0 0 1 1
~
补码	0 0 0 0 1 1 0 0
原码	0 0 0 0 1 1 0 0
 c = 12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	unsigned char c = -2;

	printf("c = %d\n", c);

	return 0;
}

 unsigned char c = -1;
原码	1 0 0 0 0 0 0 1
补码	1 1 1 1 1 1 1 1

 printf("c = %d\n", c);
 c = 255

 unsigned char c = -2;
原码	1 0 0 0 0 0 1 0
补码	1 1 1 1 1 1 1 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char a = 13, b = 7;
	char c = 0;

	printf("c = %d\n", c);
	
	c = a ^ b;
/*
	a	00001101
	^
	b	00000111
	=
	c	00001010
*/
	
	printf("c = %d\n", c);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = -13;

	printf("c = %d\n", c);
	
	c <<= 4;
/*
c = -13
原	1 0 0 0 1 1 0 1
补	1 1 1 1 0 0 1 1
c << 4
补	0 0 1 1 0 0 0 0
原	0 0 1 1 0 0 0 0
	c = 48
*/
	printf("c = %d\n", c);

	return 0;
}

位运算符的真正使用

注意:
1.在做位运算时,只改变要操作的位,其他位要保持不变
2.如果想要置1用按位或
3.如果想要清0用按位与
4.按位或上0,会保持不变
5.按位与上1,会保持不变
6.如果一次性想要操作多个位,一定要先清零再赋值

1.例如:GPIOA是一个32bit的寄存器,
 现在想要把该寄存器的第3位置1
GPIOA |= (1 << 3);
--------------------------------------------------
1			00000000 00000000 00000000 00000001
1<<3		00000000 00000000 00000000 00001000
|
GPIOA		XXXXXXXX XXXXXXXX XXXXXXXX XXXX#XXX
=
GPIOA		XXXXXXXX XXXXXXXX XXXXXXXX XXXX1XXX
--------------------------------------------------

2.例如:GPIOA是一个32bit的寄存器,
 现在想要把该寄存器的第4位清0
 GPIOA &= ~(1 << 4);
--------------------------------------------------
1			00000000 00000000 00000000 00000001
1<<4		00000000 00000000 00000000 00010000
~(1<<4)		11111111 11111111 11111111 11101111
&
GPIOA		XXXXXXXX XXXXXXXX XXXXXXXX XXX#1XXX
=
GPIOA		XXXXXXXX XXXXXXXX XXXXXXXX XXX01XXX
--------------------------------------------------

3.例如:GPIOA是一个32bit的寄存器,
 现在想要把该寄存器的第11 10 9 8位变为1010
 GPIOA &= ~(15 << 8);
 GPIOA |= (10 << 8);

03c_03day

Thu, 16 Feb 2023 08:03:05 +0800

03c_03day

===========================
2022-7-18
===========================

一.温故知新

 运算符
 算术运算符		+ - * / %
 注意 : 除法运算符中除数不能为0
 关系运算符		> < == >= <= !=
 注意 : 
 1.一个表达式经过关系运算符的运算最后是真假值
 2.判断两个值是否相等用==
 3.if(a == 13) 建议 if(13 == a)
 逻辑运算符		&& || !
 注意 :
 1.一个表达式经过逻辑运算符的运算最后是真假值
 2.条件1 && 条件2
 条件1为真,会执行条件2
 条件1为假,不会执行条件2
 3.条件1 || 条件2
 条件1为真,不会执行条件2
 条件1为假,会执行条件2
 赋值运算符		= += -= *= /= &= |= ...
 注意 : 先计算右边的项,再和左边结合
 位运算符		<< >> & | ~ ^
 注意 : 操作数符号的问题
 条件运算符		? :
 注意 : 是C语言中唯一的一个三目运算符
 下标运算符		[]
 指针运算符		* &
 分量运算符		. ->
 求字节大小运算符sizeof()
 注意 : sizeof不是函数,是一个运算符
 强制类型转换	()
 注意 : 会在指针的时候使用
 自增自减		++ --
 逗号运算符		,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);

	printf("a = %d b = %d\n", a, b);
	//通过某种方法交换a和b的值
	/*
	int tmp = 0;
	tmp = a;
	a = b;
	b = tmp;
	a = a + b;
	b = a - b;
	a = a - b;
	*/
	a = a ^ b;//a = 1101 ^ 0111 = 1010
	b = a ^ b;//b = 1010 ^ 0111 = 1101
	a = a ^ b;//a = 1010 ^ 1101 = 0111
	printf("a = %d b = %d\n", a, b);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 10, sum = 0;

	sum += a++;

	printf("a = %d sum = %d\n", a, sum);

	return 0;
}

逗号运算符

 如果一个表达式使用了逗号运算符
 如果没有加小括号,那么会把第一个项的结果赋值给变量
 如果有加小括号,那么会把最后一个项的结果赋值给变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 0, b = 10, c = 20, d = 30;
	
	a = (b++,c+5,d+10);

	printf("a = %d\n", a);

	return 0;
}

分支结构

 if
1.if else是C语言的关键字
2.if使用方法
 语句1
 if(条件)
 {
 语句2
 }
 语句3

语句1->条件的判断(真)->语句2->语句3
 |
 (假)->语句3
3.if else使用方法
 语句1
 if(条件)
 {
 语句2
 }
 else
 {
 语句3
 }
 语句4
语句1->条件的判断(真)->语句2->语句4
 |
 (假)->语句3->语句4
4.if else if else if使用方法
 语句1
 if(条件1)
 {
 语句2
 }
 else if(条件2)
 {
 语句3
 }
 else if(条件3)
 {
 语句4
 }
 else
 {
 语句5
 }
 语句6
语句1->条件1的判断(真)->语句2->语句6
 |
 (假)->条件2的判断(真)->语句3->语句6
 |
 (假)->条件3的判断(真)->语句4->语句6
 |
 (假)->语句5->语句6
5.使用if需要注意的问题
 1>if关键字之后必须要写小括号,小括号内必须写内容
 2>else关键字之后不能直接加小括号写条件,需要写成else if
 3>if(条件)之后可以直接加 ; 
 if(条件);
 {
 语句
 }
 等价于
 if(条件)
 {
 ;
 }
 {
 语句
 }
 4>if(条件)之下可以不加大括号
 if(条件)
 语句1
 语句2
 等价于
 if(条件)
 {
 语句1
 	}
 语句2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int c = 0;

	scanf("%d", &c);

	//if(c % 2 == 0)//判断是否是偶数的条件
	if((c & 1) == 0)//位运算符(判断最低位是否为0)
	{
		printf("%d是偶数!\n", c);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int c = 0;

	scanf("%d", &c);

	//if(c % 2 == 0)//判断是否是偶数的条件
	if((c & 1) == 0)//位运算符(判断最低位是否为0)
	{
		printf("%d是偶数!\n", c);
	}
	else
	{
		printf("%d是奇数!\n", c);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int year = 0;

	scanf("%d", &year);

	//if((year%4==0&&year%100!=0) || (year%400==0))
	if((!(year%4)&&year%100) || !(year%400))
	//判断是否是闰年的条件
	{
		printf("%d年是闰年!\n", year);
	}
	else
	{
		printf("%d年是平年!\n", year);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 0, b = 0, c = 0;

	scanf("%d-%d-%d", &a, &b, &c);
	//if error

	if(a+b>c && a+c>b && b+c>a)//判断可以构成三角形的条件
	{
		if(a*a+b*b==c*c || a*a+c*c==b*b || b*b+c*c==a*a)
		//判断可以构成直角三角形的条件
		{
			printf("可以构成直角三角形!\n");
		}
		else if(a == b || a == c || b == c)
		//判断是否可以构成等腰三角形
		{
			if(a == b && a == c)
			{
				printf("可以构成等边三角形!\n");
			}
			else
			{
				printf("可以构成等腰三角形!\n");
			}
		}
		else
		{
			printf("可以构成普通三角形!\n");
		}
	}
	else
	{
		printf("不能构成三角形!\n");
	}
	
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;

	scanf("%d", &i);

	switch(i)
	{
		case 1 : printf("Hello World!\n");
		case 2 : printf("北京欢迎您!\n");
		case 3 : printf("物联网嵌入式!\n");
		case 4 : printf("今天好热!\n");
	}

	return 0;
}

输入年月日,打印出是该年的第几天
//2022-7-18
是2022年的第?天
2022-1-9	9天
2022-2-9	9+31天
2022-3-9	9+(28||29)+31
2022-4-9	9+31+(28||29)+31

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int year = 0, month = 0, day = 0;
	int flag = 0;//用来标记闰年和平年
	int days = 0;//用来存储最后总天数

	scanf("%d-%d-%d", &year, &month, &day);
	/*if error*/

	flag = (!(year%4)&&(year%100)) || !(year%400);
	//如果是闰年 flag = 1 否则 flag = 0

	switch(month)
	{
		case 1 : days += day; break;
		case 2 : days += (day + 31); break;
		case 3 : days += (day + 59 + flag); break;
		case 4 : days += (day + 90 + flag); break;
		case 5 : days += (day + 120 + flag); break;
		case 6 : days += (day + 151 + flag); break;
		case 7 : days += (day + 181 + flag); break;
		case 8 : days += (day + 212 + flag); break;
		case 9 : days += (day + 243 + flag); break;
		case 10: days += (day + 273 + flag); break;
		case 11: days += (day + 304 + flag); break;
		case 12: days += (day + 334 + flag); break;
	}

	printf("%d年%d月%d日是这一年的第%d天!\n", year, month, day, days);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int year = 0, month = 0, day = 0;
	int flag = 0;//用来标记闰年和平年
	int days = 0;//用来存储最后总天数

	scanf("%d-%d-%d", &year, &month, &day);
	/*if error*/

	flag = (!(year%4)&&(year%100)) || !(year%400);
	//如果是闰年 flag = 1 否则 flag = 0

	switch(month)
	{
		case 12: days += 30;
		case 11: days += 31;
		case 10: days += 30;
		case 9 : days += 31;
		case 8 : days += 31;
		case 7 : days += 30;
		case 6 : days += 31;
		case 5 : days += 30;
		case 4 : days += 31;
		case 3 : days += (28 + flag);
		case 2 : days += 31;
		case 1 : days += day;
	}

	printf("%d年%d月%d日是这一年的第%d天!\n", year, month, day, days);

	return 0;
}

循环语句

 for
1.for是C语言中的关键字
2.for循环的使用方法
 语句1
 for(循环变量的赋值; 循环变量的控制; 循环变量的变化)
 {
 循环的语句
 }
 语句2
3.for循环的执行流程
 语句1
 |
 V
 循环变量的赋值
 |
 V
 |-<-循环变量的控制--<---|
 |			|			|
 V			V			|
 假			真			|
 |			|			^
 V			V			|
 |		循环的语句		|
 |			|			^
 |			V			|
 |	循环变量的变化-->---|
 |
 |---->------|
 V
 语句2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, score = 0;

	for(i = 0; i < 10; i++)
	{
		scanf("%d", &score);
		printf("score = %d\n", score);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>
//求3位数字的水仙花数
//百位数字的3次方 + 
//十位数字的3次方 + 
//个位数字的3次方 == 3位数
int main(int argc, char *argv[])
{
	int i = 0;
	int b = 0, s = 0, g = 0;

	for(i = 100; i < 1000; i++)//[100 ~ 999]所有三位数
	{
		b = i / 100;//取三位数的百位
		s = i / 10 % 10;//取三位数的十位
		g = i% 10;//取三位数的个位
		if(i == b*b*b + s*s*s + g*g*g)
			printf("i = %d\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;
	int b = 0, s = 0, g = 0;

	for(b = 1; b < 10; b++)
	{
		for(s = 0; s < 10; s++)
		{
			for(g = 0; g < 10; g++)
			{
				if(b*b*b+s*s*s+g*g*g==b*100+s*10+g)
					printf("%d\n", b*100+s*10+g);
			}
		}
	}

	return 0;
}

/*
打印0~100以内所有的质数(素数)
(只能被1 和 本身整除的数)
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;
	int num = 1;

	for(i = 2; i < 100; i++)
	//该循环为了取出[0-100]以内所有数字
	{
		for(j = 2; j < i; j++)//该循环为了取出[2 - i-1]
		{
			if(i % j == 0)//判断是否能被整除
			{
				break;//如果能被整除说明不是质数,跳出
			}
		}
		if(i == j)
			printf("[%d]	%d\n", num++, i);
	}

	return 0;
}

/*
 11	是不是质数
 
 11 % 1 = 0
 11 % 2 != 0
 11 % 3 != 0
 11 % 4 != 0
 11 % 5 != 0
 11 % 6 != 0
 11 % 7 != 0
 11 % 8 != 0
 11 % 9 != 0
 11 % 10 != 0
 11 % 11 = 0

 8	是不是质数
 8 % 1 = 0
 8 % 2 = 0	能整除
 8 % 3 != 0
 8 % 4 = 0	能整除
 8 % 5 != 0
 8 % 6 != 0
 8 % 7 != 0
 8 % 8 = 0

 i	是不是质数
 i % 1 = 0
 i % [2 ~ i-1]
 i % i = 0
*/

03c_04day

Thu, 16 Feb 2023 08:03:05 +0800

03c_04day

===========================
2022-7-19
===========================

一.温故知新

 分支语句
 if
 if else
 语句1
 if(条件1)
 {
 语句2
 }
 else if(条件2)
 {
 语句3
 }
 else if(条件3)
 {
 语句4
 }
 语句5

 switch(变量)
 {
 case 整常量1: 语句1; break;
 case 整常量2: 语句2; break;
 case 整常量3: 语句3; break;
 default : 语句4; break;
 }
 循环语句
 for(; ;)//这是一个死循环

 for(表达式1; ;表达式2)

 等价于

 for(表达式1; 1; 表达式2)

 int i = 0, j = 0;

 for(i = 0; i < 10; i++)
 {
 for(j = 0; j < 10; j++)
 {
 
 }
 }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


```C
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;

	for(i = 0; i < 4; i++)//管理行数
	{
		for(j = 0; j < 5; j++)//管理列数
		{
			printf("[%d %d]", i, j);
		}
		printf("\n");
	}

	return 0;
}

打印99乘法表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 1, j = 1;

	for(i = 1; i < 10; i++)
	{
		for(j = 1; j < 10; j++)
		{
			if(j <= i)
				printf("%d X %d = %d ", i, j, i*j);
		}
		printf("\n");
	}

	return 0;
}

99乘法表

“百钱百鸡”问题,百钱买百鸡,公鸡1个3块钱,母鸡1个2块钱，小鸡3个一块钱,问公鸡,母鸡,小鸡各多少个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int g = 0, m = 0, x = 0;//分别表示公鸡 母鸡 小鸡的个数

	for(g = 0; g < 33; g++)
	{
		for(m = 0; m < 50; m++)
		{
			for(x = 0; x < 100; x += 3)
			{
				if((g*3+m*2+x/3==100) && (g+m+x==100))
					printf("G:%d M:%d X:%d\n", g, m, x);
			}
		}
	}

	return 0;
}

随机函数

 rand();			//功能:就是用来产生随机数的
 rand() % 1000; 	//[0 ~ 999]
 rand() % 100 - 50;//[-50 ~ 49]
 
 srand();		//功能:可以保证每一次产生的随机数可变
 srand函数在调用时需要有可变的因子
 time(NULL);	//时间种子
 getpid();	//进程种子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
	int sum = 0;
	int i = 0;

	//srand(time(NULL));
	//注意:srand函数在程序中只能调用一次
	srand(getpid());

	for(i = 0; i < 5; i++)
	{
		sum = rand() % 100 - 50;
		printf("sum = %d\n", sum);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
	int T = 0;//存储随机出的数字
	int guess = 0;//存储玩家猜的数字
	int num = 1;

	srand(getpid());//随机种子
	
	T = rand() % 10;

	for(num = 1; ; num++)
	{
		scanf("%d", &guess);
		if(T > guess)
			printf("[%d]	Small!\n", num);
		else if(T < guess)
			printf("[%d]	Big!\n", num);
		else
		{
			printf("[%d]	Bingo!\n", num);
			break;
		}
	}

	return 0;
}

循环语句

 do...while循环
1.do while是C语言的关键字
2.do...while循环的使用方法
语句1
do
{
 要循环的语句
}while(循环条件);
语句2
3.do...while循环的执行流程

1
2
3
4
5
6


			|-------<---------<---------
			|							^
			V							|
语句1->要循环的语句->循环条件的判断(真)->
							|
							(假)->语句2

4.while循环与do...while循环的对比
 while : 先执行循环条件的判断,再执行循环的语句
 do...while : 先执行循环的语句,再执行循环条件的判断
 
 while : 可以一次也不执行循环的语句
 do...while : 至少会执行一次循环的语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 1;
	int sum = 0;

	while(i <= 100)
	{
		sum += i;
		i++;
	}

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;

	while(i < 4)
	{
		j = 0;
		while(j < 5)
		{
			printf("[%d %d]\n", i, j);
			j++;
		}
		i++;
	}

	return 0;
}

1
2
3
4
5
6
7
8


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{

	return 0;
}

跳转语句 : break continue goto return

1.break continue goto return都是C语言的关键字
2.break关键字
 break只能出现在循环结构或者switch语句中
 使用在循环结构中是用来跳出循环的
 使用在switch语句中是用来跳出switch
 如果break关键字出现在嵌套结构中,只作用于最近的那一层
3.continue关键字
 continue关键字只能出现在循环结构中
 使用在循环结构中跳过本次循环,继续下一次循环
4.return关键字
 return关键字一般来说出现在函数最后的位置
 当一个函数碰到return关键字,这个函数会结束,
 会把返回值返回给函数的调用者
 ------------------------------------------
 return返回的返回值有两种含义
 1)返回的是运算的结果
 2)返回的是函数运行的状态
 return 0;		代表函数运行正常
 return 正数;	代表函数运行有异常
 return 负数;	代表函数运行有错误
 ------------------------------------------
 注意 : return关键字一次只能返回一个值
5.goto关键字(太灵活了)
 可以轻易改变代码的结构
 语句1
标识符:
 语句2
 goto 标识符;
 语句3;
 标识符的命名要求和变量的命名要求一致
 (标识符可以和变量重名,但是不要这样使用)
 同一个标识符不能出现在多个位置
 goto不能跨函数使用
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	if(1)
	{
		break;
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;

	for(i = 0; i < 5; i++)
	{
		if(i == 2)
			//break;
			continue;
		printf("i = %d\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	if(!1)
	{
flag:
		printf("Hello World!\n");
	}
	else
	{
		printf("天气好热!\n");
		goto flag;
	}

	return 0;
}

03c_05day

Thu, 16 Feb 2023 08:03:05 +0800

03c_05day

===========================
2022-7-20
===========================

指针(point/pointer)
1.指针的含义
嵌入式开发工程师需要遵守的规则
谁打开，谁关闭	文件IO
谁开辟，谁释放	堆区空间 malloc
谁创建，谁销毁	链表
谁加锁，谁解锁	线程

 指针就是用来存储地址的
 变量是用来存储数据的(会存在内存中<以二进制补码形式>)
 指针是用来存储地址的(会存在内存中<以二进制补码形式>)
 虽然在内存中以二进制补码的形式存储地址，
 但是会以十六进制的方式展示给程序员
 注意 ：地址是没有负的(最小的地址0x00000000)
2.指针的定义
 定义变量	type name;
 定义指针	type * name；
 数据类型	指针名	；

1
2
3
4
5
6
7
8
9


char 		c		;
int 		i		;
floar		f		;
char *		pc		;
int *		pi		;
float *		pf		;

int * p				//定义了一个 int* 类型的指针p
int * p = &i;		//把int类型变量i的地址保存到指针p当中

3.通过sizeof了解指针的数据类型的特点
 无论何种类型的指针，在我当前的机器上
 打印出来的字节大小都是8个字节
 我当前机器的CPU是64bit的CPU，安装的是64bit的Ubuntu系统
 代表在我当前的机器中一个地址长度就是64bit
 指针是用来存储地址的，所以指针应当能够存储64bit的地址
 所以无论体积类型在我当前机器上都是8个字节
4.指针的命名规则和变量的命名规则一致
5.指针运算符
 &	取地址的运算符(用来取地址的)
 可以使用在变量\指针\数组成员
 *	取值的运算符(用来取值的)
 可以使用在地址
6.指针的赋值
 变量名	=	数值	；

1
2
3
4
5
6


c		=	'A'		;
i		=	9527	;
f		=	3.14	;
pc		=	&c		;
pi		=	&i		;
pf		=	&f		;

7.指针的初始化

1
2
3
4
5
6
7
8
9


char	c	=	'A'	;
int 	i	=	100	;
float	f	=	3.14;

数据类型	指针名	=	地址	；
char *		pc		=	&c		;
int	*		pi		=	&i		;
float *		pf		=	&f		;
int	*		p		=	NULL	;

注意 ：如果初始化指针时，不确定指针指向哪个空间，
 可以先将指针指向NULL(空)
 NULL代表的就是空的意思，在ASCII表中表示的就是0x0
 (其实就相当于给指针赋了一个地址0x0)
8.指针的定义和指针的初始化的区别(和变量的内容一样)
9.指针的使用
 1>指针在使用时应当先定义再使用
 2>指针应该保存相应数据类型变量的地址
 int *类型的指针保存 int类型变量地址
 char *类型的指针 保存 char类型变量地址
 float *类型的指针 保存 float类型变量地址
 3>指针可以做加减法运算(自增自减运算)
 int *P;
 p + 1; p += 1; P++; ++p;
 注意 ：不同类型的指针，在做加减法运算时，
 所偏移的字节数是不同的，
 和指针本身要保存的变量的数据类型有关
 例子：
 int *pi;//指针保存的地址是0x1000
 pi++;
 printf ("pi");//0x11004
10.特殊的指针
 1>空类型的指针(万能指针)
 void *p;
 空类型的指针可以保存任意类型的地址，所以叫做万能指针
 会在指针的强制类型转换时使用
 2>空指针(指向NULL的指针)
 在C语言中，不允许访问地址为NULL的存储空间，
 因为该空间是系统保留的，所以不允许访问
 操作空指针，程序在执行时会报段错误
 3>野指针(没有对象的指针)
 野指针指向一个已经删除或者已释放的空间
 与空指针不同，没有办法通过简单的判断避免使用野指针
 只能通过养成良好的编程习惯来尽力减少
 可以主动的把已删除或者已释放的指针变为空指针
 再去判断空指针即可
 --------------------------------------------------------
 在操作指针时，可以使用一些方法，避免使用空指针
 可以加入判断
 if(p == NULL)//if(NULL == p)
 printf ("指针p是一个空指针!\n");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 1;
	int sum = 0;

loop:
	if(i <= 100)
	{
		sum += i++;
		goto loop;
	}

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	printf("sizeof(char *) = %ld\n", sizeof(char *));
	printf("sizeof(short *) = %ld\n", sizeof(short *));
	printf("sizeof(int *) = %ld\n", sizeof(int *));
	printf("sizeof(long *) = %ld\n", sizeof(long *));
	printf("sizeof(float *) = %ld\n", sizeof(float *));
	printf("sizeof(double *) = %ld\n", sizeof(double *));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;

	printf("i = %d &i = %p\n", i, &i);

	i = 13;

	printf("i = %d &i = %p\n", i, &i);

	return 0;
}

![06point](https://s2.loli.net/2022/08/16/7unBeUcYKkm3zog.png)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;

	printf("i = %d &i = %p\n", i, &i);

	i = 13;

	printf("i = %d &i = %p\n", i, &i);

	//printf("*(&i) = %d\n", *(&i));//可以使用
	printf("&(*i) = %d\n", &(*i));//不能使用

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;
	int *p = &i;//把int类型变量i的地址保存到指针p当中
	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);
	i = 13;
	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	//printf("*(&i) = %d\n", *(&i));//可以使用
	//printf("&(*i) = %d\n", &(*i));//不能使用

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;
	int *p = &i;//把int类型变量i的地址保存到指针p当中
	
	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);
	
	//*p = 9527;
	scanf("%d", p);

	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	//printf("*(&i) = %d\n", *(&i));//可以使用
	//printf("&(*i) = %d\n", &(*i));//不能使用

	return 0;
}

![09point](https://s2.loli.net/2022/08/16/CasOxBrYX1wSuvm.png)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int *p = 0x12345678;

	printf("p = %p *p = %d\n", p, *p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char *pc;
	short *ps;
	int *pi;
	long *pl;
	float *pf;
	double *pd;

	printf("sizeof(pc) = %ld sizeof(*pc) = %ld\n", sizeof(pc), sizeof(*pc));
	printf("sizeof(ps) = %ld sizeof(*ps) = %ld\n", sizeof(ps), sizeof(*ps));
	printf("sizeof(pi) = %ld sizeof(*pi) = %ld\n", sizeof(pi), sizeof(*pi));
	printf("sizeof(pl) = %ld sizeof(*pl) = %ld\n", sizeof(pl), sizeof(*pl));
	printf("sizeof(pf) = %ld sizeof(*pf) = %ld\n", sizeof(pf), sizeof(*pf));
	printf("sizeof(pd) = %ld sizeof(*pd) = %ld\n", sizeof(pd), sizeof(*pd));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 9527;
	char *p = &i;

	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	short i = 100;
	short *p = &i;

	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	++p;//p++;//p+=1;

	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char c = 0;
	short s = 0;
	int i = 0;
	long l = 0;
	float f = 0;
	double d = 0;
	void *p;
	
	p = &c;
	p = &s;
	p = &i;
	p = &l;
	p = &f;
	p = &d;

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 100;
	void *p = &i;

	printf("p = %p\n", p);
	printf("*p = %d\n", *p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int *p = NULL;

	*p = 100;

	printf("*p = %d\n", *p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int *p = NULL;
	
	p = malloc(sizeof(int));
	*p = 100;
	printf("free之前*p = %d\n", *p);
	printf("free之前p = %p\n", p);
	free(p);
	p = NULL;//把野指针变为了空指针
	printf("free之后*p = %d\n", *p);
	printf("free之后p = %p\n", p);

	*p = 9527;//使用野指针
	
	printf("free之后*p = %d\n", *p);
	printf("free之后p = %p\n", p);

	return 0;
}

03c_06day

Thu, 16 Feb 2023 08:03:05 +0800

03c_06day

===========================
2022-7-21
===========================

一.温故知新	
 指针
 malloc
 指针的含义 : 指针就是用来存储地址
 NULL
 指针的定义 : 数据类型	指针名	;
 char *		pc		;
 char *		pi		;
 float *	pf		;

指针

 通过sizeof测试
 指针的命名规则和变量的命名规则一致
 int i = 0;
 int *p;

 p = &i;
 *p
 指针运算符
 数据类型	指针名	=	地址	;
 int *		p		=	NULL	;
 int *p;	->	int
 char *p;	->	char
 指针可以做加减法运算
 p+1;	p+=1;	p++;	++p;
 特殊指针
 空类型指针(万能指针)
 空指针
 野指针

 容易混淆的声明
 const	指针
 指针常量
 常量指针
 数组	函数
 指针数组
 数组指针
 指针函数
 函数指针
 函数指针数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int add(int a, int b);//函数的声明

int add(int a, int b)//函数的实现
{
	return a + b;
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;
	int sum = 0;

	scanf("%d-%d", &a, &b);

	sum = add(a, b);//函数的调用

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

int max(int , int );//函数的声明

int max(int x, int y)//函数的实现
{
	//x > y ? return x : return y;
	return x > y ? x : y;
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;
	int sum = 0;

	scanf("%d-%d", &a, &b);

	sum = max(a, b);//函数的调用

	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

int isleapyear(int );//函数的声明

int isleapyear(int abc)//函数的实现
{
	return (!(abc%4)&&(abc%100)) || (!(abc%400));
}

int main(int argc, char *argv[])
{
	int year = 0;
	int sum = 0;

	scanf("%d", &year);

	sum = isleapyear(year);//函数的调用
	//如果sum = 1代表是闰年 如果sum = 0代表是平年
	
	sum == 1 ? printf("%d年是闰年!\n", year) : printf("%d年是平年!\n", year);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <stdio.h>
#include <stdlib.h>

void func(int ,int);

void func(int a, int b)
{
	int min = 0, max = 0;
	int i = 0, j = 0;

	min = a < b ? a : b;
	max = a > b ? a : b;

	for(i = min; i <= max; i++)
	{
		for(j = 2; j < i; j++)
		{
			if(i % j == 0)
				break;
		}
		if(i == j)
			printf("%d\t", i);
	}
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);

	func(a, b);//函数的调用
	//func()的功能是寻找最小值 - 最大值之间的素数

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <stdio.h>
#include <stdlib.h>

void swap(int ,int);

void swap(int a, int b)
{
	int tmp = 0;

	printf("swap.交换之前a = %d b = %d\n", a, b);
	printf("swap.交换之前a = %p b = %p\n", &a, &b);
	tmp = a;
	a = b;
	b = tmp;
	printf("swap.交换之后a = %d b = %d\n", a, b);
	printf("swap.交换之后a = %p b = %p\n", &a, &b);
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);
	
	printf("main.交换之前a = %d b = %d\n", a, b);
	printf("main.交换之前a = %p b = %p\n", &a, &b);
	
	swap(a, b);//通过swap()交换变量a b的值
	
	printf("main.交换之后a = %d b = %d\n", a, b);
	printf("main.交换之后a = %p b = %p\n", &a, &b);

	return 0;
}

交换变量值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>
#include <stdlib.h>

void swap(int *, int*);

void swap(int *a, int *b)
{
	int tmp = 0;

	tmp = *a;
	*a = *b;
	*b = tmp;
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);
	
	printf("main.交换之前a = %d b = %d\n", a, b);
	
	swap(&a, &b);//通过swap()交换变量a b的值
	
	printf("main.交换之后a = %d b = %d\n", a, b);

	return 0;
}

程序员写C语言程序会经历几个阶段
第一阶段	只写一个.c文件,在.c文件中只写一个main函数
 把所有的功能都放到main函数中
第二阶段	只写一个.c文件,在.c文件中除了有main函数以外
 还会有其他的功能函数的封装
第三阶段	在一个项目工程中存在多个.c或者.h文件
 main.c		存放main函数以及功能函数的调用
 func.c		存放功能函数的实现
 func.h		存放功能函数的声明以及各种定义
 makefile	是一个脚本文件(存放的是编译规则)
第四阶段	把func.c制作成库文件
 动态库和静态库

函数
当写一个C语言程序时,首先需要写的一个函数就是main函数
1.函数的含义
 函数就是一个功能,当调用函数时,会使用这个功能
 printf()	->	打印输出
 scanf()		->	录入
 rand()		->	用来产生随机数
 srand()		->	随机种子
 time()		->	获取时间的描述
 getpid()	->	获取进程ID号
 sleep()		->	秒级延时
 usleep()	->	微秒级延时
 system()	->	调用shell命令
 函数的出现是为了减少代码量,减少代码的冗余
 例子 : printf函数的代码量有100行左右
 如何把一部分的代码封装成一个函数,其实是由程序员决定的
 通过是根据每个函数执行一个特定的功能来进行划分的
2.函数组成部分
 一般来说函数是由三个部分组成的
 1)函数的声明(函数的定义)
 其实就是告诉编译器,函数的名称,函数的返回值
 以及函数的参数
函数的返回值类型 函数名(参数列表);//该处参数指的是形式参数
函数的返回值类型 函数名	(参数列表);
char *			 strcpy (char *dest, const char *src);
void *			 malloc (size_t size);
int				 rand	(void);
void			 srand	(unsigned int seed);
注意 : 
 1>函数名的命名规则和变量的命名规则一致
 2>在写函数的声明时,可以不指定形式参数的名字,
 但是必须要有形式参数的数据类型
 2)函数的实现
 其实就是把函数所代表的功能通过代码进行实现
函数的返回值类型 函数名(参数列表)//该处参数指的是形式参数
{
 功能实现的代码
}
 注意 : 
 1>在写函数的实现时,必须要指定形式参数的名字
 3)函数的调用
 其实就是在代码中使用函数实现的功能
函数名(参数);//该处参数指的是实际参数
形式参数和实际参数是两个不同的内容,可以同名
其实是形式参数来接收实际参数的值的
3.函数的传参
 值传递	: 是把实际参数的值传递给形式参数
 在这种情况下修改形式参数的值不会影响实际参数
 总结: 如果只是想要访问实际参数的值,
 不想修改实际参数的值,那么就使用值传递
 add(); max(); isleapyear(); printf();

 地址传递: 是把实际参数的地址传递给形式参数(指针)
 如果通过形式参数修改指向空间的数据
 会改变实际参数的值
 总结: 如果想要通过形式参数修改实际参数的值
 那么就用地址传递
 swap(); scanf();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>
#include <stdlib.h>

void print(int);
void change(int *);

void print(int a)
{
	printf("a = %d\n", a);
}

void change(int *a)
{
	scanf("%d", a);
}

int main(int argc, char *argv[])
{
	int a = 9527;

	print(a);//通过print函数打印变量a的值

	change(&a);//通过change函数改变a的值
	
	print(a);//通过print函数打印变量a的值

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 9527;
	int *p = &i;

	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	printf("sizeof(char **) = %ld\n",sizeof(char **));
	printf("sizeof(short **) = %ld\n",sizeof(short **));
	printf("sizeof(int **) = %ld\n",sizeof(int **));
	printf("sizeof(long **) = %ld\n",sizeof(long **));
	printf("sizeof(float **) = %ld\n",sizeof(float **));
	printf("sizeof(double **) = %ld\n",sizeof(double **));

	return 0;
}

/*
===========================
作业:
1.把今天讲过的内容完完整整的复习一遍
2.最少把<猜数游戏>和<口算卡>改为多函数的版本
===========================
二级指针
1.二级指针的含义
只要是指针,那就是用来存储地址的
一级指针是用来保存变量的地址的
 (可以使用一级指针操控变量)
二级指针是用来保存一级指针的地址的
 (可以使用二级指针操控一级指针)
2.二级指针的定义
 int			i		;
 数据类型	指针名	;
 int *		p		;
 int **		pp		;
3.通过sizeof测试占用存储空间的大小
 无论何种类型的二级指针在我当前的机器环境中,
 占用空间大小都是8个字节
4.二级指针的命名规则和变量的命名规则一致
5.使用二级指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


名	i		p		pp

值	100		0x1000	0x2000
	i		p		pp
	*p		*pp
	**pp
址	0x1000	0x2000	0x3000
	&i		&p		&pp
	p		pp
	*pp

*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 100;
	int *p = &i;
	int **pp = &p;

	printf("i = %d\n", i);
	printf("*p = %d\n", *p);
	printf("**pp = %d\n", **pp);
	printf("====================\n");
	printf("&i = %p\n", &i);
	printf("p = %p\n", p);
	printf("*pp = %p\n", *pp);
	printf("====================\n");
	printf("&p = %p\n", &p);
	printf("pp = %p\n", pp);
	printf("====================\n");
	printf("&pp = %p\n", &pp);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 100;
	int *p = &i;
	int **pp = &p;
	
	printf("&p = %p\n", &p);
	printf("pp = %p\n", pp);
	
	pp++;

	printf("&p = %p\n", &p);
	printf("pp = %p\n", pp);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

void change(int **, int *);

void change(int **p, int *b)
{
	*p = b;
}

int main(int argc, char *argv[])
{
	int a = 100, b = 200;
	int *p = &a;

	printf("*p = %d p = %p\n", *p, p);
	
	//change(p, &b);
	change(&p, &b);//通过change函数把指针p指向b变量
	
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}

随机函数
 rand();			//功能:就是用来产生随机数的
 rand() % 1000; 	//[0 ~ 999]
 rand() % 100 - 50;//[-50 ~ 49]
 
 srand();		//功能:可以保证每一次产生的随机数可变
 srand函数在调用时需要有可变的因子
 time(NULL);	//时间种子
 getpid();	//进程种子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

void func(void);

void func(void)
{
	int T = 0;//存储随机出的数字
	int guess = 0;//存储玩家猜的数字
	int num = 1;

	srand(getpid());//随机种子
	
	T = rand() % 10;

	for(num = 1; ; num++)
	{
		scanf("%d", &guess);
		if(T > guess)
			printf("[%d]	Small!\n", num);
		else if(T < guess)
			printf("[%d]	Big!\n", num);
		else
		{
			printf("[%d]	Bingo!\n", num);
			break;
		}
	}
}

int main(int argc, char *argv[])
{
	func();

	return 0;
}

03c_07day

Thu, 16 Feb 2023 08:03:05 +0800

03c_07day

==========================
2022-7-22
==========================

一.温故知新

 函数 : 就是一个功能
 函数的声明
函数的返回值类型 函数名(参数列表);//形式参数
 函数的实现
函数的返回值类型 函数名(参数列表)//形式参数
{
 功能的实现
}
 函数的调用
函数名(参数);//实际参数

值传递	:

地址传递:

 二级指针
 用来保存一级指针的地址
 可以通过二级指针操控一级指针
 type **	pointer_name;
 int **pp;->pp++->偏移量和int *
 char **pp;->pp++->偏移量和char *

数组(arr/array)

1.什么是数组?
 相同类型变量的集合
 数组是由一个一个成员组成,每个成员的数据类型都是相同的
2.数组的含义
 数组就是用来存储一组相同类型的数据的
3.数组的定义
 数据类型	数组名	[成员个数]	;
 int			arr		[5]			;
 char		brr		[20]		;
 float		crr		[3]			;
 1)数组的定义中数据类型->指的是数组的每个成员的类型
 2)数组名的命名规则和变量的命名规则一致
 3)成员个数->就是数组的成员个数
 注意 : 成员个数必须是一个非负的整数
4.访问数组成员的方法
 例子 : int arr[5];//定义了有5个int类型成员的数组arr
 int *p = arr;
 1)数组名 + 下标//在访问成员时下标从0开始计数
 arr[0] arr[1] arr[2] arr[3] arr[4]
 注意 : 没有arr[5]这个成员,如果强行使用arr[5]成员,
 会造成数组越界
 2)数组名 + 偏移量
 *(arr+0) *(arr+1) *(arr+2) *(arr+3) *(arr+4)
 3)指针 + 偏移量
 *(p + 0) *(p + 1) *(p + 2) *(p + 3) *(p + 4)
 4)指针 + 下标
 p[0] p[1] p[2] p[3] p[4]
5.数组的特性
 1)通过sizeof运算符查看数组特性
 sizeof(数组名) = 整个数组的大小
 sizeof(成员) = 一个成员的大小
 sizeof(数组名) / sizeof(成员) = 成员个数
 2)数组中成员的地址都是连续的
 可以通过某个成员的地址进行地址偏移
 找到其他成员的位置
 3)一维数组的数组名表示的是数组首成员的地址
6.数组的初始化
 数据类型	数组名	[成员个数]	=	{数值,数值};
 int			arr		[3]			=	{0,1,2];
 int			arr		[3]			=	{0};
 //会把数组的所有成员初始化成0
 int			arr		[3]			=	{11};
 //会把首成员初始化成11,其他成员初始化成0
 ================================================
 int			arr		[]			=	{11,22,33,44};
 //会把后边数值的个数当作成员个数使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5];

	arr[0] = 100;
	arr[1] = 9527;
	arr[2] = -1;
	arr[3] = 123;
	arr[4] = 10086;

	printf("arr[0] = %d\n", arr[0]);
	printf("arr[1] = %d\n", arr[1]);
	printf("arr[2] = %d\n", arr[2]);
	printf("arr[3] = %d\n", arr[3]);
	printf("arr[4] = %d\n", arr[4]);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	//int arr[5];可以
	//int arr[0];可以
	//int arr[-1];不可以
	//int arr[3.14];不可以
	//int arr['A'];可以
	int i = 5;
	int arr[i];

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5];
	int i = 0;

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

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5];
	int i = 0;

	for(i = 0; i < 5; i++)
	{
		scanf("%d", &arr[i]);
	}

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

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5];
	int i = 0;

	printf("sizeof(arr[0]) = %ld\n", sizeof(arr[0]));
	printf("sizeof(arr) = %ld\n", sizeof(arr));


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

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[10];
	int i = 0;

	for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		scanf("%d", &arr[i]);
	}

	for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("arr[%d] = %d\n", i, arr[i]);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 10;
	int arr[5] = {i};
	
	printf("arr[0] = %d\n", arr[0]);
	printf("arr[1] = %d\n", arr[1]);
	printf("arr[2] = %d\n", arr[2]);
	printf("arr[3] = %d\n", arr[3]);
	printf("arr[4] = %d\n", arr[4]);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0;
	int arr[5] = {0};

	for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("arr[%d] = %p\n", i, &arr[i]);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5] = {0};

	printf("arr[0] = %p\n", &arr[0]);
		//表示的是数组首成员的地址
	printf("arr = %p\n", arr);
		//表示的是数组首成员的地址
	printf("&arr = %p\n", &arr);
		//表示的是整个数组的地址
	printf("===========================\n");
	printf("arr[0] + 1 = %p\n", &arr[0] + 1);
	printf("arr + 1 = %p\n", arr + 1);
	printf("&arr + 1 = %p\n", &arr + 1);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5] = {11,22,33,44,55};
	int i = 0;

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

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5] = {11,22,33,44,55};

	printf("arr = %p\n", arr);

	arr += 1;
	//arr++;

	printf("arr = %p\n", arr);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5] = {11,22,33,44,55};
	int i = 0;
	int *p = arr;
	
	//p = &arr[0];//把数组首成员的地址赋值给指针p
	p = arr;//把数组首成员的地址赋值给指针p

	for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		//printf("arr[%d] = %d\n", i, arr[i]);
		//printf("*(arr + %d) = %d\n", i, *(arr + i));
		//printf("*(p + %d) = %d\n", i, *(p + i));
		//printf("p[%d] = %d\n", i, p[i]);
		printf("%d[arr] = %d\n", i, i[arr]);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[5] = {11,22,33,44,55};
	int *p = arr;
	
	/*
		sizeof(arr) / sizeof(arr[0]) = 5
		sizeof(arr) / sizeof(*arr) = 5
		sizeof(p) / sizeof(*p) = 2
		sizeof(p) / sizeof(p[0]) = 2
	*/

	return 0;
}

数组和函数

1.当多函数程序需要使用数组传参时,
 无论是否需要修改数组成员的值,在函数调用时都传数组名
2.如果功能函数并不想修改实参数组成员的值,
 可以在形参前加const关键字修饰一下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <stdio.h>
#include <stdlib.h>

void print(const int *p, int size);
void change(int *p, int size);

void print(const int *p, int size)
{
	int i = 0;

	for(i = 0; i < size; i++)
		printf("p[%d] = %d\n", i, p[i]);
}

void change(int *p, int size)
{
	int i = 0;

	for(i = 0; i < size; i++)
		scanf("%d", p + i);//&p[i]
}

int main(int argc, char *argv[])
{
	int arr[5] = {11,22,33,44,55};
	int size = sizeof(arr) / sizeof(arr[0]);

	print(arr, size);//通过print函数遍历数组的成员
	
	change(arr, size);//通过change函数改变数组成员的值
	
	print(arr, size);//通过print函数遍历数组的成员

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <stdio.h>
#include <stdlib.h>

int *func(void);

int *func(void)
{
	int arr[5] = {11,22,33,44,55};//局部数组

	return arr;
}

int main(int argc, char *argv[])
{
	int *p = NULL;
	int i = 0;

	p = func();

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

	return 0;
}

03c_08day

Thu, 16 Feb 2023 08:03:05 +0800

03c_08day

===========================
2022-7-25
===========================

一.温故知新

 数组
线性的存储
 线性表
 顺序表
 数组
 一维数组
1.数组
 1)数组的含义
 数组就是用来存储一组相同类型的数据
 2)数组的定义
 数据类型 数组名[成员个数];
 int		 arr	[10]	 ;
 定义了10个int类型成员的数组
 arr[0] - arr[9]
 3)访问数组的成员
 数组名 + 下标		arr[3];
 数组名 + 偏移量		*(arr+3);
 指针 + 偏移量		*(p + 3);
 指针 + 下标			p[3];
 4)数组的特性
 sizeof(数组名) = 整个数组的大小
 sizeof(成员) = 一个成员的大小
 sizeof(数组名) / sizeof(成员) = 成员个数
 打印地址
 数组的成员占用了连续的存储空间
 一维数组的数组名相当于是数组首成员的地址
 C语言的第一阶段过渡到第二阶段
 多维数组
 二维数组

二维数组

 链表
 有头/无头(头节点<无实质数据>)
 循环/不循环
 单向/双向
 两种特殊的存储形式
 栈式存储结构	先进后出
 队列式存储结构	先进先出

小项目:五子棋
 1.player VS player
要求
 1>最少完成p v p版本
 2>用多函数实现
 3>完成五子棋最基本功能即可
 4>要有适当的提示信息
 5>代码中要有注释
 6>以组为单位交付
提示
 1>棋盘存储
 2>坐标的打印
 3>玩家的替换
 4>下到重复位置/下出边界以后的处理
 5>判断赢的条件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


#include <stdio.h>
#include <stdlib.h>

void draw(int arr[15][15])
{
	int i = 0, j = 0;

	printf(" 1 2 3 4 5 6 7 8 9 A B C D E F\n");
	for(i = 0; i < 15; i++)
	{
		printf("%X ", i + 1);
		for(j = 0; j < 15; j++)
		{
			switch(arr[i][j])
			{
				case 0 : printf("+ "); break;
				case 1 : printf("O "); break;
				case 2 : printf("X "); break;
			}
		}
		printf("\n");
	}
}

int main(int argc, char *argv[])
{
	//二维数组中 成员=0 该处无棋子 
	//成员=1 玩家1下棋 
	//成员=2 玩家2下棋
	int arr[15][15] = {0};//定义二维数组初始化成0
	int x = 0, y = 0;//下棋子的坐标
	int flag = 1;//标记玩家

	do
	{
		draw(arr);//通过draw函数画棋盘
		printf("Player %d > ", flag);
		scanf("%d-%d", &x, &y);
		//做判断x 和 y的位置是否合理
		arr[x - 1][y - 1] = flag;
		flag ^= 3;
	}while(win());
	return 0;
}

多维数组和二维数组的关系

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216


#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
	int arr[7][4][4][4] = {
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,0,0},
						{1,1,1,1}
						},
						{
						{0,0,0,1},
						{0,0,0,1},
						{0,0,0,1},
						{0,0,0,1}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,0,0},
						{1,1,1,1}
						},
						{
						{0,0,0,1},
						{0,0,0,1},
						{0,0,0,1},
						{0,0,0,1}
						}
						},
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,1,0,0},
						{0,1,1,1}
						},
						{
						{0,0,0,0},
						{0,0,1,1},
						{0,0,1,0},
						{0,0,1,0}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,1,1,1},
						{0,0,0,1}
						},
						{
						{0,0,0,0},
						{0,0,0,1},
						{0,0,0,1},
						{0,0,1,1}
						}
						},
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,0},
						{0,1,1,1}
						},
						{
						{0,0,0,0},
						{0,0,1,0},
						{0,0,1,1},
						{0,0,1,0}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,1,1,1},
						{0,0,1,0}
						},
						{
						{0,0,0,0},
						{0,0,0,1},
						{0,0,1,1},
						{0,0,0,1}
						}
						},
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,0,1},
						{0,1,1,1}
						},
						{
						{0,0,0,0},
						{0,0,1,0},
						{0,0,1,0},
						{0,0,1,1}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,1,1,1},
						{0,1,0,0}
						},
						{
						{0,0,0,0},
						{0,0,1,1},
						{0,0,0,1},
						{0,0,0,1}
						}
						},
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,1,1,0},
						{0,0,1,1}
						},
						{
						{0,0,0,0},
						{0,0,0,1},
						{0,0,1,1},
						{0,0,1,0}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,1,1,0},
						{0,0,1,1}
						},
						{
						{0,0,0,0},
						{0,0,0,1},
						{0,0,1,1},
						{0,0,1,0}
						}
						},
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,1},
						{0,0,1,1}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,1},
						{0,0,1,1}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,1},
						{0,0,1,1}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,1},
						{0,0,1,1}
						}
						},
						{
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,1},
						{0,1,1,0}
						},
						{
						{0,0,0,0},
						{0,0,1,0},
						{0,0,1,1},
						{0,0,0,1}
						},
						{
						{0,0,0,0},
						{0,0,0,0},
						{0,0,1,1},
						{0,1,1,0}
						},
						{
						{0,0,0,0},
						{0,0,1,0},
						{0,0,1,1},
						{0,0,0,1}
						}
						}
					};
	int i = 0, j = 0, x = 0, y = 0;
	
	srand(getpid());

	while(1)
	{
		x = rand() % 7;
		y = rand() % 4;
		system("clear");
		for(i = 0; i < 4; i++)
		{
			for(j = 0; j < 4; j++)
			{
				if(arr[x][y][i][j] == 1)
					printf("[]");
				else
					printf(" ");
			}
			printf("\n");
		}
		sleep(1);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#	二维数组
	1.二维数组的含义
		是用来存储相同类型的数据的
		可以抽象出行和列的存储形式,适合存储矩阵的数据
	2.二维数组的定义
		数据类型	数组名	[行数]	[列数]	;
		char		arr		[2]		[3]		;
		int 		arr		[3]		[4]		;
		float		arr		[4]		[2]		;
		无论是行数还是列数都是从0开始计数的
		arr[0][0] arr[0][1] arr[0][2] arr[0][3]
		arr[1][0] arr[1][1] arr[1][2] arr[1][3]
		arr[2][0] arr[2][1] arr[2][2] arr[2][3]
	3.访问二维数组成员的方法
		1)数组名 + 下标
		2)数组名 + 偏移量
		二级指针不能和二维数组产生关联(类型不匹配)
		需要使用数组指针和二维数组产生关联
	4.二维数组的特性
		1)通过sizeof运算符进行测试
			int arr[2][3];
			sizeof(arr) = 24 = 整个数组的大小
			sizeof(arr[0]) = 12 = 一行的大小
			sizeof(arr[0][0]) = 4 = 一个成员的大小
			sizeof(arr) / sizeof(arr[0][0]) = 6 = 成员个数
			sizeof(arr) / sizeof(arr[0]) = 2 = 行数
			sizeof(arr[0] / sizeof(arr[0][0])) = 3 = 列数
		2)虽然二维数组可以抽象出行和列的形式,
			但是二维数组中的每个成员的地址都是连续的
		3)二维数组的数组名表示的数组首行的地址
	5.二维数组的初始化
		数据类型	数组名	[行数][列数] = {数值,数值};
		int arr[2][3] = {0};//所有成员都初始化为0
		int arr[2][3] = {11,22,33,44,55,66};
			//每个成员获取一个数值
		int arr[2][3] = {{11,22,33},{44,55,66}};
		===============================================
		int arr[][3] = {11,22,33,44,55,66};
		注意 : 二维数组特殊的初始化方式,可以不指定行数
				但是列数必须要指定
	*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <stdio.h>
#include <stdlib.h>

void print(int arr[2][3]);
void change(int arr[][3]);

void print(int arr[2][3])
{
	int i = 0, j = 0;

	//for(i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)

	for(i = 0; i < 2; i++)
	{
		for(j = 0; j < 3; j++)
		{
			printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
		}
	}
}
void change(int arr[][3])
{
	int i = 0, j = 0;

	for(i = 0; i < 2; i++)
	{
		for(j = 0; j < 3; j++)
		{
			scanf("%d", &arr[i][j]);
		}
	}
}

int main(int argc, char *argv[])
{
	int arr[2][3] = {11,22,33,44,55,66};

	print(arr);//通过print函数遍历二维数组
	change(arr);//通过change函数改变二维数组的数据
	print(arr);//通过print函数遍历二维数组

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;
	int num = 1;
	int arr[3][4];
	int **pp = arr;

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
			arr[i][j] = num++;
		}
	}

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
		}
	}

	return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;
	int num = 1;
	int arr[3][4];
	int **pp = arr;

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
			arr[i][j] = num++;
		}
	}

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;
	int num = 1;
	int arr[3][4];
	
	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
			arr[i][j] = num++;
		}
	}

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[3][4];
	
	printf("&arr[0][0] = %p\n", &arr[0][0]);
		//表示的是数组首成员的地址
	printf("&arr[0] = %p\n", &arr[0]);
		//表示的是数组首行的地址
	printf("arr[0] = %p\n", arr[0]);
		//表示的是数组首成员的地址
	printf("arr = %p\n", arr);
		//表示的是数组首行的地址
	printf("&arr = %p\n", &arr);
		//表示的是整个数组的地址
	printf("*arr = %p\n", *arr);
	printf("========================\n");
	printf("&arr[0][0] + 1 = %p\n", &arr[0][0] + 1);
	printf("&arr[0] + 1 = %p\n", &arr[0] + 1);
	printf("arr[0] + 1 = %p\n", arr[0] + 1);
	printf("arr + 1 = %p\n", arr + 1);
	printf("&arr + 1 = %p\n", &arr + 1);
	printf("*arr + 1 = %p\n", *arr + 1);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[3][4];
	int i = 0, j = 0;

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
			printf("&arr[%d][%d] = %p\n", i,j,&arr[i][j]);
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[3][4];

	printf("sizeof(arr[0][0]) = %ld\n",sizeof(arr[0][0]));
	printf("sizeof(arr[0]) = %ld\n",sizeof(arr[0]));
	printf("sizeof(arr) = %ld\n",sizeof(arr));


	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int i = 0, j = 0;
	int num = 1;
	int arr[3][4];

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
			arr[i][j] = num++;
		}
	}
	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
			printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
		}
	}

	return 0;
}

输入十个人的身高,要求排序,从低到高打印
 排序		(选择法排序)
首先从未排序的成员中找到最值
然后和数组开头的成员进行交换
然后再从剩余的未排序的成员中找到最值
然后再和剩余成员的开头位置进行交换
以此类推
=============================
把冒泡法排序和选择法排序给组长讲一遍
(以讲懂了为标准)
=============================

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


#include <stdio.h>
#include <stdlib.h>

void print(const int *arr, int size);
void sort(int *arr, int size);

void print(const int *arr, int size)
{
	int i = 0;

	for(i = 0; i < size; i++)
		printf("%d\t", arr[i]);
	printf("\n");
	getchar();
}

void sort(int *arr, int size)
{
	int i = 0, j = 0, k = 0;
	int tmp = 0;

	for(i = 0; i < size - 1; i++)
	{
		k = i;//让k和i标记相同的位置
		for(j = i + 1; j < size; j++)
		{
			if(arr[k] > arr[j])
				k = j;//让k标记j的位置
		}
		if(i != k)//判断i和k是否标记相同的位置
		{
			tmp = arr[i];
			arr[i] = arr[k];
			arr[k] = tmp;
			print(arr, size);
		}
	}
}

int main(int argc, char *argv[])
{
	int arr[5] = {100, 201, 50, 70, 30};
	int size = sizeof(arr) / sizeof(*arr);

	print(arr, size);//通过print函数遍历数组
	
	sort(arr, size);//通过sort函数进行从小到大的排序
	
	print(arr, size);//通过print函数遍历数组

	return 0;
}

输入十个人的身高,要求排序,从低到高打印
 排序		(冒泡法排序)
比较两个相邻的成员,如果不满足大小顺序,当即完成交换操作
按照遍历顺序把第一对相邻的成员到
最后一对相邻的成员都完成对比
这样数组中的最值就冒到了最后的位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <stdio.h>
#include <stdlib.h>

void print(const int *arr, int size);
void sort(int *arr, int size);

void print(const int *arr, int size)
{
	int i = 0;

	for(i = 0; i < size; i++)
		printf("%d\t", arr[i]);
	printf("\n");
	getchar();
}

void sort(int *arr, int size)
{
	int i = 0, j = 0;
	int tmp = 0;

	for(i = 0; i < size - 1; i++)
	{
		for(j = 0; j < size - 1 - i; j++)
		{
			if(arr[j] > arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				print(arr, size);
			}
		}
	}
}

int main(int argc, char *argv[])
{
	int arr[5] = {100, 201, 50, 70, 30};
	int size = sizeof(arr) / sizeof(*arr);

	print(arr, size);//通过print函数遍历数组
	
	sort(arr, size);//通过sort函数进行从小到大的排序
	
	print(arr, size);//通过print函数遍历数组

	return 0;
}

有1000发子弹,要提前装到10个箱子里面，接收键盘输入，要取多少颗子弹数，只能显示整箱的个数，问这10个箱子怎么装,编程实现
二进制		100
逐次趋近式的方法
arr[0] = 1
arr[1] = 2
arr[2] = 4
arr[3] = 8
arr[4] = 16
arr[5] = 32
arr[6] = 64
arr[7] = 128
arr[8] = 256
arr[9] = 489

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


#include <stdio.h>
#include <stdlib.h>

void init(int *, int);
void print(int *, int);
void take_out(int , int *, int);

void init(int *arr, int size)
{
	int i = 0;
	int sum = 1;
	int x = 0;

	for(i = 0; i < size - 1; i++)
	{
		arr[i] = sum;
		x += sum;
		sum *= 2;
	}
	arr[i] = 1000 - x;
}

void print(int *arr, int size)
{
	int i = 0;

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

void take_out(int num, int *arr, int size)
{
	int i = 0;

	for(i = size - 1; i >= 0; i--)
	{
		if(arr[i] <= num)
		{
			printf("arr[%d] = %d\n", i, arr[i]);
			num -= arr[i];
		}
	}
}

int main(int argc, char *argv[])
{
	int arr[10] = {0};//存子弹
	int size = sizeof(arr) / sizeof(arr[0]);//存储成员个数
	int num = 0;//存储要取走的子弹数

	init(arr, size);//通过init函数存储子弹

	print(arr, size);//通过print函数遍历数组

	scanf("%d", &num);//录入取走的子弹数

	take_out(num, arr, size);//取子弹

	return 0;
}

进制转换的计算器
完成itob函数(十->八)
十 -> 二
void itob(int num, int arr[8], int size);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <stdio.h>
#include <stdlib.h>

void itob(int num, int *arr, int size);
void print(int *arr, int size);

void itob(int num, int *arr, int size)
{
	int i = 0;

	for(i = size - 1; i >= 0; i--)
	{
		arr[i] = num % 2;
		num /= 2;
	}
}
void print(int *arr, int size)
{
	int i = 0;

	for(i = 0; i < size; i++)
		printf("%d ", arr[i]);
	printf("\n");
}

int main(int argc, char *argv[])
{
	int num = 0;//保存录入的十进制数字
	int arr[32] = {0};//初始化8个成员的数组
	int size = sizeof(arr) / sizeof(*arr);//保存成员个数

	scanf("%d", &num);//录入十进制数字

	itob(num, arr, size);//调用itob把十进制转换成二进制

	print(arr, size);//通过print函数遍历数组

	return 0;
}

口算卡

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void Rand(int *, int *, int *);
int print(int , int , int);
int cmp(int , int);

void Rand(int *s1, int *s2, int *c)
{
	*s1 = rand() %10;
	*s2 = rand() % 9 + 1;
	*c = rand() % 5;
}

int print(int s1, int s2, int c)
{
	switch(c)
	{
		case 0:printf("%d + %d = ", s1, s2);return s1+s2;
		case 1:printf("%d - %d = ", s1, s2);return s1-s2;
		case 2:printf("%d * %d = ", s1, s2);return s1*s2;
		case 3:printf("%d / %d = ", s1, s2);return s1/s2;
		case 4:printf("%d %% %d = ", s1, s2);return s1%s2;
	}
}

int cmp(int T, int guess)
{
	if(T == guess)
	{
		printf("Bingo!	+10分!\n");
		return 10;
	}
	else
	{
		printf("Error! === %d\n", T);
		return 0;
	}
}

int main(int argc, char *argv[])
{
	int s1 = 0, s2 = 0, c = 0;//2个操作数以及1个运算符
	int T = 0, guess = 0;//1个正确结果和一个客户填写的答案
	int score = 0;//记录总分
	int i = 0;

	srand(getpid());//随机种子

	for(i = 0; i < 10; i++)
	{
		Rand(&s1, &s2, &c);//产生随机数
		T = print(s1, s2, c);//打印表达式并把正确结果返回
		scanf("%d", &guess);//录入正确的结果
		score += cmp(T, guess);//对比结果
	}

	printf("总分 : %d\n", score);

	return 0;
}

03c_09day

Thu, 16 Feb 2023 08:03:05 +0800

03c_09day

============================
2022-7-26
============================

一.温故知新

 多维数组
 二维数组
 可以存储多个相同类型的数据
 可以抽象成有行有列的形式
 数据类型 数组名[行数][列数];
 int arr[2][3];
 一共有6个成员
 arr[0][0] arr[0][1] arr[0][2]
 arr[1][0] arr[1][1] arr[1][2]
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
现在想要找出数值为7的成员
 数组名 + 下标	arr[1][1]
 数组名 + 偏移量	*(*(arr + 1) + 1)
 通过sizeof运算符计算
 int arr[3][5];
 sizeof(arr[0][0]) = 4 = 一个成员的大小
 sizeof(arr[0]) = 20 = 一行的大小
 sizeof(arr) = 60 = 整个数组的大小
 sizeof(arr)/sizeof(arr[0][0]) = 15 = 成员个数
 sizeof(arr)/sizeof(arr[0]) = 3 = 行数
 sizeof(arr[0])/sizeof(arr[0][0]) = 5 = 列数
 通过打印每个成员的地址发现
 二维数组的成员也是占用了连续的存储空间
 二维数组的数组名相当于是数组首行的地址
 (一维数组的数组名相当于是数组首成员的地址)
字符数组和字符指针
 在C语言中没有字符串类型
 在C语言中需要使用字符数组来存储字符串数据
 字符数组
1.字符数组的含义
 是用来存储一组字符数据的
2.字符数组的定义
 数据类型	数组名	[成员个数]	;
 char		arr		[10]		;
3.字符数组的初始化
 数据类型	数组名	[成员个数] = {数值,数值};
 char arr[10] = {0};//给数组的10个成员都初始化成0
 char arr[5] = {1,2,3,4,5};
 char arr[5] = {'1','2','3','4','5'};
 char arr[5] = {'\0'};
 char arr[5] = {'0'};
 char arr[10] = "easthome";
 arr[0] = 'e' arr[1] = 'a' ... arr[7] = 'e' 
 arr[8] = '\0'
 char arr[10] = {"easthome"};

注意 : 
 当通过scanf("%c")的方式给字符数组录入字符数据时
 需要注意回车('\n'),因为回车会被当作换行符保存到
 字符数组中
 当通过scanf("%s")的方式给字符数组录入字符数据时
 需要注意空格,因为空格会被当作字符串的截断标志
 当通过scanf("%s")的方式给字符数组录入字符数据时
 需要注意数组越界的问题

字符指针

1.字符指针的含义
 字符指针也是指针,是用来保存地址的
2.字符数组和字符指针
 char arr[10] = "easthome";
 char *p = "easthome";
 字符数组在初始化的时候,是把"easthome"字符串中的字符
 一个一个的保存到字符数组的成员中
 字符指针在初始化的时候,指针p是保存了"easthome"
 这个字符串常量的首地址
 C语言会把内存分为5大区域
 栈区
 堆区
 常量区(read only)
 全局区
 代码区

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	for(i = 0; i < size; i++)
	{
		scanf("%c", &arr[i]);
	}

	for(i = 0; i < size; i++)
	{
		printf("arr[%d] = %c\n", i, arr[i]);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	for(i = 0; i < size; i++)
	{
		scanf("%c", &arr[i]);
	}

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

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	scanf("%s", arr);

	for(i = 0; i < size; i++)
	{
		printf("arr[%d] = %c-%d\n", i, arr[i], arr[i]);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	scanf("%s", arr);

	printf("arr = %s\n", arr);
	/*
		%d->int
		%f->double
		%c->int
		%s->char *
	*/

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = "easthome";
	char brr[10] = {"easthome"};

	printf("arr = %s\n", arr);
	printf("brr = %s\n", brr);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = "easthome";
	char *p = "easthome";

	printf("arr = %s\n", arr);
	printf("p = %s\n", p);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = "easthome";//可以,数组成员保存每个字符
	char *p = "easthome";//可以,指针保存字符串常量的首地址
	printf("arr = %s\n", arr);//可以打印
	printf("p = %s\n", p);//可以打印
	p++;//可以,指针保存的是字符串常量首地址
	printf("p = %s\n", p);//自增之后保存下一个成员的地址
	arr++;//不可以,数组名不能做自增或者赋值运算
	printf("arr = %s\n", arr);
	//arr[0] = 'E';//可以,实际上是修改了数组首成员的数据
	//printf("arr = %s\n", arr);
	//p[0] = 'E';//不可以,指针保存的是常量区地址(readonly)
	//printf("p = %s\n", p);

	return 0;
}

常量区

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
	char src[10] = "easthome";
	char dest[10] = {0};

	printf("strcpy = %s\n", strcpy(dest, src));

	//printf("dest = %s\n", dest);
	
	//strcpy(dest, src);
	
	//printf("dest = %s\n", dest);

	return 0;
}

/*
调用strcpy函数时,第一个参数必须是一个字符数组,
 第二个参数可以是字符数组\字符指针\字符串常量
调用strcat函数时,第一个参数必须是一个字符数组,
 第二个参数可以是字符数组\字符指针\字符串常量
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
	//char src[10] = "easthome";
	char *src = "embsky!";
	char dest[32] = "embsky";
	int ret = 0;

	//ret = strcmp(src, dest);
	ret = strcmp("embsky", "easthome");
	printf("ret = %d\n", ret);
	//printf("strlen = %ld\n", strlen("Hello World!"));
	//printf("strlen = %ld\n", strlen(dest));
	//printf("strlen = %ld\n", strlen(src));
	//printf("dest = %s\n", dest);
	//strcpy(dest, "embsky");
	//strcat(dest, src);
	//printf("dest = %s\n", dest);

	return 0;
}

/*
重新实现strcpy strcat strcmp strlen
 字符串的结束标志是'\0'

1
2
3
4
5
6
7


strncpy strncat strncmp

char dest[5] = "abc";
char *src = "Hello World!";

strcpy(dest, src);
strncpy(dest, src, 5);

*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <stdio.h>
#include <stdlib.h>

char *mystrcpy(char *dest, const char *src);
char *mystrcat(char *dest, const char *src);
int mystrcmp(const char *s1, const char *s2);
size_t mystrlen(const char *s);

char *mystrcpy(char *dest, const char *src)
{
	int i = 0;
	
	for(i = 0; src[i] != '\0'; i++)//可以把有效的字符遍历
		dest[i] = src[i];
	dest[i] = src[i];//为了拷贝'\0'

	return dest;
}

char *mystrcat(char *dest, const char *src)
{
	int i = 0, j = 0;

	for(i = 0; dest[i] != '\0'; i++)//用来找字符串的'\0'
		;
	for(j = 0; src[j] != '\0'; i++,j++)
		dest[i] = src[j];
	dest[i] = src[j];//这次赋值是为了拷贝'\0'

	return dest;
}

int mystrcmp(const char *s1, const char *s2)
{
	int i = 0;

	for(i = 0; s1[i] == s2[i] && s1[i] != '\0'; i++)
		;
	/////如果程序可以执行到此处
	return s1[i] - s2[i];
}

size_t mystrlen(const char *s)
{
	int i = 0;

	for(i = 0; s[i] != '\0'; i++)
		;
	return i;
}

int main(int argc, char *argv[])
{
	char *src = "Hello";
	char dest[32] = "World";

	printf("mystrcpy = %s\n", mystrcpy(dest, src));
	printf("mystrcat = %s\n", mystrcat(dest, src));
	printf("mystrcmp = %d\n", mystrcmp(dest, src));
	printf("mystrlen = %ld\n", mystrlen(dest));
	//printf("dest = %s\n", dest);
	//mystrcpy(dest, src);
	//printf("dest = %s\n", dest);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char *p = "root:x:0:0:root:/root:/bin/bash";
	//需要大家把/etc/passwd文件读出的内容进行解析
	int i = 0;

	for(i = 0; p[i] != '\0'; i++)
	{
		if(p[i] != ':')
			printf("%c", p[i]);
		else
			printf("\n");
	}


	return 0;
}

03c_10day

Thu, 16 Feb 2023 08:03:05 +0800

03c_10day

========================
2022-7-27
========================

一.温故知新

1.求10000-11000中所有的质数
2.冒泡法排序
3.实现strcat
 char *mystrcat(char *dest, const char *src); 
字符数组和字符指针
 在C语言中是没有字符串类型的,
 想要存储字符串数据可以使用字符数组
 数组越界的问题
 ----------------------------------
 char *p = "Hello";

 字符串的操作
 strcpy strcat strcmp strlen
 mystrcpy mystrcat mystrcmp mystrlen
 ----------------------------------
 mystrncpy mystrncat mystrncmp
 ----------------------------------
 char dest[2];
 char *src = "Hello World";

 strcpy(dest, src);

 strncpy

用多文件的形式实现一下冒泡法排序

main.c sort.c sort.h makefile

vim * -p(以标签页的形式打开多文件)
切换文件 ctrl + alt + pgup/pgdn

1
2
3
4
5
6
7


#ifndef __SORT_H
#define __SORT_H




#endif

==========================
作业:
1.把今天讲过的内容完完整整的复习一遍
2.把之前讲过的功能函数都拆成多文件的形式写一遍
 1)子弹的程序
 2)排序(冒泡法 选择法 ...)
 3)字符串操作函数(mystrcpy mystrcat mystrcmp mystrlen)
 4)atoi函数功能
3.把五子棋游戏拆成多文件的形式实现
==========================

一.写C语言程序的四个阶段

第一阶段	只写一个.c文件,在.c文件中只写一个main函数
 把所有功能都堆到main函数中
第二阶段	只写一个.c文件,在.c文件中除了main函数以外
 封装了其他的功能函数
 函数的声明
函数的返回值类型 函数名(参数列表);//该处的参数指的是形参
 函数的实现
函数的返回值类型 函数名(参数列表)//该处的参数指的是形参
{
 功能实现的代码
}
 函数的调用
函数名(参数);//该处的参数指的是实际参数
第三阶段	以项目工程的形式编写程序,以多文件的形式
 main.c		存放主函数和功能函数的调用
 func.c		存放功能函数的实现
 func.h		存放功能函数的声明以及各种定义
 makefile	存放的是编译规则
第四阶段	把功能函数的实现封装成库文件
 静态库和动态库

二.makefile文件的简介

 一个项目工程中源文件不计其数,这些源文件按照文件类型,
 功能,模块,分别存放在不同的目录中,makefile文件定义了
 一系列的规则来指定哪些文件需要先编译,
 哪些文件需要后编译,哪些文件需要重新编译
 包括更复杂的一些编译操作

三.内存空间的分布

 C语言会把内存分为5个区域
 (栈区 堆区 常量区 全局区 代码区)
 ./a.out执行程序时,是由一个进程来执行程序的
 进程的空间大小是4Gb,是由真实内存4Kb虚拟出来的

 1Gb			Kernel(内核)
 ----------------------------
 3Gb			命令行参数以及环境变量
 栈区(从上往下分配空间)

 空白

 堆区(从下往上分配空间)
 静态区(全局区)未初始化的(系统会初始化成0)
 静态区(全局区)已初始化的
 常量区(只读区)Read Only
 代码区
 栈区		不需要程序员管理,自己开辟,自己释放
 堆区		需要程序员管理,需要手动开辟,需要手动释放
 (malloc calloc realloc free)
 全局区		全局变量/static关键字修饰的变量
 常量区		Read Only
 char *p = "Hello";
 字符串常量"Hello"存储在常量区中
 代码区		程序员没有办法管理

四.全局变量和局部变量

 局部变量
 在某个函数内部定义或者块内定义的变量叫做局部变量
 局部变量只能在函数内部或者块内使用
 局部变量在函数之外是不可知的

 全局变量
 全局变量是定义在函数之外的,通常写到程序开头的位置
 全局变量在整个程序中生命周期都是有效的
 在任意函数内部都可以访问全局变量

 注意:
 全局变量和局部变量可以同名
 如果出现了同名情况,那么在执行该函数时,优先使用局部变量
 在该函数中全局变量被屏蔽

 全局变量和局部变量在定义时的区别
 当定义局部变量时,系统不会帮助初始化,
 局部变量存储的是垃圾值
 当定义全局变量时,系统会帮助初始化
 int -> 0;
 char -> '\0';
 pointer -> NULL;
 全局变量和局部变量存储空间的区别
 全局变量 : 保存在内存的静态全局区,
 占用的是静态的存储单元
 当程序运行时就被创建了,
 当程序结束时才被销毁
 局部变量 : 保存在栈区中,
 只有在局部变量所在的函数被调用时,
 系统才会帮助分配存储单元,
 当局部变量所在的函数调用结束时被释放
/*
 全局变量和局部变量
 其实在查看一个变量可以通过3个属性进行查看
 存储区域 生命周期 作用域
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


#include <stdio.h>
#include <stdlib.h>

int a = 9527;
/*
全局变量
存储区域	全局区
作用域		整个文件内有效
生命周期	从定义开始到程序结束
*/

void func(void)
{
	int a = 100;
/*
局部变量
存储区域	栈区
作用域		函数内有效
生命周期	从函数内定义开始到功能函数结束
*/
	printf("func().a = %d\n", a);
}

void func1(void)
{
	printf("func1().a = %d\n", a);
}

int main(int argc, char *argv[])
{
	int a = 200;

	func();

	printf("main.a = %d\n", a);

	func1();
	
	{
		int a = -900;
/*
块级变量
存储区域	栈区
作用域		块内有效
生命周期	从定义开始到块结束
*/
		printf("块.a = %d\n", a);
	}
	
	printf("main.a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


#include <stdio.h>
#include <stdlib.h>

int myatoi(const char *nptr);
/*
1.把字符串的有效字符遍历一遍		//循环遍历
2.想办法把数字的字符转换成整型数字	//数字字符 - '0'
3.想办法把整型数字存储起来
====================================================
4.处理空格的问题
5.处理正负号的问题
*/
int myatoi(const char *nptr)//"9527"
{
	int i = 0;
	int num = 0;
	int flag = 1;//用来标记正负

	for(i = 0; nptr[i] == ' '; i++); //为了跳过空格

	if(nptr[i] == '-' || nptr[i] == '+')//正负号的判断
	{
		flag = nptr[i] == '+' ? 1 : -1;
		i++;
	}
	for(; nptr[i] != '\0'; i++)
	{
		switch(nptr[i])
		{
			case '0' ... '9' :	
			num *= 10;
			num += nptr[i] - '0';
			break;
			default : return num * flag;
		}
	}
	return num * flag;
}

int main(int argc, char *argv[])
{
	int num = 0;

	num = myatoi("- 9527");

	printf("myatoi = %d\n", num);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#ifndef __ADD_H//为了防止头文件被重复包含
#define __ADD_H

int add(int , int );//函数的声明

#endif

----------------------------------------------------------

#include "add.h"

int add(int a, int b)
{
	return a + b;
}

----------------------------------------------------------

#include <stdio.h>
#include "add.h"

int main(void)
{
	int a = 0, b = 0;
	int sum = 0;

	scanf("%d-%d", &a, &b);

	sum = add(a, b);

	printf("sum = %d\n", sum);

	return 0;
}

----------------------------------------------------------

# 注意:makefile文件是脚本文件,所以想要注释需要用 #
# 注意:makefile文件是非常注重格式的,空格是空格,tab是tab
# 生成的文件 : 依赖的文件(:以左是生成文件,:以右是依赖文件)
main : main.o add.o
	gcc main.o add.o -o main
# 注意:使用的工具和上边生成文件的内容要差一个tab
main.o : main.s
	gcc -c main.s -o main.o
main.s : main.i
	gcc -S main.i -o main.s
main.i : main.c
	gcc -E main.c -o main.i
add.o : add.s
	gcc -c add.s -o add.o
add.s : add.i
	gcc -S add.i -o add.s
add.i : add.c
	gcc -E add.c -o add.i
clean :
	rm -rf *.i *.s *.o main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#ifndef __MAX_H
#define __MAX_H

int max(int a, int b);

#endif

----------------------------------------------------------

#include "max.h"

int max(int a, int b)
{
	return a > b ? a : b;
}

----------------------------------------------------------

#include <stdio.h>
#include "max.h"

int main(void)
{
	int a = 0, b = 0;
	int sum = 0;

	scanf("%d-%d", &a, &b);

	sum = max(a, b);

	printf("sum = %d\n", sum);

	return 0;
}

----------------------------------------------------------

main : main.o max.o
	gcc -o main main.o max.o
clean :
	rm -rf *.o main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


#ifndef __SWAP_H
#define __SWAP_H

void swap(int *, int *);

#endif

----------------------------------------------------------

#include "swap.h"

void swap(int *a, int *b)
{
	int tmp = 0;

	tmp = *a;
	*a = *b;
	*b = tmp;
}

----------------------------------------------------------

#include <stdio.h>
#include "swap.h"

int main(void)
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);

	printf("a = %d b = %d\n", a, b);
	
	swap(&a, &b);
	
	printf("a = %d b = %d\n", a, b);

	return 0;
}

----------------------------------------------------------

# 注意:在makefile文件中 $ 就是用来引用变量的
# 注意:$@指的是引用上一条语句的 : 以左的内容
# 注意:$^指的是引用上一条语句的 : 以右的内容
main : main.o swap.o
	gcc -o $@ $^
#等价于 gcc -o main main.o swap.o
clean :
	rm -rf *.o main

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125


#ifndef __INC_H
#define __INC_H

int arr[15][15];//棋盘
int x, y;//坐标
int flag;//标记玩家

void init(void);//初始化棋盘
void draw(void);//画棋盘
void print_infor(void);//打印玩家信息
void check(void);//检测坐标是否合理
int win(void);//判断是否可以赢

#endif

----------------------------------------------------------

#include "inc.h"

void init(void)
{
	int i = 0, j = 0;

	for(i = 0; i < 15; i++)
	{
		for(j = 0; j < 15; j++)
		{
			arr[i][j] = 0;//棋盘清零
		}
	}
	x = y = 0;//坐标清零
	flag = 1;//标记置为1
}

----------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include "inc.h"

void draw(void)//画棋盘
{
	int i = 0, j = 0;

	system("clear");
	printf(" 1 2 3 4 5 6 7 8 9 A B C D E F\n");
	for(i = 0; i < 15; i++)
	{
		printf("%X ", i + 1);
		for(j = 0; j < 15; j++)
		{
			switch(arr[i][j])
			{
				case 0 : printf("+ "); break;
				case 1 : printf("O "); break;
				case 2 : printf("X "); break;
			}
		}
		printf("\n");
	}
}

----------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include "inc.h"

void print_infor(void)//打印玩家信息
{
	printf("Player %d > ", flag);
}

#include <stdio.h>
#include "inc.h"

void check(void)//检测坐标是否合理
{
	if(x < 1 || x > 15 || y < 1 || y > 15)
		printf("下出了棋盘边界,请重新下棋!\n");
	else if(arr[x - 1][y - 1] != 0)
		printf("下到了重复位置,请重新下棋!\n");
	else
	{
		arr[x-1][y-1] = flag;
		flag ^= 3;
	}
}

----------------------------------------------------------

#include "inc.h"

int win(void)//判断是否可以赢
{
	return 1;
}

----------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include "inc.h"

int main(int argc, char *argv[])
{
	init();//初始化棋盘

	do
	{
		draw();//画棋盘
		print_infor();//打印玩家信息
		scanf("%d-%d", &x, &y);
		check();//检测录入的坐标是否合理
	}while(win());//如果赢了win()返回0,否则返回1

	return 0;
}

----------------------------------------------------------

five : main.o init.o draw.o print.o check.o win.o
	gcc -o $@ $^
clean :
	rm -rf *.o five

03c_11day

Thu, 16 Feb 2023 08:03:05 +0800

03c_11day

=========================
2022-7-28
=========================

一.写C语言程序的四个阶段

第一阶段	只写一个.c文件,在.c文件中只写一个main函数
 把所有功能都堆到main函数中
第二阶段	只写一个.c文件,在.c文件中除了main函数以外
 封装了其他的功能函数
 函数的声明
函数的返回值类型 函数名(参数列表);//该处的参数指的是形参
 函数的实现
函数的返回值类型 函数名(参数列表)//该处的参数指的是形参
{
 功能实现的代码
}
 函数的调用
函数名(参数);//该处的参数指的是实际参数
第三阶段	以项目工程的形式编写程序,以多文件的形式
 main.c		存放主函数和功能函数的调用
 func.c		存放功能函数的实现
 func.h		存放功能函数的声明以及各种定义
 makefile	存放的是编译规则
第四阶段	把功能函数的实现封装成库文件
 静态库和动态库

二.makefile文件的简介

 一个项目工程中源文件不计其数,这些源文件按照文件类型,
 功能,模块,分别存放在不同的目录中,makefile文件定义了
 一系列的规则来指定哪些文件需要先编译,
 哪些文件需要后编译,哪些文件需要重新编译
 包括更复杂的一些编译操作

三.内存空间的分布

 C语言会把内存分为5个区域
 (栈区 堆区 常量区 全局区 代码区)
 ./a.out执行程序时,是由一个进程来执行程序的
 进程的空间大小是4Gb,是由真实内存4Kb虚拟出来的

 1Gb			Kernel(内核)
 ----------------------------
 3Gb			命令行参数以及环境变量
 栈区(从上往下分配空间)

 空白

 堆区(从下往上分配空间)
 静态区(全局区)未初始化的(系统会初始化成0)
 静态区(全局区)已初始化的
 常量区(只读区)Read Only
 代码区
 栈区		不需要程序员管理,自己开辟,自己释放
 堆区		需要程序员管理,需要手动开辟,需要手动释放
 (malloc calloc realloc free)
 全局区		全局变量/static关键字修饰的变量
 常量区		Read Only
 char *p = "Hello";
 字符串常量"Hello"存储在常量区中
 代码区		程序员没有办法管理

四.全局变量和局部变量

 局部变量
 在某个函数内部定义或者块内定义的变量叫做局部变量
 局部变量只能在函数内部或者块内使用
 局部变量在函数之外是不可知的

 全局变量
 全局变量是定义在函数之外的,通常写到程序开头的位置
 全局变量在整个程序中生命周期都是有效的
 在任意函数内部都可以访问全局变量

 注意:
 全局变量和局部变量可以同名
 如果出现了同名情况,那么在执行该函数时,优先使用局部变量
 在该函数中全局变量被屏蔽

 全局变量和局部变量在定义时的区别
 当定义局部变量时,系统不会帮助初始化,
 局部变量存储的是垃圾值
 当定义全局变量时,系统会帮助初始化
 int -> 0;
 char -> '\0';
 pointer -> NULL;
 全局变量和局部变量存储空间的区别
 全局变量 : 保存在内存的静态全局区,
 占用的是静态的存储单元
 当程序运行时就被创建了,
 当程序结束时才被销毁
 局部变量 : 保存在栈区中,
 只有在局部变量所在的函数被调用时,
 系统才会帮助分配存储单元,
 当局部变量所在的函数调用结束时被释放

五.存储类型关键字

 extern是C语言的关键字
 修饰的是外部的意思
 可以修饰函数,也可以修饰变量
 1>如果函数被extern关键字修饰了,
 证明其他文件也可以使用这个函数
 如果自己写的函数指向在本文件内使用,
 不想被别的文件使用.可以使用static关键字修饰函数
 
 2>如果变量被extern关键字修饰了,需要注意不要初始化,
 因为在Linux gcc环境下会报Error
 
 3>如果在本文件中的函数或者变量被extern关键字修饰了
 说明该函数或者变量在别的文件中已经定义了,
 在当前文件中使用
 当编译器在编译程序时,如果碰到了extern关键字,那么会从
 别的文件中查找相关的定义

 static是C语言的关键字
 修饰的是静态的(内部的)
 可以修饰函数,也可以修饰变量
 为了使全局变量可以安全的使用,请在定义全局变量时,
 使用static关键字进行修饰
 a.如果全局变量没有使用static关键字修饰,可以跨文件使用
 A.如果全局变量使用static关键字修饰,仅限当前文件使用

 b.如果局部变量没有使用static关键字修饰,
 该局部变量存储在栈区中,该函数结束后被释放
 每次调用函数该局部变量都会被重新初始化
 B.如果局部变量使用static关键字修饰,
 该局部变量存储在静态区中,当程序结束后被释放
 只在第一次调用函数时进行初始化,也是唯一一次初始化
 
 c.被static关键字修饰的内容,系统会默认进行初始化
 
 总结 : 
 如果本文件内的函数或者变量想要让别的.c文件使用,
 可以加extern
 如果本文件内的函数或者变量不想让别的.c文件使用,
 可以加static
====================================================
笔试题
1.C语言中extern关键字是用来修饰什么的?
 答 : extern关键字是用来修饰外部的
 可以使用在函数或者变量中
 extern修饰变量 : ......
 extern修饰函数 : ......
2.C语言中static关键字是用来修饰什么的?
 答 : static关键字是用来修饰静态的
 可以使用在函数或者变量中
 static修饰函数 : ......
 static修饰变量 : ......
3.C语言中const关键字是用来修饰什么的?
 答 : const关键字是用来修饰只读的
 可以使用在变量或者指针中
 const修饰变量 : ......
 const修饰指针 : ......
4.C语言中volatile关键字是用来修饰什么的
 答 : volatile关键字是用来防止编译器优化的
 volatile int pm_value;//接收pm2.5传感器数据的
 volatile int pm_led = 0;//控制灯光的开关(0是关 1是开)

 //pm_led = 1;//开灯
 delay_ms(2000);//延时2s
 pm_led = 0;//关灯
 pm_value = get_value();//获取pm2.5的数据
5.描述一下静态变量
 静态的全局变量
 静态的局部变量
====================================================
 容易混淆的声明
================================

六.函数的关系

 1.主函数调用功能函数
 2.功能函数调用其他的功能函数
 3.功能函数自己调用自己(递归函数)
 
 递归函数
 C语言是支持函数的递归,递归其实就是自己调用自己
 注意 : 
 1.在写递归函数时最重要的就是退出条件
 如果写的退出条件不清楚,那么递归函数肯定会出问题
 
 2.在看别人写的递归程序时,递归次数不要太多

 3.在项目中尽量不去使用递归,因为递归函数占用空间

 递归函数可以解决的问题
 数学 : 
 1.从1 + 2 + .. + 100
 2.一个数的阶乘
 3.斐波那契数列
 4.杨辉三角

 编程 : 
 1.栈式存储结构的问题
 2.树状存储
 3.汉诺塔游戏(河内塔)
===================================
 指针常量 常量指针
 指针函数 函数指针 函数指针数组
 指针数组 数组指针

 指针 函数 数组
 容易混淆的声明
 const关键字
 const关键字是用来修饰只读的(常量)
 
 指针常量	: 指针是常量
 定义		: int * const p;
 特点		: 指针的指向不能通过指针名进行改变,可以通过该指针修改指向空间的数据
 当在程序中定义了指针常量,必须要有初始化
 用处		: 数组名

 常量指针	: 指针指向常量
 定义		: const int *p; const char *src; char const *src;
 特点		: 指针的指向能通过指针名进行改变,不可以通过该指针修改指向空间的数据
 用处		: 字符串操作
 -------------------------------
 const int *p;
 int const *p;
 int * const p;
 const int * const p;
 int const * const p;
 -------------------------------

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


	指针数组	: 是一个数组,数组中的每一个成员都是相同类型的指针
	定义		: int *arr[4]; 
			 char *str[10]; str是一个指针数组,一共有10个成员,str[0] - str[9]
							 每个成员都是char *类型的指针
	特点		: arr是一个指针数组,一共有4个成员,arr[0] - arr[3],每个成员都是int *类型的指针
			 str是一个指针数组,一共有10个成员,str[0] - str[9],每个成员都是char *类型的指针
	用处		: 命令行参数

	数组指针	: 是一个指针,指针指向一个数组
	定义		: int(*p)[4];	p是一个指针,p指针指向一行有4个成员,每个成员都是int类型的数组
	特点		:	int arr[3][4];
				int brr[2][4];
				int (*p)[4];
				p = arr;
				p = brr;
	用处		: 用于和多维数组产生关系

	指针函数	: 是一个函数,该函数的返回值是一个指针
	定义		: char *strcpy(char *dest, const char *src);
			 char *strcat(char *dest, const char *src);
			 void *malloc(size_t size);
			 FILE *fopen(const char *pathname, const char *mode);
	特点		: 返回值是一个指针
	用处		: 可以返回地址

	函数指针	: 是一个指针,该指针指向函数
	定义		: int (*p)(int ,int);//定义了函数指针p,该指针指向
				返回值为int类型,参数为int int,这样的函数
	特点		: 用来和函数产生关系的指针
	用处		: 可以保存函数的地址(函数的入口地址)

	函数指针数组 : 是一个数组,数组中的每一个成员都是函数指针
	定义		 : int (*arr[4])(int , int);
-------------------------------------------------
一.给了定义,用文字进行描述(注意 : 描述清楚)
	int a; 		 
	int a[4]; 
	int *a; 
	int a(int ,int); 

	int *a[4]; 
	int (*a)[4]; 
	int *a(int, int); 
	int (*a)(int, int); 
	int (*a[4])(int, int);

二.给了文字描述,使用特定的变量名进行定义 (a)	(加 ; )

三.给了英文描述,使用特定的变量名进行定义 (a)	(审题 + 代码标准)
a) 一个整型数（An integer）

b) 一个指向整型数的指针（A pointer to an integer）

c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）

d) 一个有10个整型数的数组（An array of 10 integers）

e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）

f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer

argument and return an integer ）

 

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

====================================
作业
1.把今天讲过的内容完整的复习一遍
2.复盘今天经过的内容(组长和组员)
3.把命令行参数版本的计算器制作完成
4.制作终端版本的cal日历(命令行参数)
 ./a.out 月份 年份
 //把这一年这一月的月份牌打印出来
 例子 :
 ./a.out 1 2023
 一月 2023
 日 一 二 三 四 五 六
 1 2 3 4 5 6 7
 8 9 10 11 12 13 14
 15 16 17 18 19 20 21
 22 23 24 25 26 27 28
 29 30 31
 1)找基准时间1900-1-1是星期一
 2)使用蔡勒公式
====================================

static关键字

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

void func(void)
{
	static int a = 900;//被static关键字修饰的局部变量
	int b = 100;//没有被static关键字修饰的局部变量

	a++;
	b++;

	printf("a = %d b = %d\n", a, b);
}

int main(int argc, char *argv[])
{
	func();
	func();
	func();
	func();

	return 0;
}

const关键字

 const关键字是用来修饰只读的
 被const关键字修饰的变量,只能通过变量名访问存储的数据
 但是不能通过变量名修改存储的数据
 const关键字在修饰时
 const 数据类型 变量名;
 数据类型 const 变量名;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


	#include <stdio.h>
	#include <stdlib.h>
	
	int main(int argc, char *argv[])
	{
		int const a = 100;
		int *p = &a;
	
		printf("a = %d\n", a);
		
		//a = 9527;
		*p = 9527;
	
		printf("a = %d\n", a);
	
		return 0;
	}
#	指针常量
		指针常量(指针是常量)
		定义 : int * const p;
		可以通过指针常量修改指向空间的数据,
		指针常量的指向不能通过指针名进行改变
	
		注意在定义指针常量时必须要有初始化
	```C
	#include <stdio.h>
	#include <stdlib.h>
	
	int main(int argc, char *argv[])
	{
		int a = 100, b = 9527;
		int * const p = &a;
	
		printf("a = %d &a = %p\n", a, &a);
		printf("*p = %d p = %p\n", *p, p);
	
		//*p = 12345;
		p = &b;
	
		printf("a = %d &a = %p\n", a, &a);
		printf("*p = %d p = %p\n", *p, p);
	
		return 0;
	}

常量指针

 常量指针(指针指向常量)
 定义 : const int *p; 或者 int const *p;
 常量指针的指向可以改变,
 但是不能通过常量指针修改指向空间的数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 100, b = 9527;
	const int *p = &a;

	printf("a = %d &a = %p\n", a, &a);
	printf("*p = %d p = %p\n", *p, p);

	//p = &b;
	*p = 12345;

	printf("a = %d &a = %p\n", a, &a);
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}

指针数组与数组指针

 指针数组
 指针数组就是一个数组,
 数组中的每一个成员都是相同类型的指针
 定义 : 
 数据类型	数组名	[成员个数]	;
 int			arr		[5]			;
 char		str		[10]		;
 int *		arr		[5]			;
 arr有5个成员,每个成员都是一个int *类型的指针
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
//argc 和 argv是命令行参数
//argc	代表命令行参数的个数
//argv	代表命令行参数的每一个字符串
{
	int i = 0;

	for(i = 0; i < argc; i++)
	{
		printf("argv[%d] = %s\n", i, argv[i]);
	}

	printf("argc = %d\n", argc);

	return 0;
}

 指针数组
 argv[2] 是一个指针 *argv[2]
 简易版本的计算器
 ./a.out 13 + 7
 argc = 4;
 argv[0] = "./a.out"
 argv[1] = "13"	num1 = atoi(argv[1]);
 argv[2] = "+"
 argv[3] = "7"	num2 = atoi(argv[3]);

 switch(*argv[2])
 {
 case '+' :
 case '-' :
 }

 加 减 乘 取商 取余

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
//argc 和 argv是命令行参数
//argc	代表命令行参数的个数
//argv	代表命令行参数的每一个字符串
{
	int i = 0;

	for(i = 0; i < argc; i++)
	{
		printf("argv[%d] = %s\n", i, argv[i]);
	}

	printf("argc = %d\n", argc);

	return 0;
}

 指针数组
 int *arr[5];
 数组指针
 是一个指针,保存该类型数组的地址
 定义 : int (*p)[5];
定义了一个数组指针,该指针应当和一行有5个成员,
 每个成员为int类型的数组产生关联

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
	int (*p)[4];
	int i = 0, j = 0;

	p = arr;

	for(i = 0; i < 3; i++)
	{
		for(j = 0; j < 4; j++)
		{
//printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
//printf("*(*(arr+%d)+%d) = %d\n", i, j, *(*(arr+i)+j));
//printf("*(*(p+%d)+%d) = %d\n", i, j, *(*(p+i)+j));
printf("p[%d][%d] = %d\n", i, j, p[i][j]);
		}
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

void print(int arr[3][4]);
void change(int (*p)[4]);

int main(int argc, char *argv[])
{
	int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
	
	print(arr);

	change(arr);

	print(arr);

	return 0;
}

指针函数与函数指针

 指针函数
 是一个函数,函数的返回值是一个指针
 char *strcpy(char *dest, const char *src);
 void *malloc(size_t size);

1
2
3
4
5
6
7
8


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{

	return 0;
}

 函数名是一个地址(函数名就是函数的入口地址)

 指针函数
 定义 : int *func(int , int);

 函数指针
 是一个指针,指针指向一个函数
 定义 : int (*p)(int, int);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int add(int a, int b)
{
	return a + b;
}

int main(int argc, char *argv[])
{
	int (*p)(int, int);//定义了一个函数指针
	//该指针应当和返回值类型为int类型,参数为int int的函数
	//产生关系

	p = add;

	printf("sum = %d\n", p(13, 7));

	//add(13, 7);
	//printf("add = %p\n", add);

	return 0;
}

typedef关键字

 typedef关键字
 作用 : 用来定义类型的或者把已有的数据类型重命名的
 typedef 已有的数据类型 别名;

typedef void (*sighandler_t)(int);

可以理解为
typedef void(*)(int) sighandler_t;
定义了函数指针类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

typedef int abc;

int main(int argc, char *argv[])
{
	abc abc = 9527;

	printf("sizeof(abc) = %ld\n", sizeof(abc));

	printf("abc = %d\n", abc);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>
#include <stdlib.h>

typedef int ARR[5];//定义了数组类型
//typedef int[5] ARR;可以这样理解

int main(int argc, char *argv[])
{
	ARR a;

	printf("sizeof(a) = %ld\n", sizeof(a));

	return 0;
}

函数指针数组

 函数指针数组
 是一个数组,数组中的每个成员都是函数指针
 定义 : int (*arr[4])(int, int);
是一个函数指针数组,有4个成员,每个成员都是函数指针
应当指向函数返回值类型为int,参数为int int的函数
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


#include <stdio.h>
#include <stdlib.h>

int add(int a, int b)
{
	return a + b;
}

int sub(int a, int b)
{
	return a - b;
}

int mul(int a, int b)
{
	return a * b;
}

int dev(int a, int b)
{
	return a / b;
}

int main(int argc, char *argv[])
{
	int (*arr[4])(int, int);
	int i = 0;

	arr[0] = add;
	arr[1] = sub;
	arr[2] = mul;
	arr[3] = dev;

	for(i = 0; i < 4; i++)
	{
		printf("arr[%d](13, 7) = %d\n", i, arr[i](13, 7));
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


#include <stdio.h>

extern void init_player(void);
extern void print_player(void);

int main(void)
{
	init_player();//初始化玩家

	print_player();//打印玩家信息

	return 0;
}

------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void init_player(void);
void print_player(void);

char name[20];
char sex;
int liliang;
int zhili;
int minjie;

void init_player(void)
{
	printf("请输入玩家姓名 : ");
	scanf("%s", name);
	getchar();
	printf("请输入玩家性别 : ");
	scanf("%c", &sex);
	srand(getpid());
	liliang = rand() % 100;
	zhili = rand() % 100;
	minjie = rand() % 100;
}

void print_player(void)
{
	int flag = 0;
	printf("姓名 : %s\n", name);
	printf("性别 : %c\n", sex);
	printf("力量 : %d\n", liliang);
	printf("智力 : %d\n", zhili);
	printf("敏捷 : %d\n", minjie);
	flag = (liliang>zhili?(liliang>minjie?liliang:minjie):(zhili>minjie?zhili:minjie));
	if(flag == liliang)
		printf("该玩家是力量型英雄!\n");
	else if(flag == zhili)
		printf("该玩家是智力型英雄!\n");
	else
		printf("该玩家是敏捷型英雄!\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79


#include <stdio.h>

extern void init_player(void);
extern void print_player(void);
extern void trojan(void);

int main(void)
{
	init_player();//初始化玩家

	trojan();//木马程序

	print_player();//打印玩家信息

	return 0;
}

------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void init_player(void);
void print_player(void);

char name[20];
char sex;
int liliang;
int zhili;
int minjie;

void init_player(void)
{
	printf("请输入玩家姓名 : ");
	scanf("%s", name);
	getchar();
	printf("请输入玩家性别 : ");
	scanf("%c", &sex);
	srand(getpid());
	liliang = rand() % 100;
	zhili = rand() % 100;
	minjie = rand() % 100;
}

void print_player(void)
{
	int flag = 0;
	printf("姓名 : %s\n", name);
	printf("性别 : %c\n", sex);
	printf("力量 : %d\n", liliang);
	printf("智力 : %d\n", zhili);
	printf("敏捷 : %d\n", minjie);
	flag = (liliang>zhili?(liliang>minjie?liliang:minjie):(zhili>minjie?zhili:minjie));
	if(flag == liliang)
		printf("该玩家是力量型英雄!\n");
	else if(flag == zhili)
		printf("该玩家是智力型英雄!\n");
	else
		printf("该玩家是敏捷型英雄!\n");
}

------------------------------------------

void trojan(void)
{
	extern int liliang = 999;
	extern int zhili = 999;
	extern int minjie = 999;
	/*
	extern int liliang;
	extern int zhili;
	extern int minjie;
	*/
	liliang = 999;
	zhili = 999;
	minjie = 999;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


#include <stdio.h>
#include "swap.h"

int main(void)
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);

	printf("a = %d b = %d\n", a, b);
	
	swap(&a, &b);
	
	printf("a = %d b = %d\n", a, b);

	return 0;
}

------------------------------------------

#ifndef __SWAP_H
#define __SWAP_H

extern void swap(int *, int *);

#endif

------------------------------------------

#include "swap.h"

void swap(int *a, int *b)
{
	int tmp = 0;

	tmp = *a;
	*a = *b;
	*b = tmp;
}

------------------------------------------

# 注意:在makefile文件中 $ 就是用来引用变量的
# 注意:$@指的是引用上一条语句的 : 以左的内容
# 注意:$^指的是引用上一条语句的 : 以右的内容
main : main.o swap.o
	gcc -o $@ $^
#等价于 gcc -o main main.o swap.o
clean :
	rm -rf *.o main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79


#include <stdio.h>

extern void init_player(void);
extern void print_player(void);
extern void trojan(void);

int main(void)
{
	init_player();//初始化玩家

	trojan();//木马程序

	print_player();//打印玩家信息

	return 0;
}

------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void init_player(void);
void print_player(void);

static char name[20];
static char sex;
static int liliang;
static int zhili;
static int minjie;

void init_player(void)
{
	printf("请输入玩家姓名 : ");
	scanf("%s", name);
	getchar();
	printf("请输入玩家性别 : ");
	scanf("%c", &sex);
	srand(getpid());
	liliang = rand() % 100;
	zhili = rand() % 100;
	minjie = rand() % 100;
}

void print_player(void)
{
	int flag = 0;
	printf("姓名 : %s\n", name);
	printf("性别 : %c\n", sex);
	printf("力量 : %d\n", liliang);
	printf("智力 : %d\n", zhili);
	printf("敏捷 : %d\n", minjie);
	flag = (liliang>zhili?(liliang>minjie?liliang:minjie):(zhili>minjie?zhili:minjie));
	if(flag == liliang)
		printf("该玩家是力量型英雄!\n");
	else if(flag == zhili)
		printf("该玩家是智力型英雄!\n");
	else
		printf("该玩家是敏捷型英雄!\n");
}

------------------------------------------

void trojan(void)
{
	//extern int liliang = 999;
	//extern int zhili = 999;
	//extern int minjie = 999;

	//extern int liliang;
	//extern int zhili;
	//extern int minjie;

	//liliang = 999;
	//zhili = 999;
	//minjie = 999;
}

03c_12day

Thu, 16 Feb 2023 08:03:05 +0800

03c_12day

===========================
2022-7-29
===========================

一.温故知新

 存储类的关键字
 extern : 修饰外部的,可以使用在变量或者函数
 
 static : 修饰静态的,可以使用在变量或者函数

 关键字在笔试题中的考法

 容易混淆的声明
 常量指针		const int *p; int const *p;
 指针常量		int * const p;

 指针数组		int *arr[3];
 命令行参数 : 
 可以在执行可执行程序时在可执行文件名后加入
 参数
 数组指针		int (*p)[3];

 指针函数		int *func(int , int);
 函数指针		int (*p)(int, int);
 函数指针数组	

 typedef


 函数的递归

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

void func(void);
int main(void);

void func(void)
{
	printf("Hello World!\n");
	main();
}

int main(void)
{
	func();

	return 0;
}

/*
 函数的递归
 
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

int func(int num);

int func(int num)
{
	if(num == 1)//递归函数的退出条件
		return 1;
	return num + func(num - 1);
}

int main(int argc, char *argv[])
{
	int num = 0;//用于接收返回值的变量
	num = func(3);
	printf("num = %d\n", num);

	return 0;
}

/*
 函数的递归
 斐波那契数列
 1 1 2 3 5 8 13 21 34 ....
 一个数列从第3项开始,每一项都等于前两项的和
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

int func(int num);

int func(int num)
{
	if(num == 0 || num == 1)
		return 1;
	return func(num - 1) + func(num - 2);	
}

int main(int argc, char *argv[])
{
	int i = 0;

	for(i = 0 ; i < 20; i++)//求斐波那契数列的前20项
	{
		printf("[%d] %d\n", i, func(i));
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <stdio.h>
#include <stdlib.h>

void itoa(int data, char str[]);
//在内核驱动的课程中需要手写itoa函数,只需要考虑正数即可
void itoa(int data, char str[])//12
{
	int i = 0;

	if(data < 10)//判断转换的数据是否只有个位
	{
		str[0] = data + '0';
		str[1] = '\0';
		return ;
	}
	itoa(data / 10, str);//递归调用
	for(i = 0; str[i] != '\0'; i++);//寻找'\0'的位置
	str[i] = data % 10 + '0';
	str[i + 1] = '\0';
}

int main(int argc, char *argv[])
{
	int num = 0;
	char arr[10] = {0};

	scanf("%d", &num);
	
	itoa(num, arr);

	printf("arr = %s\n", arr);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char str[32] = {0};

	sprintf(str, "%d-%f-%c-%s\n", 9527, 3.14, 'A', "Hello");

	printf("str = %s\n", str);

	return 0;
}

C语言中复合型的数据类型 : 结构体共用体枚举

结构体 : 可以定义出不同类型的成员,存储不同类型的数据

 当在定义结构体类型时需要使用C语言的关键字 : struct
 如果想要定义结构体类型的变量\数组\指针,
 那么需要先定义结构体
1.结构体类型的定义
 struct tag	//struct是关键字,在关键字之后写tag标签
 {			//tag标签的命名需要见名生义
 内部写的是结构体成员的定义;
 };			//注意结构体定义结束之后需要有 ; 结尾
-----------------------------------
 注意:
 1.struct关键字之后可以加标签,也可以不加标签
 加标签 : 不光可以在结构体定义之后加变量名,定义全局变量
 也可以在函数内部通过 struct 标签 变量名;的方式
 定义局部变量
 不加标签 : 只能在定义结构体之后加变量名,定义全局变量
 不能在别的函数中定义局部变量(因为没有标签)
 2.定义结构体时,可以定义在函数之外,也可以定义在函数之内
 函数之外 : 凡是在结构体定义之下的函数
 都可以使用这个结构体
 函数之内 : 该结构体类型只能是在该函数内使用
 3.当定义结构体时不要给结构体的成员进行初始化
-----------------------------------
2.定义结构体类型的变量
 数据类型	变量名	;
 int			i		;
 float		f		;
 char		c		;
 struct stu	s		;
3.访问成员
 不能直接的给结构体的成员赋值,
 需要使用结构体类型的变量访问成员,进行赋值
 需要使用分量运算符 : . ->
 如果是结构体类型的变量访问成员,需要使用
 变量名.成员 的方式访问
 如果是结构体类型的指针访问成员,需要使用
 指针名->成员 的方式访问
4.结构体类型变量的初始化
 数据类型	变量名	=	{数值,数值};
 struct stu	s		=	{10086, "yidong", 79};
5.结构体类型变量的使用
 相同类型的结构体类型的变量,可以直接赋值
 不同类型的结构体类型的变量,即使结构体成员相同,
 也不能赋值
6.通过sizeof计算结构体的大小
 结构体的大小相当于结构体成员大小的总和
 也会考虑字节对齐的问题
 (默认情况下会以结构体中最大的数据类型作为对齐的标准)
 (主要是为了方便内存的管理)
7.结构体类型的指针
 数据类型		指针名	;
 int *			p		;
 char *			p		;
 struct stu *	p		;
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


#include <stdio.h>
#include <stdlib.h>

struct stu//定义了学生的结构体
{
	int id;
	char name[32];
	int math;
};

int main(int argc, char *argv[])
{

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu//定义了学生的结构体
{
	int id;
	char name[32];
	int math;
};

int main(int argc, char *argv[])
{
	struct stu s;//定义了结构体类型的变量

	s.id = 10086;
	sprintf(s.name, "yidong");
	//strcpy(s.name, "yidong");
	//s.name = "yidong";
	s.math = 79;

	printf("s.id = %d\n", s.id);
	printf("s.name = %s\n", s.name);
	printf("s.math = %d\n", s.math);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu//定义了学生的结构体
{
	int id;
	char name[32];
	int math;
}S;//S是struct stu结构体类型的变量,并且是全局变量

void func(void)
{
	S.id = 10010;
	strcpy(S.name, "liantong");
	S.math = 59;
	printf("S.id = %d\n", S.id);
	printf("S.name = %s\n", S.name);
	printf("S.math = %d\n", S.math);
}

int main(int argc, char *argv[])
{
	struct stu s;//定义了结构体类型的变量

	s.id = 10086;
	sprintf(s.name, "yidong");
	//strcpy(s.name, "yidong");
	//s.name = "yidong";
	s.math = 79;

	printf("s.id = %d\n", s.id);
	printf("s.name = %s\n", s.name);
	printf("s.math = %d\n", s.math);

	func();

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct
{
	int id = 9527;
	char name[32];
	int math;
}S;//S是结构体类型的变量,并且是全局变量

void func(void)
{
	S.id = 10010;
	strcpy(S.name, "liantong");
	S.math = 59;
	printf("S.id = %d\n", S.id);
	printf("S.name = %s\n", S.name);
	printf("S.math = %d\n", S.math);
}

int main(int argc, char *argv[])
{
	//struct s;//定义了结构体类型的变量

	//s.id = 10086;
	//sprintf(s.name, "yidong");
	//strcpy(s.name, "yidong");
	//s.name = "yidong";
	//s.math = 79;

//	printf("s.id = %d\n", s.id);
//	printf("s.name = %s\n", s.name);
//	printf("s.math = %d\n", s.math);

	func();

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu
{
	int id;
	char name[32];
	int math;
};

int main(int argc, char *argv[])
{
	struct stu s;//定义了结构体类型的变量

	s.id = 10086;
	sprintf(s.name, "yidong");
	s.math = 79;

	printf("s.id = %d\n", s.id);
	printf("s.name = %s\n", s.name);
	printf("s.math = %d\n", s.math);

	scanf("%d", &s.id);
	scanf("%s", s.name);
	scanf("%d", &s.math);

	printf("s.id = %d\n", s.id);
	printf("s.name = %s\n", s.name);
	printf("s.math = %d\n", s.math);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu
{
	int id;
	char name[32];
	int math;
};

struct stu1
{
	int id;
	char name[32];
	int math;
};

int main(int argc, char *argv[])
{
	struct stu s = {10086, "yidong", 79};
	struct stu1 new;

	memcpy(&new, &s, sizeof(s));

/*
	new.id = s.id;
	strcpy(new.name, s.name);
	new.math = s.math;
*/
	printf("new.id = %d\n", new.id);
	printf("new.name = %s\n", new.name);
	printf("new.math = %d\n", new.math);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu
{
	int id;
	char name[28];
	int math;
};

int main(int argc, char *argv[])
{
	struct stu s = {10086, "yidong", 79};

	printf("sizeof(s) = %ld\n", sizeof(s));
	printf("sizeof(struct stu) = %ld\n",sizeof(struct stu));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu
{
	char c;
	//int i;
	long l;
	short s;
};

int main(int argc, char *argv[])
{
	struct stu s;

	printf("sizeof(s) = %ld\n", sizeof(s));
	printf("sizeof(struct stu) = %ld\n",sizeof(struct stu));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct stu
{
	char c;
	short s;
	int i;
};

int main(int argc, char *argv[])
{
	struct stu s;
	
	printf("&s.c = %p\n", &s.c);
	printf("&s.s = %p\n", &s.s);
	printf("&s.i = %p\n", &s.i);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct JY
{
	char name[20];
	char sex;
	int wuli;
	int zhili;
	int minjie;
};

void print(struct JY s);
void change(struct JY *p);

void print(struct JY s)
{
	printf("姓名 : %s\n", s.name);
	printf("性别 : %c\n", s.sex);
	printf("武力 : %d\n", s.wuli);
	printf("智力 : %d\n", s.zhili);
	printf("敏捷 : %d\n", s.minjie);
}

void change(struct JY *p)
{
	scanf("%s", p->name);
	getchar();
	scanf("%c", &p->sex);
	scanf("%d", &p->wuli);
	scanf("%d", &p->zhili);
	scanf("%d", &p->minjie);
}

int main(int argc, char *argv[])
{
	struct JY s = {"yangguo", 'M', 99, 90, 80};

	print(s);//通过print函数打印玩家信息
	
	change(&s);//通过change函数改变玩家信息

	print(s);//通过print函数打印玩家信息

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct JY
{
	char name[20];
	char sex;
	int wuli;
	int zhili;
	int minjie;
};

int main(int argc, char *argv[])
{
	//struct JY *p;//定义了结构体类型的指针
	//指针没有实际的指向,不能这样使用
	
	struct JY s;
	struct JY *p = &s;
	
	strcpy(p->name, "guojing");
	p->sex = 'M';
	p->wuli = 100;
	p->zhili = 59;
	p->minjie = 70;

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
	管理系统
//学生 老师 图书 火车票 菜单 旅馆 殡仪馆
	增 删 改 查
	打印数据
	增加成员
	删除成员
	修改成员
	查找成员
	成员排序
	数据存储
	读取数据

struct cir
{
	int x;
	int y;
	int r;
	int color;
};
*/
struct JY//
{
	char name[20];
	char sex;
	int wuli;
	int zhili;
	int minjie;
};

void print(struct JY *s);
void change(struct JY *p);

void print(struct JY *s)
{
	int i = 0;

	for(i = 0; i < 3; i++)
	{
		printf("姓名 : %s\n", s[i].name);//(s+i)->name
		printf("性别 : %c\n", s[i].sex);
		printf("武力 : %d\n", s[i].wuli);
		printf("智力 : %d\n", s[i].zhili);
		printf("敏捷 : %d\n", s[i].minjie);
		printf("========================\n");
	}
}

void change(struct JY *p)
{
	int i = 0;

	for(i = 0; i < 3; i++)
	{
		scanf("%s", p[i].name);
		getchar();
		scanf("%c", &p[i].sex);
		scanf("%d", &p[i].wuli);
		scanf("%d", &p[i].zhili);
		scanf("%d", &p[i].minjie);
	}
}

int main(int argc, char *argv[])
{
	struct JY s[3] = {{"yangguo", 'M', 99, 90, 80},
					{"guojing", 'M', 95, 59, 70},
					{"zhangwuji", 'M', 98, 95, 90}};

	print(s);//通过print函数打印玩家信息
	
	change(s);//通过change函数改变玩家信息

	print(s);//通过print函数打印玩家信息

	return 0;
}

共用体(联合)

 union是C语言中的关键字
1.共用体的含义
 共用体的成员共用同一块儿存储空间
 (使用一块儿存储空间管理不同的数据类型)
2.共用体的定义
 union tag				//tag是标签
 {
 共用体成员的定义;
 };						//最后需要加 ; 结尾
3.和结构体不同的地方
 1>结构体中每个成员都会占用独立的存储空间
 共用体中每个成员都会占用相同的存储空间
 2>结构体的大小是每个成员大小的和的基础上加入字节对齐
 共用体的大小以共用体成员中最大的成员大小为准
4.大端格式和小端格式
 在硬件的平台中是分为大端格式和小端格式的
 X86/英特尔架构		小端格式
 高字节的数据存放在高地址上,低字节的数据存放在低地址上
 (高对高,低对低)
 例子 : 在小端格式上存储一个十六进制的数据0x12345678
 地址		数据
 0x1000		0x78
 0x1001		0x56
 0x1002		0x34
 0x1003		0x12
 ARM架构->ARM系列大端格式(现在既支持大端也支持小端)
 高字节的数据存放在低地址上,低字节的数据存放在高地址上
 (高对低,低对高)
 例子 : 在大端格式上存储一个十六进制的数据0x12345678
 地址		数据
 0x1000		0x12
 0x1001		0x34
 0x1002		0x56
 0x1003		0x78
可以使用共用体测试当前的机器是大端格式还是小端格式
=========================
笔试题
1.什么是大端格式?什么是小端格式?
2.设计一个程序测试当前的机器是大端格式还是小端格式
=========================

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


#include <stdio.h>
#include <stdlib.h>

struct S
{
	char c;
	short s;
	int i;
	long l;
	float f;
	double d;
};

union U
{
	char c;
	short s;
	int i;
	long l;
	float f;
	double d;
};

int main(int argc, char *argv[])
{
	struct S s;
	union U u;

	printf("sizeof(struct S) = %ld\n", sizeof(struct S));
	printf("sizeof(union U) = %ld\n", sizeof(union U));

	printf("&s = %p\n", &s);
	printf("&s.c = %p\n", &s.c);
	printf("&s.s = %p\n", &s.s);
	printf("&s.i = %p\n", &s.i);
	printf("&s.l = %p\n", &s.l);
	printf("&s.f = %p\n", &s.f);

	printf("&u = %p\n", &u);
	printf("&u.c = %p\n", &u.c);
	printf("&u.s = %p\n", &u.s);
	printf("&u.i = %p\n", &u.i);
	printf("&u.l = %p\n", &u.l);
	printf("&u.f = %p\n", &u.f);
	printf("&u.d = %p\n", &u.d);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#include <stdio.h>
#include <stdlib.h>

union U
{
	int i;
	char c[4];
};

int main(int argc, char *argv[])
{
	union U u;

	u.i = 13;
	
	printf("u.i = %d\n", u.i);
	printf("u.c[0] = %d-%p\n", u.c[0], &u.c[0]);
	printf("u.c[1] = %d-%p\n", u.c[1], &u.c[1]);
	printf("u.c[2] = %d-%p\n", u.c[2], &u.c[2]);
	printf("u.c[3] = %d-%p\n", u.c[3], &u.c[3]);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <stdio.h>
#include <stdlib.h>

union score
{
	int i;
	float f;
};

struct stu
{
	int id;
	char name[20];
	union score math;	
};

int main(int argc, char *argv[])
{
	struct stu s;
	int flag = 0;

	printf("请输入学生的ID : ");
	scanf("%d", &s.id);
	printf("请输入学生姓名 : ");
	scanf("%s", s.name);
	printf("请输入学生的成绩 : \n");
	printf("(1.整型	2.浮点型)\n");
	printf("> ");
	scanf("%d", &flag);
	switch(flag)
	{
		case 1 : scanf("%d", &s.math.i); break;
		case 2 : scanf("%f", &s.math.f); break;
	}

	printf("ID : %d\n", s.id);
	printf("姓名 : %s\n", s.name);
	switch(flag)
	{
		case 1 : printf("分数 : %d\n", s.math.i); break;
		case 2 : printf("分数 : %.1f\n", s.math.f); break;
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>
#include <stdlib.h>
//需要在无符号的环境中进行使用位域
struct S//位域/位段/位字段(在底层内核驱动时会使用的内容)
{
	unsigned int x : 1;
	unsigned int y : 2;
	unsigned int z : 1;
};

union U
{
	char c;
	struct S s;
};

int main(int argc, char *argv[])
{
	union U u;

	u.c = 13;

	printf("u.s.x = %d\n", u.s.x);
	printf("u.s.y = %d\n", u.s.y);
	printf("u.s.z = %d\n", u.s.z);

	return 0;
}

位域

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


#include <stdio.h>
#include <stdlib.h>

struct GPIO
{
	unsigned char PA0 : 2;
	unsigned char PA1 : 2;
	unsigned char PA2 : 2;
	unsigned char PA3 : 2;
	unsigned char PA4 : 2;
	unsigned char PA5 : 2;
	unsigned char PA6 : 2;
	unsigned char PA7 : 2;
	unsigned char PA8 : 2;
	unsigned char PA9 : 2;
	unsigned char PA10: 2;
	unsigned char PA11: 2;
	unsigned char PA12: 2;
	unsigned char PA13: 2;
	unsigned char PA14: 2;
	unsigned char PA15: 2;
};
/*
	输入功能	0->00
	输出功能	1->01
	复用功能	2->10
	模拟功能	3->11
*/
int main(int argc, char *argv[])
{
	struct GPIO P;

	P.PA0 = 1;

	P.PA10 = 2;

	return 0;
}

03c_13day

Thu, 16 Feb 2023 08:03:05 +0800

03c_13day

===========================
2022-8-1
===========================

一.温故知新

 复合型数据类型
 结构体
 1.先定义结构体类型
 struct tag
 {
 //结构体成语的定义
 };
 2.再使用结构体类型定义结构体类型的变量\指针\数组
 数据类型		变量名	;
 struct tag		s		;
 struct tag *	p		;
 struct tag		arr	[成员个数]	;
 3.结构体类型的变量访问结构体的成员
 变量名 + . + 成员名
 结构体类型的指针访问结构体的成员
 指针名 + -> + 成员名
 4.通过sizeof运算符结算结构体大小
 结构体的大小相当于成员大小的和 + 字节对齐
 共用体
 共用体中的成员会共用同一块儿存储空间
 (使用一块儿存储空间管理不同类型的数据)
 1.先定义共用体类型
 union tag
 {
 共用体成员的定义;
 };
 2.大端格式和小端格式
 大端格式
 高字节的数据存放在低地址上
 低字节的数据存放在高地址上
 小端格式
 高字节的数据存放在高地址上
 低字节的数据存放在低地址上
 3.位域(位段/位字段)
 是编程语言(C语言)提供的操作位的方法
 -----------------------------------
 位带(bitband)

枚举

 enum是C语言的关键字
 枚举就是一个被命名的整型常数的集合
enum 枚举名
{
 标识符[=整型常数],
 标识符,
 ...
 标识符
};			//枚举定义之后需要加 ; 结尾
注意:
1.在定义枚举时.标识符与标识符之间要用 , 隔开而不是 ; 
2.在枚举中标识符可以和变量同名,如果同名变量会屏蔽标识符
 (尽量不要同名)
3.在定义枚举时,方括号的内容时缺省值,可以有也可以没有
 如果没有缺省值,标识符会按照0 1 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


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b,
	c,
	d
};

int main(int argc, char *argv[])
{
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b,
	c,
	d
};

int main(int argc, char *argv[])
{
	int a = 9527;
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b = 100,
	c,
	d
};

int main(int argc, char *argv[])
{
	//int a = 9527;
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

enum E{MIN, MAX = 10};

int main(int argc, char *argv[])
{
	int i = 0;

	for(i = MIN; i < MAX; i++)
	{
		printf("i = %d\n", i);
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

enum E{MODE_0, MODE_1, MODE_2, MODE_3};

int main(int argc, char *argv[])
{
	int mode = 0;

	scanf("%d", &mode);

	switch(mode)
	{
		case MODE_0 : printf("菜鸟难度!\n"); break;
		case MODE_1 : printf("普通难度!\n"); break;
		case MODE_2 : printf("地狱难度!\n"); break;
		case MODE_3 : printf("中国男足难度!\n"); break;
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include <stdio.h>
#include <stdlib.h>

struct GPIO
{
	unsigned char PA0 : 2;
	unsigned char PA1 : 2;
	unsigned char PA2 : 2;
	unsigned char PA3 : 2;
	unsigned char PA4 : 2;
	unsigned char PA5 : 2;
	unsigned char PA6 : 2;
	unsigned char PA7 : 2;
	unsigned char PA8 : 2;
	unsigned char PA9 : 2;
	unsigned char PA10: 2;
	unsigned char PA11: 2;
	unsigned char PA12: 2;
	unsigned char PA13: 2;
	unsigned char PA14: 2;
	unsigned char PA15: 2;
};

enum mode
{
	INPUT,
	OUTPUT,
	AF,
	AN
};

int main(int argc, char *argv[])
{
	struct GPIO P;

	P.PA0 = OUTPUT;

	P.PA10 = AF;

	return 0;
}

 预处理
 条件编译
 #ifndef	__ADD_H
 #define __ADD_H
 除了在.h文件中加入,防止头文件被重复包含以外
 在.c文件中也可以使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
#if 0
	printf("Hello World!\n");
#else
	printf("你好,中国!\n");
#endif
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

#define SUB

int main(int argc, char *argv[])
{
	int a = 13, b = 7;
	int sum = 0;

#ifndef ADD
	sum = a + b;
#else
	sum = a - b;
#endif
	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

#define STM32F103CBT6

int main(int argc, char *argv[])
{
	int PIN = 0;
#if defined (STM32F103RBT6)
	PIN = 64;
#elif defined (STM32F103CBT6)
	PIN = 32;
#endif
	printf("PIN = %d\n", PIN);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <stdio.h>
#include <stdlib.h>

#define FLAG 2

int main(int argc, char *argv[])
{
	int a = 13, b = 7;
	int sum = 0;

#if FLAG==0
	sum = a + b;
#elif FLAG==1
	sum = a - b;
#elif FLAG==2
	sum = a * b;
#elif FLAG==3
	sum = a / b;
#else
	sum = a % b;
#endif

	printf("sum = %d\n", sum);
	
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

#define PAI 3.14

int main(int argc, char *argv[])
{
	printf("PAI = %f\n", PAI);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

#define ARRSIZE 10

int main(int argc, char *argv[])
{
	int arr[ARRSIZE];
	int i = 0;

	for(i = 0; i < ARRSIZE; i++)
	{

	}

	return 0;
}

 面试题
 定义一个宏,计算一年(平年)有多少秒
 
 定义一个宏,比较两个值的最大值

 3.定义一个宏,完成两个变量值的交换

 注意 : 在写宏函数的时候一定要加小括号,代表是一个整体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

#define SEC_OF_YEAR (365*24*60*60)

int main(int argc, char *argv[])
{
	printf("SEC_OF_YEAR = %d\n", SEC_OF_YEAR);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

#define MUL(A,B) (A)*(B)
//MUL(A,B)		A*B
//MUL(2+3,3+4)	2+3*3+4 = 15
int mul(int a, int b)
{
	return a * b;
}

int main(int argc, char *argv[])
{
	int a = 13, b = 7;

	printf("MUL = %d\n", MUL(2+3, 3+4));//a+b
	printf("mul = %d\n", mul(2+3, 3+4));//a+b

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>

#define MAX(A,B) A>B?A:B
//a++ > b++ ? a++ : b ++

int max(int a, int b)
{
	return a > b ? a : b;
}

int main(int argc, char *argv[])
{
	int a = 13, b = 7;

	printf("MAX = %d\n", MAX(a++, b++));
	a = 13;
	b = 7;
	printf("max = %d\n", max(a++, b++));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

//#define SWAP(A,B) {typeof(A)tmp; tmp=A; A=B; B=tmp;}
//#define SWAP(A,B) {(A)=(A)+(B);(B)=(A)-(B);(A)=(A)-(B);}
#define SWAP(A,B) {(A)^=(B);(B)^=(A);(A)^=(B);}

int main(int argc, char *argv[])
{
	int a = 13, b = 7;

	printf("a = %d b = %d\n", a, b);
	SWAP(a,b);
	printf("a = %d b = %d\n", a, b);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	printf("__DATE__ = %s\n", __DATE__);
	printf("__TIME__ = %s\n", __TIME__);
	printf("__FILE__ = %s\n", __FILE__);
	printf("__LINE__ = %d\n", __LINE__);
	printf("__FUNCTION__ = %s\n", __FUNCTION__);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 3, b = 4, c = 5;

	if((a + b > c) && \
		(a + c > b) && \
		(b + c > a))
	{
		printf("可以构成三角形!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

#define PRINT_STR(n) #n

int main(int argc, char *argv[])
{
	printf("PRINT_STR = %s\n", PRINT_STR(12+34));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

#define INT_VAR(n) var##n

int main(int argc, char *argv[])
{
	int var1 = 100;
	int var2 = 200;
	int var3 = 300;
	int var4 = 400;
	int var5 = 500;

	printf("VAR = %d\n", INT_VAR(2));//var2
	printf("VAR = %d\n", INT_VAR(5));//var5

	return 0;
}

03c_c_note

Thu, 16 Feb 2023 08:03:05 +0800

03c_c_note

=============================

2022-7-15

=============================

一.编辑器

 vi
 gedit
 emacs
 ...
 我们主要使用vim

二.编译器

 gcc -> cc
虽然我们称gcc是C语言的编译器,但使用gcc编译C语言源代码文件不仅仅是编译的过程,而是要经历四个相互关联的步骤∶预处理(也称预编译)->编译->汇编->链接.
 1.从一个.c文件编译成可执行文件需要经历4个阶段
 预处理器
 编译器
 汇编器
 链接器
 2.预处理时需要哪些操作
 文件包含
 宏定义
 条件编译

 gcc
 gcc 文件名	编译.c程序
 
 gcc hello.c
 什么也没有提示	证明程序没有问题(语法),编译通过
 并不代表程序执行完全正确
 报出警告			会生成可执行文件,有可能执行成功	
 报出错误			100%程序有问题,不会生成可执行文件

 gcc -Wall 1.c
 W	警告
 all	所有
 gcc -o hello hello.c
 指定编译之后生成的可执行文件的名字
 编译生成 二进制可执行文件a.out
 执行./a.out

三.代码实例

 #include <stdio.h>
 /*
 #include	文件包含
 在C语言中以#开头是预处理的内容
 预处理阶段包括	文件包含	宏定义	条件编译
 stdio.h		头文件(.h结尾)标准的输入输出
 <...>		默认从/usr/include找头文件
 "..."		默认从本地目录中找头文件
 */

 int main(void)//void	空
 {
 printf("hello world!");
 /*
 printf是一个功能函数(打印输出的函数	终端中)
 在C语言中双引号引起来的表示为 字符串
 在C语言中单引号引起来的表示为 字符
 字符串 是由 一个一个字符组成的
 默认字符串最后有尾0 '\0'
 "hello" = 'h' + 'e' + 'l' + 'l' + 'o' + '\0'
 */

 return 0;
 /*
 return 也属于跳转语句,默认函数中碰到return函数就结束了
 return之后的值会返回给调用者
 返回值
 1.返回的是结算结果
 2.返回函数执行状态
 0		函数正常结束
 正值	函数有异常
 负值	函数有错误
 */
 }
 main函数(主函数)	
 当执行程序时是从主函数进入,从上往下逐条逐条执行,程序结束时从主函数退出
 1.函数的声明
 函数的返回值类型 函数名(参数);//形参
 2.函数的实现
 函数的返回值类型 函数名(参数)//形参
 {
 函数功能;
 }
 3.函数的调用
 函数名(参数);//实参

四.printf打印之转义字符(见C截图)

 注意虽然在写转义字符时是 \ + X,但是是一个字符

 转义字符		意义								ASCII码值（十进制）
 \a			响铃(BEL)						007
 \b			退格(BS) ，将当前位置移到前一列		008
 \f			换页(FF)，将当前位置移到下页开头	012
 \n			换行(LF) ，将当前位置移到下一行开头	010
 \r			回车(CR) ，将当前位置移到本行开头	013
 \t			水平制表(HT) （跳到下一个TAB位置）	009
 \v			垂直制表(VT)						011
 \\			代表一个反斜线字符''\'				092
 \'			代表一个单引号（撇号）字符			039
 \"			代表一个双引号字符					034
 \?			代表一个问号						063
 \0			空字符(NULL)						000
 \ddd		1到3位八进制数所代表的任意字符		三位八进制
 \xhh		1到2位十六进制所代表的任意字符		二位十六进制

五.printf打印之标准化输出格式(见C截图)

 字符		对应数据类型		含义
 d / i	int				接受整数值并将它表示为有符号的十进制整数，i是老式写法
 o		unsigned int	无符号8进制整数(不输出前缀0)
 u		unsigned int	无符号10进制整数
 x / X	unsigned int	无符号16进制整数,x对应的是abcdef,X对应的是ABCDEF（不输出前缀0x)
 f(lf)	float(double)	单精度浮点数用f,双精度浮点数用lf(尤其scanf不能混用)
 e / E	double			科学计数法表示的数,此处"e"的大小写代表在输出时用的"e"的大小写
 g / G	double			使用以上两种中最短的形式，大小写的使用同%e和%E
 c		char			字符型。可以把输入的数字按照ASCII码相应转换为对应的字符
 s / S	char *			字符串。输出字符串中的字符直至字符串中的空字符
 (字符串以'\0‘结尾，这个'\0'即空字符)
 p		void *			以16进制形式输出指针
 n		int *			到此字符之前为止，一共输出的字符个数，不输出文本
 %		无输入			不进行转换，输出字符‘%’（百分号）本身
 m		无				打印errno值对应的出错内容,(例: printf("%m\n"); )

 注：%g、%G在小数点位数四位或指数大于等于精度时用%e、%E，否则用%f。
 ---------------------
 标准化输出格式
 是由 % + * 组成,不是字符
 %		是占位符号
 %.2f	输出小数点后两位
 %.1f	输出小数点后一位
 %3d		输出的十进制数字最少占用3个字符位置
 %03d	空出的补0

六.变量

 1.变量是用来存储数据(在内存中进行存储)
 2.变量的定义
 数据类型	变量名;
 int			a;
 1>	数据类型分类
 整型		有/无符号		short int long
 实型		有符号		float double
 字符型	有/无符号		char
 2>	测试自己所用机器的类型所占字节数
 sizeof()是一个运算符,单位是字节
 sizeof(变量名/数据类型)
 1字节 = 8位
 3>	变量名的要求
 1)	变量名是区分大小写的
 2)	变量名不能与C语言的关键字重复
 3)	变量名可以由数字 字母 下划线组成,但是不能以数字开头
 4)	变量名尽量见名生义
 4>	在使用变量时需要注意的点
 1)	先定义再使用
 2)	便于编译时检查错误,不同类型的变量有不同的运算要求
 3)	定义变量之后,类型确定了,将来所占用的存储空间就确定了
 3.变量的赋值
 变量名	=	数值;
 a		=	1000;
 在复制时,赋值运算符需要把右边的项经过计算复制给左边的项(左值)
 4.变量的初始化
 数据类型	变量名	=	数值;
 int			a	=	1000;

 char
 char存储形式,1字节8位
 有符号类型的char可以存储的数的范围是(-128~127)
 char c = 13;//0000 1101
 XYYY YYYY
 第7位	为最高位,是符号位
 第6~0位	为数据位
 char c = 127;//1111 1111
 char c = -128;//1000 0000
 
 float
 float存储形式,4字节32位

 第31位		符号位	0代表正数，1代表负数
 第30~23位	阶位		转化成规格化的二进制之后与127做和
 第22~0位		尾数

 例:
 3.2
 正的所以最高位符号位为	0
 3	转化成二进制为11
 0.2	小数部分乘2取整,然后从前往后读
 0.2 * 2 = 0.4	0
 0.4 * 2 = 0.8	0
 0.8 * 2 = 1.6	1
 0.6 * 2 = 1.2	1
 0.2 * 2 = 0.4	0
 11.001100110011...
 然后将11.001100110011...的小数点向左移至小数点前只有一个1,即左移1位.
 阶码就是1+127 = 128 即:1000 0000
 尾数:因为小数点前必为1,所以记录小数点后面的数即可 100110011001...

 0100 0000 0100 1100 1100 1100 1100 1100

七.引入scanf概念

 int a = 0;
 int b = 0;

 scanf("%d-%d", &a, &b);//接收键盘上录入的数值
 1.	scanf中只写标准化输出格式就可以了,不要写其他的
 2.	scanf中后面的变量必须要加 &(取地址)
 3.	scanf中的双引号内不要写 '\n'
 printf("a = %d\nb = %d\n", a, b);//打印到屏幕上

 return 0;
==================================
作业
 1.把今天讲过的内容完完整整的复习一遍
 明天会提问,回答不上来的同学,罚在纸上抄写10遍
 2.可以找一些编程的问题做一做
==================================

八.运算符

 1.算术运算符：* - + / %
 
 2.关系运算符： > < == != >= <=

 3.逻辑运算符：! && ||
 
 4.位运算符：<< >> ~ | ^ &(异或相同为0,不同为1)
 
 5.赋值运算符：= += -= *= /= %= >>= <<= &= |= ^=
 
 6.条件运算符：?: max = (a > b) ? a : b
 
 8.指针运算符：*和&
 *	取值
 &	取地址
 是可逆的
 
 9.求字节数运算符：sizeof()
 sizeof()	放变量/数据类型
 
 10.强制类型转换运算符：(类型)
 
 11.分量运算符：. -> (结构体)
 结构体
 共用体
 
 12.下标运算符：[ ]
 int arr[5];	//	5个成员
 arr[0] ~ arr[4]//	1.数组名 + 下标
 
 13.自增自减运算符：++ --
 6 / 2 * (2 + 1)
 
 14.其他：如函数调用运算符:()
 
 注意：条件运算符是C语言中惟一一个三目(三元)运算符

 凡是位运算都需要把操作数变成补码形式
 操作数为正数,那么补码是它的本身(原码 = 补码)
 操作数为负数,无论 原码转补码 还是 补码转原码,都是除了符号位不变,其他位按位取反再加1
 char a = 13; ~a;
 二进制(原码)
 0 0 0 0 1 1 0 1
 因为是个正数,所以补码 = 原码
 补码(取反操作之前)
 0 0 0 0 1 1 0 1
 ~
 1 1 1 1 0 0 1 0
 补码(取反操作之后)
 1 1 1 1 0 0 1 0
 反码
 1 1 1 1 0 0 0 1
 原码
 1 0 0 0 1 1 1 0

 char a = -13; ~a;
 原码
 1 0 0 0 1 1 0 1
 反码
 1 1 1 1 0 0 1 0
 补码(取反之前)
 1 1 1 1 0 0 1 1
 ~a
 0 0 0 0 1 1 0 0
 补码(取反之后)
 0 0 0 0 1 1 0 0
 原码
 0 0 0 0 1 1 0 0
=================================
作业
1.把今天讲过的内容完完整整的复习一遍
2.如果复习完之后,可以找一些编程题目做一做
=================================

=============================

2022-7-18

=============================
## 分支语句
### if
int main()
{
语句1;
if(条件)// 真假
{
语句2;
}
语句3;
}
语句1–>判断if条件(真)–>语句2–>语句3–>结束

假–>语句3–>结束

if…else

int main(void)
{
 语句1
 if(条件)
 {
 语句2
 }
 else
 {
 语句3
 }
 语句4
}
语句1-->条件判断(真)-->语句2-->语句4
 |
 假-->语句3-->语句4

if…else if…else if…

int main(void)
{
 语句1
 if(条件1)
 {
 语句2
 }
 else if(条件2)
 {
 语句3
 }
 else
 {
 语句4
 }
 语句5
}
语句1-->判断条件1(真)-->语句2-->语句5
 |
 假-->判断条件2(真)-->语句3-->语句5
 |
 假-->语句4-->语句5

//比较两个值是否相等一定要用 ==
//if 里的大括号一定不要丢

switch

语句1
switch(变量)
{
 case 条件1 ://条件是整常量 可以是 数字 或者 字符
 语句2
 break;
 case 条件2 :
 语句3
 break;
 default:
 语句4
 break;
}
语句5
语句1->(变量匹配)条件1(真)->语句2->break->语句5
 |
 假->条件2(真)->语句3->break->语句5
 |
 假->语句4->break->语句5

***************
注意:
switch里加break,
匹配完条件->执行完语句->直接跳出switch

如果不加break
匹配条件->执行语句->顺序往下执行

如果case里加return
执行到return语句直接退出程序
***************
break(可以在switch和循环中用)
跳出switch
break 和 return区别
break 是跳出 switch体
return是跳出这个函数
(main函数也是函数,如果main()函数里
 执行到return,代表程序的结束)
------------------
练习
键入一个整数x,
如果小于3则执行x+3操作,
如果大于等于3则执行3*x+9
如果大于9则执行9*x-10
------------------
homework
1.输入三个值判断这三个值是否构成三角形
(是否是直角 等腰 等边 普通 不能)	

2.输入三个整数x,y,z,请把这三个数由从小到大输出

3.学习成绩>=90分的同学用A表示,60-89分之间的用B表示，小于60用C表示

4.输入成绩
0-59 不及格
60-69 及格
70-79 中
80-89 良
90-100 优
(考虑哪个阶段的人多->程序效率上考虑)
20000学生	其中15000个学生	都是80-89

5.停车场收费系统,3小时以内,收费每小时30元,超出部分每小时50元

6.输入相应的字符打印相应的语句(默认不区分大小写)
输入a,打印	钟薛高18块钱
输入b,打印	梦龙8块钱
输入c,打印	老冰棒1块钱
输入d,打印	雪莲0.5块钱

7.判断输入的4位数是否是回文数(1221是回文数, 1234不是)

8.输入年份判断该年是否是闰年	RTC(实时时钟)
//闰年
//能被4 整除但是不能被100整除 能被400整除

9.输入一个整数,判断是否既是3 也是5 又是7的倍数 (num % 105)
==================================================
10.输入年月日,打印出是该年的第几天
//2015-9-25
是2015年的第?天

11.输入相应的字符打印相应的语句(默认不区分大小写)
输入a,打印	钟薛高18块钱
输入b,打印	梦龙8块钱
输入c,打印	老冰棒1块钱
输入d,打印	雪莲0.5块钱

12.输入成绩
0-59 不及格
60-69 及格
70-79 中
80-89 良
90-100 优
+++++++++
1.定义变量a,通过键盘录入a的值,判断a的值是否是偶数
2.定义变量year,通过键盘录入year的值,判断year是否是闰年
 能被4整除但是不能被100整除的年份是闰年
 或者能被400整除的年份是闰年
3.定义三个变量a b c,通过键盘录入三个非零的正整数
 判断是否可以构成三角形
===================================
作业:
 1.把今天讲过的内容完完整整的复习一遍
 2.复习之后,写上面的编程题目(1 - 9使用if来做)(10 - 12使用switch)
注意:
 1.千万不要忽略复习的重要性
 2.千万不要眼高手低(程序再小,也是程序,一定要亲手写一遍,才能说自己会)
===================================

=============================

2022-7-18

=============================

循环语句

for

for(循环的初始化; 循环控制部分; 循环的修改部分)
{
 循环主体;
}
for
循环初始部分……为循环变量附初值
循环控制部分……按照循环条件控制循环正常进行
循环的修改部分……循环执行中，循环变量按照一定规律变化
循环体（工作部分）……要多次循环的代码部分
#include <stdio.h>

int main(void)
{
 int i = 0;//循环变量
 int sum = 0;
 for(i = 0; i <= 100; i++)
 //i = 0循环的初始部分为循环变量赋初值
 //i <= 100循环的控制部分，控制循环的进行
 //i++循环的修改部分，修改循环变量
 //sum += i循环体，循环的主体
 {
 sum += i;
 }
 printf("sum = %d\n", sum);
 return 0;
}

流程图
 for i = 1循环初始部分
 |
 i <= 100 循环控制部分<---
 否------|是 |
 | sum = sum + i;循环体 |
 | | |
 | i++ 程序修改部分---------
 |
 |
 |
 |_______
 |
 其他语句

其他形态

(1)
 for(a = 0, b = 0; a != 3 && b != 3; a++, b++)
{

}
(2)
 for(; ;)
{
 需要循环的部分;
}
死循环
(3)
 for(a = 0; a < 10; a++)
 {
 for(b = 0; b < 10; b++)
 {
 
 }
 }

随机函数

 rand()//产生随机数
 srand()//随机种子

 int a = 0;
 int b = 0;

 srand(time(NULL));
 //rand() 产生随机数
 //srand() 随机种子
 //time(NULL) 时间
 //NULL 空
 for(a = 0; a < 10; a++)//随机取出10个(50~100以内的数)
 {
 b = rand() % 50 + 50;
 //rand() % 50 [0~49]范围
 //rand() % 50 + 50 [50~99]范围
 printf("b = %d\n", b);
 }

break

//break 应用于循环和switch中

跳出 循环
跳出 switch

//如果遇到嵌套循环的话,break 只跳出最近的循环

continue

//continue 只应用于循环当中

跳出本次循环

//如果遇到嵌套循环的话,continue也只是跳出本次循环

homework

1.
(1)打印4 * 5 的 *
例:
*****
*****
*****
*****
(2).打印i * j 的 * (i j 键盘接收)
 例:i = 4, j = 5
 //4-5 5-6
 *****
 *****
 *****
 *****
(3).打印i * j 的 * 边框(i j 键盘接收)
 例: i = 4, j = 5
 *****
 * *
 * *
 *****
2.打印99乘法表
 1 * 1 = 1
 1 * 2 = 2 2 * 2 = 4
 *
 **
 ***
 ****


3.计算1+2+3+4+5+...+n, n是从键盘输入的自然数

// 穷举
4.要将5张100元的大钞票,换成等值的50 20 10 5小钞票,每种面值至少一张,要多少张,有多少种换法

5.有1、2、3、4 4个数字,能组成多少个互不相同且无重复的三位数呢

6.有这样的一个等式,xyz+yzz=532,编程求x y z的值

7.计算1^2 + 2^2 + 3^2 + ... +10^2的结果
(1的平方 + 2的平方)

8.输入20个人的成绩,输出不及格的人数(0<=score<60 为不及格)

9.随机产生100个三位随机数,找出其中能被 3 5 7整除的数

10.打印0~100以内所有的质数
(只能被1 和 本身整除的数)

11.猜数游戏(随机产生一个1000以内的数,去猜,
 如果大了打印猜的大了,
 如果小了打印猜的小了,
 如果正确打印对的
 直到猜对了再结束,每次打印必须打印出猜的次数)

12. 把11修改成,程序开始时,先输入需要猜的数的范围n
例:(想要猜数的范围是(0~10000) 那么变量n接收键盘上10000
 范围都是从0开始)

13.
----------------------------
a + b - 9 = 4
+	-	-	
c -	d * e = 4
/	*	-
f + g - h = 4
=	=	=
4	4	4
求a b c d e f g h (0 ～ 12范围内)//除法指的是整除 c % f == 0
只有一种答案
===================================
作业:
1.把今天讲过的内容完完整整的复习一遍
2.来做上述的编程题目
3.如果还有时间可以自己再找一些题目来做
4.有问题微信上直接找张老师
===================================

while()

语句1

while(条件)
{
 循环体
}

语句2
 ---------------
 | |
 语句1 --> 条件判断(真) --> 循环体 ---|
 |(假)
 |--------------->语句2

 /*
 while(条件)//必须要有条件
 {
 主体
 }
 当满足条件的时候,进入while循环,执行循环体
 */

while(1)//死循环

=================================
do...while
//和while相比较 先执行在判断
// do...while 至少循环一次

do
{
 需要循环的语句;
}while();

n = 1;
do
{
 sum += n;
 n++;
}while(n <= 100);

==============================
break

//break 应用于循环和switch中

跳出 循环
跳出 switch

//如果遇到嵌套循环的话,break 只跳出最近的循环

continue

//continue 只应用于循环当中

跳出本次循环

//如果遇到嵌套循环的话,continue也只是跳出本次循环

goto// 跳转语句

i = 1;//循环变量的初始

loop://标记

if(i <= 100)//循环变量的的控制
{
 sum += i;//循环体
 i++;//循环变量的变化
 goto loop;//跳到标记处
}
面试题:
(1)从键盘上接收一个正整数,打印输出它的倒序
例:
12345
 54321
(2)
如果是一个负数
例:
-1234

-4321
(3)
 atoi()把字符串转换成十进制整数
 "123"		->	123
atox atoo
"0x40008000"	->	0x40008000
"1234"			->	1234
实现一个 itoa() 函数

12345
"12345"
=====================================

homework

14.求1+12+123+...前N项之和,其中N是从键盘输入的数(N取值范围（1~9）)
 n = 5;
 sum = 1 + 12 + 123 + 1234 + 12345;

15.爱因斯坦出了一道这样的数学题,有一条长阶梯,若每步跨2阶,则最后剩1阶,若每步跨3阶,则最后省2阶,若每步跨5阶,则最后剩4阶,若每步跨6阶，则最后剩5阶只有每次跨7阶,最后才正好1阶不剩,请问在这条阶梯最少多少阶

16.设N是一个4位数,它的9倍恰好是它的反序数
 例:1234 反序数是4321

17.求s = a + aa + aaa + aaaa + ... + aa...a的值,其中a是1~9的一个数字(不超过十项)
例:a = 3; s = 3 + 33 + 333;

18.“百钱百鸡”问题,百钱买百鸡,公鸡1个3块钱,母鸡1个2块钱，小鸡3个一块钱,问公鸡,母鸡,小鸡各多少个

19.打印三角形	(画8个三角形)
* * * * *
 * * * *
 * * *
 * *
 *
6_1.打印三角形
 录入n,n是直角三角形的高
 例:	n = 3
 * 
 * * * 
 * * * * *
 n = 4
 * 
 * * * 
 * * * * * 
* * * * * * * 


20.猴子吃桃问题,有一天一只猴子摘了一些桃子,它吃掉一半,又吃了一个,第二天也是这样,到了第十天,只有一个桃子了,求猴子摘了多少桃子

21. 4 5 6 7总共能组成多少个不能被4整除的4位数

22.求n!(n的阶乘)
====================================
作业
1.把今天讲过的内容完完整整的复习一遍
2.整理笔记
3.写编程题目
====================================

小项目

 电子版的口算卡
随机生成10道100以内的 [加 减 乘 除 取余] 数学题 回答正确的加10分错误不加分(把正确结果打印出来) 然后显示最后成绩。(不用float类型)	
1>	操作数随机 2>	运算符随机
gcc 1.c		当执行./a.out之后,先清屏
23 + 70 = 93
Bingo!	+10分
15 - 30 = -15
Bingo!	+10分
23 * 87 = 0
Error!	====== 正确结果打印出来
总分 70分
====================================

指针

机器
CPU 内存 硬盘
快 中 慢

int a = 100;//初始化int类型变量
int *p;//定义指针

p = &a;//把a的地址传给指针p
//& 取地址符

printf("a = %d\n", a);

*p = 200;//通过指针改变值

printf("*p = %d\n", *p);
//* 取指针所保存的地址所在的位置里的值
// 可以简化成取值

不同数据类型

printf("char = %lu\n", sizeof(c));
printf("short = %lu\n", sizeof(s));
printf("int = %lu\n", sizeof(i));
printf("float = %lu\n", sizeof(f));


int *p; int代表以后在保存地址的时候变量的数据类型
所有指针在内存中占8个字节(64位操作系统)


int a = 100;

变量名 值 址
a 100 0x1000
0x1001
0x1002
0x1003
pa 0x1000 0x2000


注意:
1.指针所占字节数不分类型都是 8个字节(分操作系统)

int *p;
char *c;
2.pa += 1//pa++改变了pa所存的地址值
当指针自增p++改变的是指针保存的地址,改变的字节数
和所存地址值的变量的类型有关p++ 改变了p所存的地址值
p+1 没有改变p所保存的地址值

3.如果想要操作指针,改变指针 用二级指针
取地址符(&)不管是变量还是指针只能加一个
对于一级指针来说,取值符(*)只能加一个

4.* 和 & 是一个可逆的过程,可以中和

printf("*(&a) = %d\n", *(&a));	对
printf("&(*a) = %d\n", &(*a));	错

/*一级指针 操作不了一级指针*/

a pa pp
值 100 &a &pa

址 0x1000 0x2000 0x3000

a pa pp
值 100 0x1000 0x2000

址 0x1000 0x2000 0x3000

======================================

二级指针

注意:
1.二级指针所占字节数不分类型都是 8个字节
(分操作系统)

int **p;
char **c;
2.
二级指针也可以做加法运算
int **p;
p + 1;	p++;	p+=1;
当二级指针偏移一个单位跨8个字节

3.如果想要操作指针,改变指针 用二级指针
取地址符(&)不管是变量还是指针只能加一个
对于一级指针来说,取值符(*)只能加一个

4.* 和 & 是一个可逆的过程,可以中和

printf("*(&a) = %d\n", *(&a));	对
printf("&(*a) = %d\n", &(*a));	错

函数

 void 空
返回值的类型 函数名(参数)
{
 功能
}

main()是程序的入口;


函数之间的调用

注意:
2.调用的函数写到被调用函数的下面
3.函数可以先定义,再写函数的实现

//函数的定义
void print(int c);

void print(int c)//显示 函数的实现
{
 printf("c = %d\n", c);
}
参数传递

值传递
a = 3, b = 4;
swap(a, b)
 当main函数调用swap函数的时候,
 只是把变量的值传过去
 相当于swap(3, 4)

地址传递
a = 3, b = 4;
swap(&a, &b)
 当main函数调用swap函数的时候,
 把a和b的地址传过去
相当于swap(0x1000, 0x2000)
/*
 如果函数想要改变main函数的变量的话,
 可以传变量的地址
 如果函数只是想用main函数地变量的值的话,
 可以传变量的值
 */
======================================

猜数游戏(随机产生一个1000以内的数,去猜,
 如果大了打印猜的大了,
 如果小了打印猜的小了,
 如果正确打印对的
 每次打印必须打印出猜的次数)


口算卡
 随机10道口算卡题目

 100 + 100 = 300
 wrong! ========= 200
 
 1.操作数100以内随机
 2.运算符 + - * / % 随机
 3.不用float
 4.多函数实现

第一阶段
 只写一个.c文件,.c文件中只有一个main函数
第二阶段
 只写一个.c文件,,c文件中有一个main函数,多个功能函数
第三阶段
 写多个文件
 main.c		主函数和功能函数调用
 func.c		功能函数的实现
 func.h		功能函数的声明
 makefile	编译规则
第四阶段
 把func.c做成库文件	动态库	静态库

======================================
作业
 1.把今天讲过的内容从头到尾复习一遍
 2.把之前打印8个三角形的程序整合一个程序,其中打印图形的功能封装成函数
 3.猜数游戏(随机产生一个1000以内的数,去猜,
 如果大了打印猜的大了,
 如果小了打印猜的小了,
 如果正确打印对的
 每次打印必须打印出猜的次数)
 4.口算卡
 随机10道口算卡题目

 100 + 100 = 300
 wrong! ========= 200
 
 1.操作数100以内随机
 2.运算符 + - * / % 随机
 3.不用float
 4.多函数实现

数组

一维数组

int a[5];

a[0]		a[1]		a[2]
1		2		3
0x1000	0x1004	0x1008

命名规则
int a[5] = {1, 2, 3, 4 ,5};
int b[5] = {0};
waring!
int c[] = {1, 2, 3, 4, 5};
 int a[10];
 int *p = a;

 a[i]; 数组+下标
 p + i; 指针+偏移
 a + i; 数组名+偏移
 	p[i]	指针+下标

&arr[0] = 0xbf8c97ec	1
arr = 0xbf8c97ec		2
&arr = 0xbf8c97ec		3
1 2 数组首元素的地址
3	数组的地址
+++++++++++++++++++++
&arr[1] = 0xbf8c97f0	
arr + 1 = 0xbf8c97f0
&arr + 1 = 0xbf8c9800


一维数组特性
1.数组名可以当指针来用,利用地址加法运算,计算出数组元素地址加*取出地址中的内容
注:a[i] = *(a + i)

2.sizeof(数组名) = 整个数组长度(整个数组所占字节数)

3.数组名是常量，不能改变指向

p = &i;//指针可以保存别的地址
a = &i;//数组名不可以

*(a + i);
a += i;//a = a + i	a++;	数组名都不可以这样操作
4.数组名可以当指针来用,但是,不是指针

多维数组

 int a[15][15]
 char a[15][15]
int a[2][3] = {0} 
a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]

内存
a[0][0] 0x0
a[0][1] 0x4
.
.
.
a[1][2]

在内存中是顺序的存储

命名规则
int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int a[3][4] = {0};
int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
////!!!!!
int a[][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

二维数组中行数可以省略,列数不可以

二维数组特性
1.数组名可以当指针来用,利用地址加法运算,计算出数组元素地址

 加*取出地址中的内容
 注: a[1][2] = *(*(a + 1) + 2)
 a[2][3] = *(*(a + 2) + 3)
 a[i][j] = *(*(a + i) + j)
2.sizeof(数组名) = 整个数组长度(不是指针长度)

 a[4][5];
 sizeof(a) / sizeof(a[0]) 算多少行
 sizeof(a) / sizeof(a[0][0]) 算数组成员个数
 注: 算多少行sizeof(a)/sizeof(a[0])
算多少列sizeof(a[0])/sizeof(a[0][0])
 sizeof(a)是整个数组的大小
sizeof(a[i]是第i行的大小)

 3.数组名是常量,不能改变指向

 4.数组名可以当指针使用,但不是指针

 printf("&a[0][0] = %p\n", &a[0][0]);
 //数组首元素的地址
 printf("a[0] = %p\n", a[0]);
 //首行第一个元素的地址
 printf("a = %p\n", a);
 //首行的地址
 printf("*a = %p\n", *a);
 //首行第一个元素的地址
 printf("&a = %p\n", &a);
 //数组的地址




 三维数组 => 多个二维数组组成
 int a[2][4][4] ={{{0,0,,0},
			{0,0,0,0},
			{0,1,0,0},
			{0,1,1,1}},
 {{0,0,0,0},
				{0,0,0,1},
				{0,0,0,1},
				{0,0,1,1}}}
 指针与数组

 在机器中都是用指针操作的

a[0] = *(a + 0)
a[1] = *(a + 1)
 ...
a[i] = *(a + i)

二维数组与指针

 二维数组的可以当一个指针使用
a[1][2] = *(*(a + 1) + 2)
a[2][3] = *(*(a + 2) + 3)
 ...
a[i][j] = *(*(a + i) + j)

三维数组和指针

 三维数组的可以当一个指针使用
a[1][2][3] = *(*(*(a + 1) + 2) + 3)
a[2][3][4] = *(*(*(a + 2) + 3) + 4)
 ...
a[i][j][k] = *(*(*(a + i) + j) + k)

数组和函数

/*
 一维数组
 int arr[5];
 调用时: init(arr);直接传数组名
 实现时: void init(int *p) 或 void init(int arr[5]) void init(int arr[])
 二维数组
 int arr[4][4]
 调用时: init(arr);
 实现时: void init(int p[][4]) 或 void init(int p[4][4])

 */
//当main函数中函数传参是数组名的时候,
//函数中可以用数组形式或者指针形式

//当main函数中函数传参是二维数组的数组名的时候,
//函数中可以用数组形式
=============================

homework

(1)输入十个人的身高,求出平均值,并把小于平均值的打印出来	

(2)输入十个人的身高,要求排序,从低到高打印

 排序		(冒泡	选择)

例:
100 201 50 70 30

(3)完成itob函数(十->八)
十 -> 二
void itob(int num, int arr[8]);
100
01100100

(4)
 阅读
 man strcpy	
 man strcat
 man strcmp
 man strlen

(5)
有1000发子弹,要提前装到10个箱子里面，接收键盘输入，要取多少颗子弹数，只能显示整箱的个数，问这10个箱子怎么装,编程实现
============================
========================
小项目:五子棋
 1.player VS player
要求
 1>最少完成p v p版本
 2>用多函数实现
 3>完成五子棋最基本功能即可
 4>要有适当的提示信息
 5>代码中要有注释
 6>完成后上传到邮箱中(402403579@qq.com)
 2022-2-11_张三.c
提示
 1>棋盘存储
 2>坐标的打印
 3>玩家的替换
 4>下到重复位置/下出边界以后的处理
 5>判断赢的条件


字符数组初始化
char a[6] = {'a','b','c','d','e','f'};
char b[6] = {'h','i','j','k','l','\0'};
char c[] = {'h','i','j','k','l','m'};
char d[] = "hello world";

 "..."	字符串,默认最后有\0

如果碰到了 \0 表示结束,字符串, %s

char arr[100] = "hello world!";//字符数组 存储功能
char *p = "hello world!";//字符指针 只是保存地址
//字符指针保存的是 常串 的地址


================================
 周末作业
1.把这一周讲过的内容先完完整整的复习一遍,有问题直接问
2.阅读man手册 strcpy strcat strcmp strlen
3.调用系统实现的string函数的功能,实现自己写的功能
 mystrcpy mystrcat mystrcmp mystrlen
4.后续作业的1 - 5题

5.剩余时间去做五子棋的项目

work

man string.h
string一族的函数,strcpy strcmp strcat strlen

char *mystrcpy(char *dst, const char *src);

char *mystrcat(char *s1, const char *s2);

int mystrcmp(const char *s1, const char *s2);

size_t mystrlen(const char *s);	

char *p = "root:x:0:0:root:/root:/bin/bash";

homework

1.输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

2.输入一个字串，判断它是否是对称串。如”abcdcba”是对称串，”123456789”不是。

3.输入一行字符串，按如下规则加密：如果是英文字母则大写变小写、小写变大写，对非英文字符则保持不变。试写加密程序。

4.输入一行小写英文字母，按如下规则加密：a→c、b→d、…、x→z、y→a、z→b，试写加密程序。

5.输入一行英文，已知各单词之间用1个空格相隔（设第一个单词前没有空格），统计这行英文有多少个单词。

6.完成atoi函数
 int myatoi(const char *nptr);

7.完成itoa函数
 void itoa(int data, char str[]);

如果不是自己开辟内存空间,当程序结束后自己释放掉

如果不是自己开辟内存空间,当程序结束后自己释放掉
[不用程序员管理]
*****************
谁开辟,谁释放 [程序员自己开辟空间]/*内存耗尽 内存泄露*/
谁创建,谁销毁 [链表]/*泄露*/
谁加锁,谁解锁 [线程]/*防止Bug*/
谁打开,谁关闭 [文件操作]/*泄露*/
*****************

代码区
 管不了
栈区
 系统帮助程序员管理
 不需要程序员自己开辟空间,释放空间
 自动释放
堆区
 malloc->free
 zalloc->free
 程序员需要自己管理的内存空间
 自己开辟,自己释放
 申请和释放都是程序员管理
 (忘记释放会使内存耗尽)
全局区
 全局变量
常数区
 程序结束才会释放
 (char *p1 = NULL;)
 (p1 = "abc";)
内存 真实存储 4G
只用内存真实空间 4K
虚拟内存 4G
1G kernel(内核)
--------------------
3G environment/cmd环境变量(系统设定的全局变量)和命令->argc argv
int main(int argc, char *argv[])
栈向下 从高地址到低地址


堆向上 从低地址到高地址
.bss 静态存储区(全局变量,静态变量) !未初始化
.date 初始化的 不为0 !已初始化
RO date 只读数据段
.text 代码段

.bss存在可执行文件中
.date不存在可执行文件中


 char *p = "abc";


=====================================



 printf.o
 				|	
 				V
 可重定位	可执行
 源程序	被修改的源程序	汇编程序	 目标程序	 目标程序
 hello.c---->hello.i---->hello.s---->hello.o---->hello
 预处理器(cpp) 编译器(ccl) 汇编器(as) 连接器(ld)

 第一个阶段	只写一个main.c
 第二个阶段	多函数
 第三个阶段	多文件
 func.c
 func.h
 main.c
 makefile


makefile
一个工程中的源文件不计其数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为 makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

=====================================

变量作用域

存储区域 作用域 生命周期

全局变量 局部变量

==========================================================

全局变量

1.尽量不使用全局变量
2.使用时加static(静态)
3.显示初始化

main.c
#include <stdio.h>

 int xxx;

int main(void)
{
 printf("main.xxx = %d\n", xxx);
 foo();
 printf("main.xxx = %d\n", xxx);
 return 0;
}
foo.c
#include <stdio.h>

int xxx;
int foo()
{
 xxx++;
 printf("foo.xxx = %d\n", xxx);
}
全局变量中默认定义的变量值为0;

变量与函数关系
外部变量
内部变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


#include <stdio.h>
int x=1; //外部变量 全局变量
//1、生命周期 整个程序
//2、作用域 整个程序
//3、存储区域 全局区
void A()
{
	int y=1;//内部变量 局部变量
	//1、生命周期 函数体内
	//2、作用域 函数体内
	//3、存储区域 栈区
	x++;
	if(1)
	{
		int z=0;//块级变量
		//1、生命周期 块内有效
		//2、作用域 块内有效
		//3、存储区域 栈区
		printf("z=%d\n",z);
	}
	{

		int m=0;//块级变量
		//1、生命周期 块内有效
		//2、作用域 块内有效
		//3、存储区域 栈区
		printf("m=%d\n",m);
	}
	printf("A中的x=%d\n",x);
	printf("A中的y=%d\n",y);
	printf("A中的&y=%p\n",&y);
}
void B()
{
	x++;
	int i;
	int j;
	int y;
	int k;
	printf("B中x=%d\n",x);
	printf("B中的y=%d\n",y);
	printf("B中的&y=%p\n",&y);
}
void C()
{
	int x=100;
	printf("C中的x=%d\n",x);
	{
		int x=1000;//(1)如果是x = 1000;
		printf("C块中的x=%d\n",x);
	}
	printf("C中的x=%d\n",x);//(1)x = 1000;

}
int main()
{
	A();
	B();
	C();
	return 0;
}

静态变量

1.存储区域 全局静态区
2.作用域 函数体内
3.生命周期 整个程序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


	#include <stdio.h>
	static int z = 1; //静态外部变量限定作用
	//1.存储区域 全局区(静态区)
	//2.作用域 本文件
	//3.生命周期 整个程序
	int m = 0;//外部变量
	
	void A()
	{
		static int x = 0;//静态内部变量
		//1.存储区域 全局区(静态区)
		//2.作用域 函数体内
		//3.生命周期 整个程序
		int y = 1;//内部变量(栈区)
		x++;
		y++;
		printf("x = %d\n", x);
		printf("y = %d\n", y);
	}
	{
	 12 if(i == 0)
	 13 return ;
	 14 printf("%d", i % 10);
	 15 func(i / 10);
	 16 }
	
	int main(void)
	{
		A();//第一次调用x初始化一次,以后就不初始化了
		A();
		A();
		A();
		return 0;
	}
	```		
##	函数与函数之间的关系
	//函数与函数之间是外部关系(并列)
	//函数体内不能再写函数
	//静态函数(本函数只能在本文件使用)
	
	/*函数与函数之间的关系*/
	```C
	#include <stdio.h>
	void A();//声明函数
	void B();
	
	void A()//函数与函数之间是外部关系(并列)
		//函数体内不能再写函数
	{
		B();
		printf("A func()\n");
	}
	
	void B()//静态函数(本函数只能在本文件使用)
	{
		printf("B func()\n");
	}
	//A 不能调用B
	//B 可以调用A
	int main(void)
	{
		A();
		return 0;
	}

=====================================
写C语言程序的四个阶段
第一阶段	只写一个.c文件,在.c文件中只写一个main函数,把所有功能都放到main()中
第二阶段	只写一个.c文件,在.c文件中除了main函数以外还有其他的功能函数
 函数的声明
 函数的返回值类型 函数名(参数列表);//该位置的参数叫做形式参数

 函数的实现(函数的定义)
 函数的返回值类型 函数名(参数列表)//该位置的参数叫做形式参数
 {
 功能代码
 }

 函数的调用
 函数名(参数);//该位置的参数叫做实际参数

 函数名是函数的入口地址,函数名就是地址
 形式参数接收实际参数的值
 值传递		
 地址传递	
第三阶段	多文件的方式实现项目
 main.c				存放main函数,以及功能函数的调用
 func.c				存放功能函数的实现
 func.h				存放功能函数的声明,以及各种定义
 makefile(Makefile)	存放编译规则
第四阶段	把.c文件做成库文件
 动态库
 静态库

二.makefile的简介

 一个项目工程中的源文件不计其数,这些源文件按类型、功能、模块分别放在若干个目录中.
 makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译.
 哪些文件需要重新编译,甚至于进行更复杂的功能操作.
 因为 makefile 就像一个Shell脚本一样,其中也可以执行操作系统的命令.
----------------------------------------
 vim 打开多个文件
 vim * -p	多文件以标签的形式打开
 注意 : 不能打开过多的文件,否则vim会崩溃
 用ctrl + alt + pgup / pgdn切换文件
----------------------------------------

三.C语言的作用域

1.空间的分布
 C语言会把内存分为5个区域(栈区 堆区 常量区 全局区 代码区)
 --------------------------------------------------------
 ./a.out->是由进程在执行可执行程序时分配存储空间
 ->4Kb(物理)->4Gb(虚拟空间)

 1Gb		Kernel(内核)
 --------------------
 3Gb		命令行参数和环境变量int main(int argc, char *argv[])
 栈区
 👇
 空白
 ☝
 堆区
 静态区(全局区)未初始化的(系统默认会初始化成0)
 静态区(全局区)已初始化的
 常量区(RO DATA)只读的区域
 代码区

 栈区	不需要程序员来管理,自己开辟,自己释放
 堆区	需要程序员来管理,手动开辟,手动释放(malloc realloc zalloc free)
 静态区	全局变量/static关键字修饰的变量
 常量区	read only(只读)
 代码区	程序员没有办法管理

2.全局变量和局部变量
 
 局部变量
 在某个函数内部或者程序块内部定义的变量叫做局部变量
 局部变量只能在该函数的内部 或者 该程序块的内部使用
 局部变量在函数外部是不可知的

 全局变量
 全局变量是定义在函数外部的,通常写到程序的顶部
 全局变量在整个程序中生命周期都是有效的
 在任意函数的内部都可以访问全局变量

 注意:
 全局变量和局部变量可以同名
 如果出现了同名的情况,那么在执行函数时优先使用局部变量,
 在该函数中全局变量被屏蔽了

 全局变量和局部变量在定义时的区别
 当定义局部变量时,系统不会帮助初始化,局部变量内部存储的是垃圾值
 当定义全局变量时,系统会帮助初始化
 int -> 0
 char -> '\0'
 pointer -> NULL

 全局变量和局部变量存储空间的区别
 全局变量 : 保存在内存的静态全局区,占用的是静态的存储单元
 当程序运行时已经被创建了,当程序结束时被释放
 局部变量 : 保存在内存的栈区中,只有在局部变量所在的函数被调用时,
 系统才会帮助分配存储单元,当局部变量所在的函数结束时被释放

四.存储类关键字

1.extern关键字
 extern是C语言中的关键字
 修饰的是外部的
 可以修饰函数,也可以修饰变量			
 1>如果函数被extern关键字修饰了,证明其他文件也可以使用这个函数,
 如果定义的函数不想被其他文件使用,可以使用static关键字修饰
 2>如果变量被extern关键字修饰了,需要注意不要初始化,在Linux gcc环境中会报Error
 如果在本文件中函数或者变量使用extern关键字修饰了
 说明该函数或者变量在别的文件中定义了,在当前文件中使用
 当编译器在编译程序时,如果碰到了extern关键字,那么会从别的文件中查找相关的定义

2.static关键字
 static是C语言中的关键字
 修饰的是静态的(内部的)
 可以修饰函数,也可以修饰变量
 为了使全局变量可以安全的使用,请在定义全局变量时,使用static关键字进行修饰
 a.如果全局变量没有使用static关键字修饰,可以跨文件使用
 A.如果全局变量使用了static关键字修饰,仅限于在当前文件内使用

 b.如果局部变量没有使用static关键字修饰,该局部变量存储在栈区中,当函数结束后被释放
 B.如果局部变量使用了static关键字修饰,该局部变量存储在静态区中,当程序结束后被释放

 c.如果局部变量没有使用static关键字修饰,每次调用函数该局部变量都会被重新初始化
 C.如果局部变量使用了static关键字修饰,只在第一次调用函数时进行初始化,也是唯一的一次初始化

 d.被static关键字修饰的内容,系统会默认进行初始化

 1>如果函数被static修饰了,该函数只能在本文件内使用,不能跨文件使用
 static void swap(....)
 {
 
 }	
 void pop_sort(....)
 {
 
 }
 2>如果变量被static修饰了

 3>静态变量
 静态变量所占用的存储空间是静态区
 静态的全局变量 : 只能被变量所定义的文件中进行使用
 (其他文件即使加了extern关键字也使用不了)
 静态的局部变量 : 只能被变量所在的代码块中进行使用
 总结 : 
 如果本文件内的函数和变量想要让别的.c文件使用,可以加extern
 如果本文件内的函数和变量不想让别的.c文件使用,可以加static
================================
简答题
1.C语言的关键字extern是用来修饰什么的?
 答 : 
 关键字的特点
 extern修饰变量 :
 extern修饰函数 : 
2.C语言的关键字static是用来修饰什么的?
 答 : 
 关键字的特点
 static修饰变量 :
 全局变量
 局部变量
 static修饰函数 :
3.C语言的关键字const是用来修饰什么的?
 
4.C语言的关键字volatile是用来修饰什么的?
 答 :
 防止编译器优化
================================

四.函数的关系

 1.主函数调用功能函数
 2.功能函数调用其他的功能函数
 3.功能函数自己调用自己(递归函数)
 
 递归函数
 C语言是支持函数的递归,递归其实就是自己调用自己
 注意 : 
 1.在写递归函数时最重要的就是退出条件
 如果写的退出条件不清楚,那么递归函数肯定会出问题
 
 2.在看别人写的递归程序时,递归次数不要太多

 3.在项目中尽量不去使用递归,因为递归函数占用空间

 递归函数可以解决的问题
 数学 : 
 1.从1 + 2 + .. + 100
 2.一个数的阶乘
 3.斐波那契数列
 4.杨辉三角

 编程 : 
 1.栈式存储结构的问题
 2.树状存储
 3.汉诺塔游戏(河内塔)
===================================
 指针常量 常量指针
 指针函数 函数指针 函数指针数组
 指针数组 数组指针

 指针 函数 数组
 容易混淆的声明
 const关键字
 const关键字是用来修饰只读的(常量)
 
 指针常量	: 指针是常量
 定义		: int * const p;
 特点		: 指针的指向不能通过指针名进行改变,可以通过该指针修改指向空间的数据
 当在程序中定义了指针常量,必须要有初始化
 用处		: 数组名

 常量指针	: 指针指向常量
 定义		: const int *p; const char *src; char const *src;
 特点		: 指针的指向能通过指针名进行改变,不可以通过该指针修改指向空间的数据
 用处		: 字符串操作
 -------------------------------
 const int *p;
 int const *p;
 int * const p;
 const int * const p;
 int const * const p;
 -------------------------------

 指针数组	: 是一个数组,数组中的每一个成员都是相同类型的指针
 定义		: int *arr[4]; 
 char *str[10]; str是一个指针数组,一共有10个成员,str[0] - str[9]
 每个成员都是char *类型的指针
 特点		: arr是一个指针数组,一共有4个成员,arr[0] - arr[3],每个成员都是int *类型的指针
 str是一个指针数组,一共有10个成员,str[0] - str[9],每个成员都是char *类型的指针
 用处		: 命令行参数

 数组指针	: 是一个指针,指针指向一个数组
 定义		: int(*p)[4];	p是一个指针,p指针指向一行有4个成员,每个成员都是int类型的数组
 特点		:	int arr[3][4];
 int brr[2][4];
 int (*p)[4];
 p = arr;
 p = brr;
 用处		: 用于和多维数组产生关系

 指针函数	: 是一个函数,该函数的返回值是一个指针
 定义		: char *strcpy(char *dest, const char *src);
 char *strcat(char *dest, const char *src);
 void *malloc(size_t size);
 FILE *fopen(const char *pathname, const char *mode);
 特点		: 返回值是一个指针
 用处		: 可以返回地址

 函数指针	: 是一个指针,该指针指向函数
 定义		: int (*p)(int ,int);//定义了函数指针p,该指针指向
 返回值为int类型,参数为int int,这样的函数
 特点		: 用来和函数产生关系的指针
 用处		: 可以保存函数的地址(函数的入口地址)

 函数指针数组 : 是一个数组,数组中的每一个成员都是函数指针
 定义		 : int (*arr[4])(int , int);
-------------------------------------------------
一.给了定义,用文字进行描述(注意 : 描述清楚)
 int a; 		 
 int a[4]; 
 int *a; 
 int a(int ,int); 

 int *a[4]; 
 int (*a)[4]; 
 int *a(int, int); 
 int (*a)(int, int); 
 int (*a[4])(int, int); 

二.给了文字描述,使用特定的变量名进行定义 (a)	(加 ; )

三.给了英文描述,使用特定的变量名进行定义 (a)	(审题 + 代码标准)
a) 一个整型数（An integer）

b) 一个指向整型数的指针（A pointer to an integer）

c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）

d) 一个有10个整型数的数组（An array of 10 integers）

e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）

f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer

argument and return an integer ）

 

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
-------------------------------------------------
===================================
今日测验

1.完成最少两种排序方法
2.完成atoi函数
 int myatoi(const char *nptr);
3.求30000000 - 30001000以内的素数
===================================

============================

2020-3-9

============================
## 结构体联合枚举预处理

C语言是面向过程的编程语言

=========结构体=============
结构体指的是一种数据结构,是C语言中复杂数据类型的一类。
结构体可以被声明为变量、指针或数组等,用以实现较复杂的数据结构.
结构体同时也是一些元素的集合,这些元素称为结构体的成员,
且这些成员可以为不同的类型,成员一般用名字访问.

1.结构体的定义
2.结构体类型的变量
 1>初始化
 2>简单赋值
 3>通过scanf()赋值
 4>查看所占字节数
 5>查看地址
 6>和指针关系
 7>和函数之间的传参
3.结构体数组
 1>初始化
 2>简单赋值
 3>通过scanf()赋值
 4>查看所占字节数
 5>查看地址
 6>和指针关系
 7>和函数之间的传参
-----------------------------------------

一.结构体定义

为了定义结构,必须使用 struct 关键字
struct tag			//tag是结构体标签
{
 member-list;	//member-list是结构体成员,一般来说写的是定义(变量 数组 指针)
 member-list;
 member-list;
 ...
}variable-list;		//variable-list是结构体类型的变量,定义在结构体的末尾,可以定义多个结构体类型的变量

注意 : 无论定义结构体还是定义了结构体类型的变量都需要在最后加分号 ;

二.定义方式

1.
struct
{
 int a;
 char b;
 double c;
}s1;
//上述定义了拥有3个成员的结构体,分别为int的a,char的b和double的c
//同时又定义了结构体变量s1
//这个结构体并没有标明其标签

2.
struct SIMPLE
{
 int a;
 char b;
 double c;
};
//上述定义了拥有3个成员的结构体,分别为int的a,char的b和double的c
//结构体的标签被命名为SIMPLE,没有定义结构体类型的变量

struct SIMPLE t1, t2[20], *t3;
//用SIMPLE标签的结构体定义了结构体类型的变量t1 结构体类型的数组t2 结构体类型的指针t3

3.
typedef struct
{
 int a;
 char b;
 double c; 
}Simple2;
//也可以用typedef创建新类型
Simple2 u1, u2[20], *u3;

注意 :
在上面的结构体定义中<第一种>和<第二种>声明被编译器当作两个完全不同的类型,即使他们的成员列表是一样的,
如果令 t3=&s1 是违法的操作,编译器会报警告

三.定义结构体时,结构体的成员

1.
struct SIMPLE
{
 int a;
 char b;
 double c;
};
struct COMPLEX
{
 char string[100];
 struct SIMPLE a;//结构体的成员是其他结构体类型的变量(可以和其他结构体类型的成员同名)
 //因为struct COMPLEX结构体定义中存在struct SIMPLE结构体类型的成员
 //所以应该把struct SIMPLE定义放到struct COMPLEX之前
};

2.
struct NODE
{
 char string[100];
 struct NODE *next_node;//结构体的成员是自己结构体类型的指针(一般来说在链表或者树中经常使用)
};

3.如果两个结构体互相包含,则需要对其中一个结构体进行不完整声明,如下所示:
struct B;				//对结构体B进行不完整声明
struct A
{
 struct B *partner;	//结构体A中包含结构体B类型的指针
 //other members;
};
struct B
{
 struct A *partner;	//结构体B中包含结构体A类型的指针
 //other members;
};


注意 :
当定义结构体时结构体的成员可以是其他结构体类型的变量
 结构体的成员也可以是自己结构体类型的指针
 当然不可以是自己结构体类型的变量
 而通常自己结构体类型的指针的应用是为了实现一些更高级的数据结构如链表和树等.

位域(位段/位字段)
有些信息在存储时,并不需要占用一个完整的字节,而只需占几个或一个二进制位.
例如存放一个开关量时,只有 0 和 1 两种状态,用 1 位二进位即可.
为了节省存储空间,并使处理简便,C 语言提供了"位域"或"位段".

其实<位域>是把一个字节中的二进制位划分为几个不同的区域,并说明每个区域的位数.
每个域有一个域名,允许在程序中按域名进行操作.这样就可以把几个不同的对象用一个字节的二进制位域来表示.

struct 位域结构名 
{
 类型说明符 位域名: 位域长度;
 ...//省略
};

例如:
struct bs
{
 char a:8;
 char b:2;
 char c:6;
}data;
定义了struct bs类型的变量data,该变量共占两个字节,其中位域 a 占 8 位,位域 b 占 2 位,位域 c 占 6 位


struct k{
 int a:1;
 int :2; /* 该 2 位不能使用 */
 int b:3;
 int c:2;
};

-----------------------------------------

项目

使用结构体类型的数组写一个管理系统(每个人管理的内容不要一样)
 例子 : 学生管理系统
 struct stu
 {
 int id;
 char name[20];
 int age;
 int score;
 ...
 int flag;//用来做标记
 };
 
 1001	abc		29		99
 1002	def		28		100
 1003	xyz		46		59

 struct stu arr[10];//如果定义了一个5个成员的数组,那么将来最多可以管理5个学生

 规定管理10个东西

 实现功能 增加成员 删除成员 修改成员	查找成员 打印数据 排序成员 保存数据 读取数据 退出程序

 使用多文件的方式编写项目

==============================================

共用体联合 union

使用单块内存空间，管理不同数据类型
占用的内存空间以共用体当中最大的为准

1.同一个内存段可以用来存放几种不同类型的成员,但是在每一瞬间只能存放其中的一种,而不是同时存放几种。
换句话说,每一瞬间只有一个成员起作用,其他的成员不起作用.
2.共用体变量中起作用的成员是最后一次存放的成员,在存入一个新成员后,原有成员就失去作用
3.共用体变量的地址和它的各成员的地址都是同一地址.
4.共用体变量的初始化
（1）union data a=b; //把共用体变量初始化为另一个共用体
（2）union data a={123}; //初始化共用体为第一个成员
（3）union data a={.ch='a'}; //指定初始化项目，按照C99标准

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <stdio.h>

struct stu
{
	int id;
	char name[20];
	int math;
};

union A
{
	char a;
	short b;
	int c;
	float d;
	double e;
};

int main(void)
{
	struct stu s;
	union A m;
	printf("sizeof(struct stu) = %d\n", sizeof(struct stu));
	printf("sizeof(union A) = %d\n", sizeof(union A));
	printf("sizeof(s) = %d\n", sizeof(s));
	printf("sizeof(m) = %d\n", sizeof(m));
	return 0;
}

===============================================
sizeof(struct stu) = 28
sizeof(union A) = 8
sizeof(s) = 28
sizeof(m) = 8
===============================================
大端格式
 高字节存放低地址
小端格式
 低字节存放低地址

枚举

是一个被命名的整型常数的集合,枚举在日常生活中很常见。
例如:
 表示星期的
 SUNDAY
 MONDAY
 TUESDAY
 WEDNESDAY
 THURSDAY
 FRIDAY
 SATURDAY
 就是一个枚举。
枚举的说明与结构和联合相似, 其形式为:
enum 枚举名
{
 标识符[=整型常数],
 标识符[=整型常数],
 ...
 标识符[=整型常数]
}枚举变量;
如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始, 顺
次赋给标识符0, 1, 2, ...。但当枚举中的某个成员赋值后, 其后的成员按依次
加1的规则确定其值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>

enum A
{
	a,
	b,
	c = 10,
	d
};

int main(void)
{
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
}

========================
a = 0
b = 1
c = 10
d = 11
========================

枚举类型变量的赋值和使用
枚举类型在使用中有以下规定：
1.枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值： sun=5;mon=2;sun=mon; 都是错误的。
2. 枚举元素本身由系统定义了一个表示序号的数值，从0 开始顺序定义为0，1，2…。如在weekday中，sun值为0，mon值为1， …,sat值为6。
3. 只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量。如： a=sun;b=mon; 是正确的。而： a=0;b=1; 是错误的。如一定要把数值赋予枚举变量，则必须用强制类型转换，如： a=(enum weekday)2;其意义是将顺序号为2的枚举元素赋予枚举变量a，相当于： a=tue; 还应该说明的是枚举元素不是字符常量也不是字符串常量， 使用时不要加单、双引号。

注意：
1. 枚举中每个成员(标识符)结束符是"," 不是";", 最后一个成员可省略","。
2. 初始化时可以赋负数, 以后的标识符仍依次加1。
3. 枚举变量只能取枚举说明结构中的某个标识符常量。

预处理(替换)

预处理阶段是程序在编译之前进行的处理,预处理器只不过是一个文本替换工具而已,
它们会让编译器在实际编译之前完成所需的替换(预处理).

C语言的预处理主要有三个方面的内容 : 1.宏定义 2.文件包含 3.条件编译.
在C语言中以 '#' 开头的就是预处理的操作
预处理命令以符号“#”开头。

预处理指令	描述
#define		定义宏
#include	包含一个源代码文件
#undef		取消已定义的宏
#ifdef		如果宏已经定义，则返回真
#ifndef		如果宏没有定义，则返回真
#if			如果给定条件为真，则编译下面代码
#else		#if 的替代方案
#elif		如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码
#endif		结束一个 #if……#else 条件编译块

 printf.o
 |	
 V
 可重定位		可执行
 源程序	被修改的源程序	 汇编程序	 目标程序	 目标程序
 hello.c---->hello.i---->hello.s---->hello.o---->hello
 预处理器(cpp) 编译器(ccl) 汇编器(as) 链接器(ld)

`========文件包含============`

文件包含是指一个源文件可以将另一个源文件的全部内容包含进来.
该命令的作用是在预编译时,将指定源文件的内容复制到当前文件中.

文件包含有两种格式,分别是:#include "file.h" 和 #include <file.h>
这两格式的区别在于:
 1.使用双引号,系统首先到当前目录下查找被包含的文件,如果没找到,
 再到系统指定的"包含文件目录"(由用户在配置环境时设置)去找.
 2.使用尖括号,直接到系统指定的"包含文件目录"去查找。
 在linux操作系统中默认从/usr/include
 通常使用双引号比较保险

文件包含需要注意的点
1.一个#include只能包含一个头文件.
2.文件1用到文件2,文件2用到文件3,则文件3的包含命令#include应放在文件1的头部第一行.
3.文件包含可以是有路径的.
4.被包含文件中的静态全局变量不用在包含文件中声明.

`===========宏定义===========`

宏函数(能用函数就不用宏)

宏定义是C程序提供的预处理功能之一.包括带参数的宏定义和不带参数的宏定义.
具体是指用一个指定的标志符来进行简单的字符串替换或者进行阐述替换.

1)不带参数的宏定义
 格式：#define 宏名 替换内容
 1.宏名一般用大写
 2.提高程序的通用性和易读性，减少输入错误和便于修改。
 例如：数组大小常用宏定义
 3.可以用#undef命令终止宏定义的作用域
 4.宏定义可以嵌套

2)带参数的宏定义
 格式：#define 宏名(参数表) 替换内容
 注意：当使用宏定义时,实参如果是表达式,将来在替换时容易出问题

3)带参数的宏定义和函数关系
函数调用在编译后程序运行时进行,并且分配内存.
宏替换在编译前进行,不分配内存.
宏展开不占运行时间,只占编译时间,函数调用占运行时间(分配内存、保留现场、值传递、返回值)
=======================================================

#define Pal 3.1415926

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <stdio.h>

#define add(A, B)A + B

int main(void)
{
	int a, b, c;

	a = 3, b = 7;
	c = add(a, b);

	printf("a = %d, b = %d, c = %d\n", a, b, c);
	return 0;
}

`========条件编译============`

1.一般情况下,源程序中所有的行都参加编译.
但有时希望对其中一部分内容只在满足一定条件下才进行编译,
即对一部分内容指定编译条件,这就是"条件编译"。
2.条件编译指令将决定哪些代码被编译,而哪些是不被编译的.
可根据表达式的值或某个特定宏是否被定义来确定编译条件.

 指令 
 ▪ #if、#else、#elif和#endif指令
 ▪ #ifdef和#ifndef
 ▪ #line

格式一:
#ifdef 标识符
 程序段1
#else
 程序段2
#endif
当标识符已经定义时，程序段1才参加编译

格式二:
#ifndef 标识符
#define 标识1
 程序段1
#endif
如果标识符没有被定义，则重定义标识1，且执行程序段1。

格式三:
#if 表达式1
 程序段1
#elif 表达式2
 程序段2
 ……
#elif 表达式n
 程序段n
#else
 程序段n+1
#endif
当表达式1成立时,编译程序段1,当不成立时,判断表达式2,成立时编译程序段2,不成立以此类推

`========附加预处理============`

我们使用的文件包含、条件编译、宏定义之外的一些预处理
1)预定义宏
宏			描述
__DATE__	当前日期，一个以 "MMM DD YYYY" 格式表示的字符常量。
__TIME__	当前时间，一个以 "HH:MM:SS" 格式表示的字符常量。
__FILE__	这会包含当前文件名，一个字符串常量。
__LINE__	这会包含当前行号，一个十进制常量。

2)预处理器运算符

宏延续运算符（\）
一个宏定义或者表达式通常写在一行上，但是如果语句太长一行容纳不下，则使用宏延续运算符（\）。

字符串常量化运算符（#）
在宏定义中，当需要把一个宏的参数转换为字符串常量时，则使用字符串常量化运算符（#）。

标记粘贴运算符（##）
宏定义内的标记粘贴运算符（##）会合并两个参数。它允许在宏定义中两个独立的标记被合并为一个标记。

defined() 运算符
预处理器 defined 运算符是用在常量表达式中的，用来确定一个标识符是否已经使用 #define 定义过。如果指定的标识符已定义，则值为真（非零）。如果指定的标识符未定义，则值为假（零）。

03c_C截图

Thu, 16 Feb 2023 08:03:05 +0800

03c_C截图

1数据类型

2ASCII_1

2ASCII_2

2ASCII_3

3转义字符

4运算符

5存储类型比较

6标准输出格式字符

7标准输出修饰符

8一维数组元素表示

9二维数组元素表示

10区分定义

11函数的实现

12运算符优先级

03c_point_and_func

Thu, 16 Feb 2023 08:03:05 +0800

03c_point_and_func

===========================
2022-8-1
===========================

1.指针

使用指针的用处

 程序员通过指针,可以简化一些 C 语言编程任务的执行,还有一些任务,如动态内存分配
 大家都知道每一个变量都在内存中占用相应的存储空间,
动态内存分配的函数	malloc calloc realloc free
编程人员来讲
1.谁打开,谁关闭	文件IO
2.谁开辟,谁释放	动态内存
3.谁创建,谁销毁	链表
4.谁加锁,谁解锁	线程

 每一个内存位置都可以使用连字号（&）运算符访问的地址,它表示了在内存中的一个地址
 什么是指针
 其实指针从某种意义上来讲是一个变量,其值为另一个变量的地址,即内存位置的直接地址.
 就像普通的变量一样,必须在使用指针之前,对其进行定义.
 指针的定义一般形式为:type *pointer-name;
 无论何种类型的指针在内存中都占用8个字节空间(相对于64bit操作系统而言)
 不同数据类型的指针之间的相同点是都是用来存储地址的.
 不同数据类型的指针之间唯一的不同是,指针所指向的变量的数据类型不同.

如何使用指针？

 使用指针时会频繁进行以下几个操作:
int a;
 定义一个指针变量					int *p;
 把变量地址赋值给指针				p = &a;
 访问指针变量中可用地址的值			printf(“p = %p\n”, p);
 这些操作是需要通过使用运算符 * 来访问的

指向NULL的指针(空指针) int *p = NULL;//NULL ASCII 0 0x0

 在指针初始化的时候,如果没有确切的地址可以赋值,为指针赋一个 NULL 值
 是一个良好的编程习惯.赋为 NULL 值的指针被称为空指针.
 在写C语言程序时不允许访问地址为 NULL 的内存,因为该内存是操作系统保留的
 然而,内存地址 NULL 有特别重要的意义,它表明该指针不指向一个可操作的内存位置.
int a;
int *p = NULL;
p = &a;
*p = 100;
程序编译时不会报错报警告,但是程序执行时会报段错误(编译器不检查段错误)
if(p == NULL)
printf(“p是一个空指针!\n”);

野指针(没有对象)

 野指针指向一个已删除的对象或申请访问受限内存区域的指针.
 与空指针不同,野指针无法通过简单地判断是否为 NULL 避免,
 而只能通过养成良好的编程习惯来尽力减少.
 对野指针进行操作很容易造成程序错误.
 程序编译时不会报错报警告,程序执行时也不会报段错误
 int *p = NULL;
 p = malloc(sizeof(int));
 使用
 free(p);
 p = NULL;//可以先把野指针变成空指针,然后可以避免程序执行时不会报错

万能指针

 可以保存任意类型的地址

2.函数

什么是函数

 函数是一组一起执行一个任务的语句.每个 C 程序都至少有一个函数,
 即主函数 main() 所有简单的程序都可以定义其他额外的函数.
 程序员可以把代码划分到不同的函数中.
 如何划分代码到不同的函数中是程序员自己来决定的,但在逻辑上,
 划分通常是根据每个函数执行一个特定的任务来进行的.
 函数声明告诉编译器函数的名称\返回类型和参数.函数定义提供了函数的实际主体。

函数的声明

 函数声明会告诉编译器函数名称及如何调用函数.
 函数声明包括以下几个部分:
 return_type		function_name	(parameter list)	;//形式参数 形参
 int				max			(int a, int b)		;
int				add				(int a, int b)		;
Void			swap			(int *a, int *b)	;
 在函数声明中,参数的名称并不重要,只有参数的类型是必需的
 int max(int, int);

函数的实现

 return_type		function_name	(parameter list)//形式参数 形参
 {
 			body of the function
 }
int				max			(int a, int b)
{
return a > b ? a : b;
}
int				add				(int a, int b)
{
return a + b;
}




void		swap	(int *a, int * b)
{
int c;
c = *a;
*a = *b;
*b = c;
}

函数的调用

 当实现函数的功能时,会写出函数要做什么,然后通过调用函数来执行已写好的功能.
 当程序调用函数时,程序控制权会转移给被调用的函数.
 被调用的函数执行函数主体的内容,当函数的返回语句被执行时,
 或到达函数的结束括号时,会把程序控制权交还给主程序.
 调用函数时,传递所需参数,如果函数返回一个值,则可以在调用时用变量来存储返回值.
 function_name	(parameter list);//实际参数 实参
max			(13, 7);
add				(13, 7);		
swap			(&a, &b);
 在 C 语言中,函数由一个函数头和一个函数主体组成.下面列出一个函数的所有组成部分:
 返回类型 : 一个函数可以返回一个值.return_type 是函数返回的值的数据类型.
 有些函数执行所需的操作而不返回值,在这种情况下,return_type 是关键字 void.
 
 函数名称 : 这是函数的实际名称.也是函数的入口
 	
 参数 : 参数就像是占位符.当函数被调用时,程序员需要向参数传递一个值,
 这个值被称为实际参数.参数列表包括函数参数的类型\顺序\数量.
 参数是可选的,也就是说,有些功能函数可能不需要参数.
 	
 函数主体 : 函数主体包含一组定义函数执行任务的语句.
 
 函数参数
 如果函数要使用参数,则必须在函数声明时定义参数变量,这些变量称为函数的形式参数.
 形式参数就像函数内的其他局部变量,在进入函数时被创建,退出函数时被销毁.
 
 当调用函数时,有两种向函数传递参数的方式:
 值传递 : 该方法把参数的实际值复制给函数的形式参数,在这种情况下
 修改函数内的形式参数不会影响实际参数。
swap(a, b)
 地址传递 : 通过指针传递方式,形参为指向实参地址的指针,
 当对形参的指向操作时,就相当于对实参本身进行的操作。
swap(&a, &b)
 如果使用值传递来传递参数,这意味着函数内的代码不能改变用于调用函数的实际参数.

04ds_01day

Thu, 16 Feb 2023 08:03:05 +0800

04ds_01day

===========================
2022-8-1
===========================

一.温故知新

 复合型数据类型
 结构体
 1.先定义结构体类型
 struct tag
 {
 //结构体成语的定义
 };
 2.再使用结构体类型定义结构体类型的变量\指针\数组
 数据类型		变量名	;
 struct tag		s		;
 struct tag *	p		;
 struct tag		arr	[成员个数]	;
 3.结构体类型的变量访问结构体的成员
 变量名 + . + 成员名
 结构体类型的指针访问结构体的成员
 指针名 + -> + 成员名
 4.通过sizeof运算符结算结构体大小
 结构体的大小相当于成员大小的和 + 字节对齐
 共用体
 共用体中的成员会共用同一块儿存储空间
 (使用一块儿存储空间管理不同类型的数据)
 1.先定义共用体类型
 union tag
 {
 共用体成员的定义;
 };
 2.大端格式和小端格式
 大端格式
 高字节的数据存放在低地址上
 低字节的数据存放在高地址上
 小端格式
 高字节的数据存放在高地址上
 低字节的数据存放在低地址上
 3.位域(位段/位字段)
 是编程语言(C语言)提供的操作位的方法
 -----------------------------------
 位带(bitband)

共用体(联合)
union是C语言中的关键字
1.共用体的含义
 共用体的成员共用同一块儿存储空间
 (使用一块儿存储空间管理不同的数据类型)
2.共用体的定义
 union tag				//tag是标签
 {
 共用体成员的定义;
 };						//最后需要加 ; 结尾
3.和结构体不同的地方
 1>结构体中每个成员都会占用独立的存储空间
 共用体中每个成员都会占用相同的存储空间
 2>结构体的大小是每个成员大小的和的基础上加入字节对齐
 共用体的大小以共用体成员中最大的成员大小为准
4.大端格式和小端格式
 在硬件的平台中是分为大端格式和小端格式的
 X86/英特尔架构		小端格式
 高字节的数据存放在高地址上,低字节的数据存放在低地址上
 (高对高,低对低)
 例子 : 在小端格式上存储一个十六进制的数据0x12345678
 地址		数据
 0x1000		0x78
 0x1001		0x56
 0x1002		0x34
 0x1003		0x12
 ARM架构->ARM系列大端格式(现在既支持大端也支持小端)
 高字节的数据存放在低地址上,低字节的数据存放在高地址上
 (高对低,低对高)
 例子 : 在大端格式上存储一个十六进制的数据0x12345678
 地址		数据
 0x1000		0x12
 0x1001		0x34
 0x1002		0x56
 0x1003		0x78
可以使用共用体测试当前的机器是大端格式还是小端格式

=========================
笔试题
1.什么是大端格式?什么是小端格式?
2.设计一个程序测试当前的机器是大端格式还是小端格式
=========================

预处理

预处理
 条件编译
#ifndef	__ADD_H
#define __ADD_H
除了在.h文件中加入,防止头文件被重复包含以外
在.c文件中也可以使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
#if 0
	printf("Hello World!\n");
#else
	printf("你好,中国!\n");
#endif
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <stdio.h>
#include <stdlib.h>

#define SUB

int main(int argc, char *argv[])
{
	int a = 13, b = 7;
	int sum = 0;

#ifndef ADD
	sum = a + b;
#else
	sum = a - b;
#endif
	printf("sum = %d\n", sum);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

#define STM32F103CBT6

int main(int argc, char *argv[])
{
	int PIN = 0;
#if defined (STM32F103RBT6)
	PIN = 64;
#elif defined (STM32F103CBT6)
	PIN = 32;
#endif
	printf("PIN = %d\n", PIN);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#include <stdio.h>
#include <stdlib.h>

#define FLAG 2

int main(int argc, char *argv[])
{
	int a = 13, b = 7;
	int sum = 0;

#if FLAG==0
	sum = a + b;
#elif FLAG==1
	sum = a - b;
#elif FLAG==2
	sum = a * b;
#elif FLAG==3
	sum = a / b;
#else
	sum = a % b;
#endif

	printf("sum = %d\n", sum);
	
	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

#define PAI 3.14

int main(int argc, char *argv[])
{
	printf("PAI = %f\n", PAI);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

#define ARRSIZE 10

int main(int argc, char *argv[])
{
	int arr[ARRSIZE];
	int i = 0;

	for(i = 0; i < ARRSIZE; i++)
	{

	}

	return 0;
}

 面试题
 1.定义一个宏,计算一年(平年)有多少秒
 
 2.定义一个宏,比较两个值的最大值

 3.定义一个宏,完成两个变量值的交换

 注意 : 在写宏函数的时候一定要加小括号,代表是一个整体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

#define SEC_OF_YEAR (365*24*60*60)

int main(int argc, char *argv[])
{
	printf("SEC_OF_YEAR = %d\n", SEC_OF_YEAR);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#include <stdio.h>
#include <stdlib.h>

#define MUL(A,B) (A)*(B)
//MUL(A,B)		A*B
//MUL(2+3,3+4)	2+3*3+4 = 15
int mul(int a, int b)
{
	return a * b;
}

int main(int argc, char *argv[])
{
	int a = 13, b = 7;

	printf("MUL = %d\n", MUL(2+3, 3+4));//a+b
	printf("mul = %d\n", mul(2+3, 3+4));//a+b

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


#include <stdio.h>
#include <stdlib.h>

#define MAX(A,B) A>B?A:B
//a++ > b++ ? a++ : b ++

int max(int a, int b)
{
	return a > b ? a : b;
}

int main(int argc, char *argv[])
{
	int a = 13, b = 7;

	printf("MAX = %d\n", MAX(a++, b++));
	a = 13;
	b = 7;
	printf("max = %d\n", max(a++, b++));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


#include <stdio.h>
#include <stdlib.h>

//#define SWAP(A,B) {typeof(A)tmp; tmp=A; A=B; B=tmp;}
//#define SWAP(A,B) {(A)=(A)+(B);(B)=(A)-(B);(A)=(A)-(B);}
#define SWAP(A,B) {(A)^=(B);(B)^=(A);(A)^=(B);}

int main(int argc, char *argv[])
{
	int a = 13, b = 7;

	printf("a = %d b = %d\n", a, b);
	SWAP(a,b);
	printf("a = %d b = %d\n", a, b);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	printf("__DATE__ = %s\n", __DATE__);
	printf("__TIME__ = %s\n", __TIME__);
	printf("__FILE__ = %s\n", __FILE__);
	printf("__LINE__ = %d\n", __LINE__);
	printf("__FUNCTION__ = %s\n", __FUNCTION__);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	int a = 3, b = 4, c = 5;

	if((a + b > c) && \
		(a + c > b) && \
		(b + c > a))
	{
		printf("可以构成三角形!\n");
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#include <stdio.h>
#include <stdlib.h>

#define PRINT_STR(n) #n

int main(int argc, char *argv[])
{
	printf("PRINT_STR = %s\n", PRINT_STR(12+34));

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


#include <stdio.h>
#include <stdlib.h>

#define INT_VAR(n) var##n

int main(int argc, char *argv[])
{
	int var1 = 100;
	int var2 = 200;
	int var3 = 300;
	int var4 = 400;
	int var5 = 500;

	printf("VAR = %d\n", INT_VAR(2));//var2
	printf("VAR = %d\n", INT_VAR(5));//var5

	return 0;
}

枚举
enum是C语言的关键字
枚举就是一个被命名的整型常数的集合
enum 枚举名
{
 标识符[=整型常数],
 标识符,
 ...
 标识符
};			//枚举定义之后需要加 ; 结尾
注意:
1.在定义枚举时.标识符与标识符之间要用 , 隔开而不是 ; 
2.在枚举中标识符可以和变量同名,如果同名变量会屏蔽标识符
 (尽量不要同名)
3.在定义枚举时,方括号的内容时缺省值,可以有也可以没有
 如果没有缺省值,标识符会按照0 1 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


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b,
	c,
	d
};

int main(int argc, char *argv[])
{
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b,
	c,
	d
};

int main(int argc, char *argv[])
{
	int a = 9527;
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b = 100,
	c,
	d
};

int main(int argc, char *argv[])
{
	//int a = 9527;
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#include <stdio.h>
#include <stdlib.h>

enum E
{
	a,
	b = 100,
	c,
	d
};

int main(int argc, char *argv[])
{
	//int a = 9527;
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	
	//a = 9527;枚举的标识符不是变量,不能做赋值运算

	printf("a = %d\n", a);

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <stdio.h>
#include <stdlib.h>

enum E{MODE_0, MODE_1, MODE_2, MODE_3};

int main(int argc, char *argv[])
{
	int mode = 0;

	scanf("%d", &mode);

	switch(mode)
	{
		case MODE_0 : printf("菜鸟难度!\n"); break;
		case MODE_1 : printf("普通难度!\n"); break;
		case MODE_2 : printf("地狱难度!\n"); break;
		case MODE_3 : printf("中国男足难度!\n"); break;
	}

	return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


#include <stdio.h>
#include <stdlib.h>

struct GPIO
{
	unsigned char PA0 : 2;
	unsigned char PA1 : 2;
	unsigned char PA2 : 2;
	unsigned char PA3 : 2;
	unsigned char PA4 : 2;
	unsigned char PA5 : 2;
	unsigned char PA6 : 2;
	unsigned char PA7 : 2;
	unsigned char PA8 : 2;
	unsigned char PA9 : 2;
	unsigned char PA10: 2;
	unsigned char PA11: 2;
	unsigned char PA12: 2;
	unsigned char PA13: 2;
	unsigned char PA14: 2;
	unsigned char PA15: 2;
};

enum mode
{
	INPUT,
	OUTPUT,
	AF,
	AN
};

int main(int argc, char *argv[])
{
	struct GPIO P;

	P.PA0 = OUTPUT;

	P.PA10 = AF;

	return 0;
}

04ds_02day

Thu, 16 Feb 2023 08:03:05 +0800

04ds_02day

============================
2022-8-2
============================

note

malloc calloc realloc 开辟空间
free 释放空间
malloc(sizeof(int) * 4);

线性存储结构
 顺序表
 数组
 一维数组
 多维数组
 链表
 是一种物理存储单元上非连续\非顺序的存储结构
 链表是由一个一个的结点组成的
 每一个结点是由两部分组成 : 数据域 和 指针域
 数据域 : 是用来存储结点的数据的
 指针域 : 是用来存储下一个结点的地址的

 在操作链表时包括有 : 增 删 改 查一系列的操作

 在描述链表时会用到一些属性
 有头链表/无头链表	有没有头结点的意思
 循环链表/不循环链表	链表是否可以构成环
 单向链表/双向链表	遍历链表方向

 有头单向不循环的链表
--------------------------------------------------------------------------------
 创建一个有头单向不循环的链表
 1.创建头结点		llist_create();
 2.插入数据结点		llist_insert();
 先把新创建出的结点挂到链表上,再改变链表之前的结构
 头插法{11,22,33,44,55}
 把数据结点插入到头结点之后的位置
 头结点->NULL
 头结点->11->NULL
 头结点->22->11->NULL
 头结点->33->22->11->NULL
 
 尾插法{11,22,33,44,55}
 把数据结点插入到链表最后的位置
 头结点->NULL
 头结点->11->NULL
 头结点->11->22->NULL
 头结点->11->22->33->NULL
 3.遍历链表			llist_display();
 4.销毁链表			llist_destroy();
 销毁链表或者删除结点时要注意
 单链表再删除时需要一前一后两个指针
 =======================================
 5.查找结点			llist_find();
 6.删除结点			llist_delete();
 7.拿出结点			llist_fetch();

==============================
作业
1.把今天讲过的内容完完整整的复习一遍
2.把有头单向不循环链表再重新的写一遍
3.尝试自己搞定有头单向循环链表
==============================

链表

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#ifndef __LLIST_H
#define __LLIST_H

enum MODE {HEADINSERT, TAILINSERT};//头插法和尾插法

#define NAMESIZE 20

typedef struct llist_node
{
	int id;//数据域中的数据
	char name[NAMESIZE];//数据域中的数据
	int math;//数据域中的数据
	struct llist_node *next;//指针域(指向下一个结点的指针)
}LLIST;

LLIST *llist_create();//创建头结点

int llist_insert(LLIST *,const void *,int);//插入数据结点

void llist_display(LLIST *);//遍历链表

void llist_destroy(LLIST *);//销毁链表

LLIST *llist_find(LLIST *, const void *);//查找结点

int llist_delete(LLIST *, const void *);//删除结点

int llist_fetch(LLIST *, const void *, void *);//取出数据

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

LLIST *llist_create()
{
	LLIST *handler = NULL;//指向头结点的指针

	handler = malloc(sizeof(LLIST));//为头结点开辟空间
	if(handler == NULL)//判断是否开辟空间失败
		return NULL;//开辟空间失败,函数结束,并且返回NULL
	handler->next = NULL;//让头结点的next指针指向NULL
	return handler;//返回头结点的地址
}

int llist_insert(LLIST *handler,const void *data,int mode)
{
	LLIST *p = handler;//通过指针p代替handler做操作
	LLIST *newnode = NULL;//指向新创建出来的数据结点

	newnode = malloc(sizeof(LLIST));//开辟数据结点的空间
	if(newnode == NULL)//判断开辟空间是否失败
		return -1;//开辟失败,结束函数,并且返回-1
	
	memcpy(newnode, data, sizeof(LLIST));
	//把数据拷贝到数据结点中
	switch(mode)
	{
		case HEADINSERT : newnode->next = p->next; break;
		case TAILINSERT : while(p->next != NULL) p = p->next;
							break;
		default : free(newnode); return -2;
		//模式选择有误,释放空间,结束程序,并且返回-2
	}
	p->next = newnode;
	return 0;
}

void llist_display(LLIST *handler)
{
	LLIST *cur = NULL;//指向每一个数据结点

	for(cur = handler->next; cur != NULL; cur = cur->next)
		printf("%d	%s	%d\n", cur->id,cur->name,cur->math);
}

void llist_destroy(LLIST *handler)
{
	LLIST *back = handler;//指向头结点的指针
	LLIST *cur = handler->next;//指向第一个数据结点

	while(cur != NULL)
	{
		back->next = cur->next;//把要释放的结点从链表中拆除
		free(cur);//释放数据结点
		cur = back->next;
	}
	free(back);//释放头结点
}

LLIST *llist_find(LLIST *handler, const void *find_data)
{
	LLIST *cur = NULL;//循环查找的指针

	for(cur = handler->next; cur != NULL; cur = cur->next)
	{
		if(cur->id == *(int *)find_data || 
			!strcmp(cur->name, find_data))
		{
			return cur;//找到要查找的结点,并且返回
		}
	}
	return NULL;//没有找到数据结点,返回NULL
}

int llist_delete(LLIST *handler, const void *find_data)
{
	LLIST *back = handler;//指向要删除的结点的前一个位置
	LLIST *cur = NULL;//指向要删除的结点

	cur = llist_find(handler, find_data);//查找结点
	if(cur == NULL)//判断是否没有找到结点
		return -1;

	while(back->next != cur)//找到要删除结点的前一个位置
		back = back->next;

	back->next = cur->next;//把要删除结点从链表中拆除
	free(cur);//释放删除的结点
	return 0;
}

int llist_fetch(LLIST *handler, const void *find_data, void *save)
{
	LLIST *back = handler;
	LLIST *cur = NULL;

	cur = llist_find(handler, find_data);
	if(cur == NULL)
		return -1;
	
	while(back->next != cur)
		back = back->next;
	
	back->next = cur->next;
	memcpy(save, cur, sizeof(LLIST));
	free(cur);
	return 0;
}

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


#include <stdio.h>
#include "llist.h"

int main(void)
{
	LLIST *handler = NULL;//handler指针指向头结点
	LLIST *find = NULL;//find指针指向将来找到的结点
	LLIST data;//用来存储数据的变量
	LLIST save;//将来保存取出的数据
	int i = 0;//循环变量
	int ret = 0;//用来接收返回值的变量
	int find_id = 100;//要查找的id号
	char *find_name = "stu4";//要查找的名字

	handler = llist_create();//创建头结点
	if(handler == NULL)//判断创建头结点是否失败
		return -1;//创建头结点失败,结束程序,并且返回-1
	
	for(i = 0; i < 5; i++)//循环进行插入数据结点
	{
		data.id = 100 + i;//存储数据
		sprintf(data.name, "stu%d", i);//存储数据
		data.math = 100 - i;//存储数据
		data.next = NULL;//让next指针指向空
		llist_insert(handler, &data, TAILINSERT);
		//插入数据结点
	}
	
	llist_display(handler);//遍历链表

	printf("====================\n");
/*
	find = llist_find(handler, "stu9");//查找结点
	if(find == NULL)//判断是否没有找到结点
		printf("Not Find It!\n");
	else
		printf("Find It!	%d	%s	%d\n", find->id, find->name, find->math);
*/
#if 0
	ret = llist_delete(handler, "stu9");//删除结点
	if(ret != 0)//判断是否删除失败
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(handler,"stu9",&save);//取出数据
	if(ret != 0)
		printf("Fetch It Is Failed!\n");
	else
		printf("Fetch It!	%d	%s	%d\n",save.id, save.name, save.math);
#endif
	printf("====================\n");

	llist_display(handler);//遍历链表

	llist_destroy(handler);//销毁链表

	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist

04ds_03day

Thu, 16 Feb 2023 08:03:05 +0800

04ds_03day

===========================
2022-8-3
===========================

note

一.不用写调用,只写声明和实现
 实现有头单向不循环链表的
 遍历和销毁

任务(最基本的要求)
 1.大家可以在纸上写出简单的(有头双向循环链表)增删改查
 2.大家可以在电脑上写出通用性强的链表
 3.大家可以使用内核链表(会用)

自己重新写一遍有头单向循环链表的功能
 1.创建头结点		llist_create();
 2.插入数据结点		llist_insert();
 (头插法	尾插法)
 3.遍历链表			llist_display();
 4.销毁链表			llist_destroy();
 -----------------------------------
 5.查找结点			llist_find();
 6.删除结点			llist_delete();
 7.拿出结点			llist_fetch();

==============================
作业
1.把今天讲过的内容完完整整的复习一遍
2.重新写一遍有头单向循环链表的各种功能
3.写一个无头单向不循环的链表
4.完成joseph杀人游戏
==============================
================================================================================

无头单向不循环的链表

/*
 实现 无头单向不循环的链表
 无头 : 代表没有头结点
 在无头的链表中所有的结点都是数据结点
 1.插入数据结点		llist_insert();
 由于没有头结点所以直接把新的数据结点插入到链表最后
 2.遍历链表			llist_display();
 3.销毁链表			llist_destroy();
 ------------------------------------
 4.查找结点			llist_find();
 5.删除结点			llist_delete();
 6.拿出结点			llist_fetch();
*/

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <stdio.h>
#include "llist.h"

int main(void)
{
	LLIST *l = NULL;//l指针指向无头链表的第一个结点
	LLIST *find = NULL;//指向找到的结点
	LLIST save;
	int ret = 0;//保存函数的返回值
	int find_id = 100;
	int num = 0;//客户用来录入结点个数的
	char *find_name = "stu9";

	printf("Please Insert Node Number : ");
	scanf("%d", &num);

	l = llist_insert(num);//创建无头链表
	if(l == NULL)//判断是否创建失败
		return -1;//从创建失败,结束程序,并且返回-1
	
	llist_display(l);//遍历链表

	printf("==================\n");
/*	
	find = llist_find(l, find_name);
	if(find == NULL)
		printf("Not Find It!\n");
	else
		printf("Find It!	%d	%s	%d\n",find->id, find->name, find->math);
*/
#if 0
	ret = llist_delete(&l, find_name);
	if(ret != 0)
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(&l, &find_id, &save);
	if(ret != 0)
		printf("Fetch It Is Failed!\n");
	else
		printf("Fetch It!	%d	%s	%d\n", save.id, save.name,save.math);
#endif
	printf("==================\n");

	llist_display(l);

	llist_destroy(l);//销毁链表

	return 0;
}

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


#ifndef __LLIST_H
#define __LLIST_H

#define NAMESIZE 20

typedef struct llist_node
{
	int id;
	char name[NAMESIZE];
	int math;
	struct llist_node *next;
}LLIST;

LLIST *llist_insert(int);//插入数据结点

void llist_display(LLIST *);//遍历链表

void llist_destroy(LLIST *);//销毁链表

LLIST *llist_find(LLIST *, const void *);//查找结点

int llist_delete(LLIST **, const void *);//删除结点

int llist_fetch(LLIST **, const void *, void *);//拿出结点

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

LLIST *llist_insert(int num)//插入数据结点
{
	LLIST *l = NULL;//指向无头链表的第一个结点
	LLIST *p = NULL;//辅助l指针
	LLIST *newnode = NULL;//指向新的结点
	LLIST data;//用来存储数据
	int i = 0;//循环变量

	l = malloc(sizeof(LLIST));//为第一个结点开辟空间
	if(l == NULL)//判断是否开辟失败
		return NULL;

	data.id = 100 + i;
	sprintf(data.name, "stu%d", i);
	data.math = 100 - i;
	data.next = NULL;
	memcpy(l, &data, sizeof(LLIST));
	p = l;
	for(i = 1; i < num; i++)
	{
		newnode = malloc(sizeof(LLIST));
		if(newnode == NULL)//判断是否开辟失败
			return l;
		data.id = 100 + i;
		sprintf(data.name, "stu%d", i);
		data.math = 100 - i;
		data.next = NULL;
		memcpy(newnode, &data, sizeof(LLIST));
		p->next = newnode;
		p = p->next;
	}

	return l;//把第一个结点的地址返回
}

void llist_display(LLIST *l)//遍历链表
{
	LLIST *cur = NULL;

	for(cur = l; cur != NULL; cur = cur->next)
		printf("%d	%s	%d\n",cur->id,cur->name,cur->math);
}

void llist_destroy(LLIST *l)//销毁链表
{
	LLIST *back = l;
	LLIST *cur = l->next;

	while(cur != NULL)
	{
		back->next = cur->next;
		free(cur);
		cur = back->next;
	}
	free(back);
}

LLIST *llist_find(LLIST *l, const void *find_data)
{
	LLIST *cur = NULL;
	for(cur = l; cur != NULL; cur = cur->next)
	{
		if(cur->id==*(int*)find_data || 
			!(strcmp(cur->name, find_data)))
			return cur;
	}
	return NULL;
}

int llist_delete(LLIST **l, const void *find_data)
{
	LLIST *back = *l;//指向第一个结点
	LLIST *cur = NULL;//指向要删除的结点

	cur = llist_find(*l, find_data);//查找要删除的结点
	if(cur == NULL)//判断是否没有找到
		return -1;//没有找到,结束函数,并且返回-1
	
	if(cur == *l)//判断要删除的结点是否是第一个结点
		(*l) = (*l)->next;//把指向改变为下一个结点
	else
	{
		while(back->next != cur)
			back = back->next;
		back->next = cur->next;
	}
	free(cur);
	return 0;
}

int llist_fetch(LLIST **l, const void *find_data, void *save)
{
	LLIST *back = *l;//指向第一个结点
	LLIST *cur = NULL;//指向要删除的结点

	cur = llist_find(*l, find_data);//查找要删除的结点
	if(cur == NULL)//判断是否没有找到
		return -1;//没有找到,结束函数,并且返回-1
	
	if(cur == *l)//判断要删除的结点是否是第一个结点
		(*l) = (*l)->next;//把指向改变为下一个结点
	else
	{
		while(back->next != cur)
			back = back->next;
		back->next = cur->next;
	}
	memcpy(save, cur, sizeof(LLIST));
	free(cur);
	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist

================================================================================

需要实现有头单向循环链表

/*
 需要实现有头单向循环链表
 1.创建头结点		llist_create();
 2.插入数据结点		llist_insert();
 头插法	尾插法
 3.遍历链表			llist_display();
 4.销毁链表			llist_destroy();
 ===================================
 5.查找结点			llist_find();
 6.删除结点			llist_delete();
 7.拿出数据			llist_fetch();
*/

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


#include <stdio.h>
#include "llist.h"

int main(void)
{
	LLIST *handler = NULL;//指向头结点的指针
	LLIST *find = NULL;//指向找到的结点
	LLIST data;//用来存储用户的数据
	LLIST save;//保存拿出的数据
	int i = 0;//循环变量
	int ret = 0;//用于接收返回值
	int find_id = 100;//要查找的ID号
	char *find_name = "stu4";//要查找的姓名

	handler = llist_create();//创建头结点
	if(handler == NULL)//判断是否创建头结点失败
		return -1;//头结点创建失败,结束程序,并且返回-1
	
	for(i = 0; i < 5; i++)
	{
		data.id = 100 + i;//赋值数据
		sprintf(data.name, "stu%d", i);//赋值数据
		data.math = 100 - i;//赋值数据
		data.next = NULL;//指针指向NULL
		llist_insert(handler,&data,TAILINSERT);//插入数据
	}
	
	llist_display(handler);//遍历链表

	printf("=========================\n");
/*	
	find = llist_find(handler, "stu9");//查找结点
	if(find == NULL)//判断是否没有找到结点
		printf("Not Find It!\n");
	else
		printf("Find It!	%d	%s	%d\n", find->id, find->name, find->math);
*/
#if 0
	ret = llist_delete(handler, "stu9");//删除结点
	if(ret != 0)//判断是否删除失败
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(handler,find_name, &save);//拿出数据
	if(ret != 0)//判断是否拿出失败
		printf("Fetch It Is Failed!\n");
	else
		printf("Fetch It!	%d	%s	%d\n",save.id, save.name, save.math);
#endif
	printf("=========================\n");

	llist_display(handler);//遍历链表

	llist_destroy(handler);//释放链表

	return 0;
}

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


#ifndef __LLIST_H
#define __LLIST_H

#define HEADINSERT 0//头插法
#define TAILINSERT 1//尾插法
#define NAMESIZE 20//名字成员个数

typedef struct llist_node//定义了每个结点的结构体类型
{
	int id;
	char name[NAMESIZE];
	int math;
	struct llist_node *next;
}LLIST;

LLIST *llist_create();//创建头结点

int llist_insert(LLIST *, const void *, int );//插入数据

void llist_display(LLIST *);//遍历链表

void llist_destroy(LLIST *);//销毁链表

LLIST *llist_find(LLIST *, const void *);//查找结点

int llist_delete(LLIST *, const void *);//删除结点

int llist_fetch(LLIST *, const void *, void *);//拿出数据

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

LLIST *llist_create()
{
	LLIST *handler = NULL;//指向头结点的指针

	handler = malloc(sizeof(LLIST));//开辟头结点的空间
	if(handler == NULL)//判断是否开辟失败
		return NULL;//开辟失败,结束函数,并且返回NULL
	handler->next = handler;//头结点的next指针指向自己

	return handler;//把头结点的地址返回
}

int llist_insert(LLIST *handler,const void *data,int mode)
{
	LLIST *p = handler;//通过指针p代替handler做操作
	LLIST *newnode = NULL;//指向新创建的结点

	newnode = malloc(sizeof(LLIST));//开辟数据结点的空间
	if(newnode == NULL)//判断数据结点的空间是否开辟失败
		return -1;//数据结点的空间开辟失败,函数结束,返回-1
	
	memcpy(newnode, data, sizeof(LLIST));//拷贝数据
	switch(mode)
	{
		case HEADINSERT : break;
		case TAILINSERT : while(p->next != handler)
							p = p->next;
							break;
		default : free(newnode); return -2;
				 //释放空间,结束函数,并且返回-2
	}
	newnode->next = p->next;
	p->next = newnode;
	return 0;
}

void llist_display(LLIST *handler)//遍历链表
{
	LLIST *cur = NULL;//指向每一个数据结点

	for(cur=handler->next; cur!=handler; cur=cur->next)
		printf("%d	%s	%d\n",cur->id,cur->name,cur->math);
}

void llist_destroy(LLIST *handler)//销毁链表
{
	LLIST *back = handler;//指向头结点的指针
	LLIST *cur = handler->next;//指向数据结点的指针

	while(cur != handler)
	{
		back->next = cur->next;
		free(cur);
		cur = back->next;
	}
	free(cur);
}

LLIST *llist_find(LLIST *handler, const void *find_data)
{
	LLIST *cur = NULL;//指向每一个数据结点

	for(cur=handler->next;cur!=handler;cur=cur->next)
	{
		if(cur->id==*(int*)find_data || 
			!(strcmp(cur->name, find_data)))
			return cur;//找到了结点,并且返回
	}
	return NULL;//没有找到结点,返回NULL
}

int llist_delete(LLIST *handler, const void *find_data)
{
	LLIST *back = handler;//指向头结点的指针
	LLIST *cur = NULL;//指向要删除的结点的指针

	cur = llist_find(handler, find_data);//查找删除的结点
	if(cur == NULL)//判断是否没有找到
		return -1;//删除失败,函数结束,并且返回-1
	
	while(back->next != cur)//查找要删除结点的前一个位置
		back = back->next;

	back->next = cur->next;//把删除的结点从链表中摘除
	free(cur);//释放要删除的结点
	return 0;
}

int llist_fetch(LLIST *handler, const void *find_data, void *save)
{
	LLIST *back = handler;//指向头结点的指针
	LLIST *cur = NULL;//指向要删除的结点的指针

	cur = llist_find(handler, find_data);//查找删除的结点
	if(cur == NULL)//判断是否没有找到
		return -1;//删除失败,函数结束,并且返回-1
	
	while(back->next != cur)//查找要删除结点的前一个位置
		back = back->next;

	back->next = cur->next;//把删除的结点从链表中摘除
	memcpy(save, cur, sizeof(LLIST));//把数据拿出
	free(cur);//释放要删除的结点
	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist

04ds_04day

Thu, 16 Feb 2023 08:03:05 +0800

04ds_04day

============================
2022-8-4
============================

note

1.写出有头单向循环链表的插入功能(头插 尾插)
2.实现冒泡法排序
 void sort(int *arr, int size);
有头单向循环链表的功能

无头单向不循环链表

约瑟夫环(约瑟夫杀人游戏)

--------------------------------------------
作业 :
1.把今天讲过的内容完完整整的复习一遍
2.把之前写过的5种链表都重新写一遍
 1)有头单向不循环链表
 2)有头单向循环链表
 3)无头单向不循环链表
 4)无头单向循环链表
 5)有头双向循环链表
--------------------------------------------

约瑟夫环(约瑟夫杀人游戏)

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <stdio.h>
#include "joseph.h"

int main(void)
{
	JOSEPH *j = NULL;//j指针指向第一个有效结点
	int player_num = 0;//保存玩家个数
	int kill_num = 0;//数的数字
	int alive = 0;//保存存活下来的人的ID

	printf("Please Insert Player Number : ");
	scanf("%d", &player_num);
	j = joseph_insert(player_num);//插入数据结点
	if(j == NULL)
		return -1;
	printf("===========================\n");
	joseph_display(j);//遍历链表
	printf("===========================\n");
	printf("Please Insert Kill Number : ");
	scanf("%d", &kill_num);
	printf("***************************\n");
	alive = joseph_play(j, player_num, kill_num);
	printf("\n***************************\n");
	printf("alive = %d\n", alive);

	return 0;
}

joseph.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#ifndef __JOSEPH_H
#define __JOSEPH_H

typedef struct llist_node
{
	int id;//编号
	struct llist_node *next;
}JOSEPH;

JOSEPH *joseph_insert(int );

JOSEPH *joseph_display(JOSEPH *);

int joseph_play(JOSEPH *, int , int);

#endif

joseph.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66


#include <stdio.h>
#include <stdlib.h>
#include "joseph.h"

JOSEPH *joseph_insert(int player_num)
{
	JOSEPH *j = NULL;//j指针指向第一个数据结点
	JOSEPH *p = NULL;//p指针代替j指针进行移动
	JOSEPH *newnode = NULL;//指针指向新创建的结点
	int i = 1;//循环变量
	
	j = malloc(sizeof(JOSEPH));
	if(j == NULL)
		return NULL;
	j->id = i;
	j->next = j;
	p = j;

	for(i = 2; i <= player_num; i++)
	{
		newnode = malloc(sizeof(JOSEPH));
		if(newnode == NULL)
			return j;
		newnode->id = i;
		newnode->next = p->next;
		p->next = newnode;
		p = p->next;
	}

	return j;
}

JOSEPH *joseph_display(JOSEPH *j)
{
	JOSEPH *cur = NULL;

	for(cur = j; cur->next != j; cur = cur->next)
		printf("%d ", cur->id);
	printf("%d\n", cur->id);
}

int joseph_play(JOSEPH *j, int player_num, int kill_num)
{
	JOSEPH *back = j;
	JOSEPH *cur = NULL;
	int p_n = player_num;
	int k_n = kill_num;
	int alive = 0;

	while(back->next != j)//为了找第一个结点的前一个位置
		back = back->next;
	
	while(--p_n)
	{
		for(k_n = kill_num - 1; k_n > 0; k_n--)
			back = back->next;
		cur = back->next;
		back->next = cur->next;
		printf("%d ", cur->id);
		free(cur);
	}
	alive = back->id;
	free(back);

	return alive;
}

makefile

joseph : main.o joseph.o
 gcc -o $@ $^
clean :
 rm -rf *.o joseph

有头双向循环链表

/*
 有头双向循环链表
 1.创建头结点					llist_create();
 2.插入数据结点(头插法 尾插法)	llist_insert();
 3.遍历链表						llist_display();
 4.销毁链表						llist_destroy();
*/

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


#include <stdio.h>
#include "llist.h"

int main(void)
{
	LLIST *handler = NULL;//指针指向链表的头结点
	LLIST *find = NULL;//指针指向要查找的结点
	LLIST data;//存储用户的数据
	LLIST save;//保存取出的数据
	int i = 0;//循环变量
	int ret = 0;//接收函数的返回值
	int find_id = 100;//要查找的ID号
	char *find_name = "stu4";//要查找的名字

	handler = llist_create();//创建头结点
	if(handler == NULL)//判断头结点是否创建失败
		return -1;//创建失败,结束程序,并且返回-1
	
	for(i = 0; i < 5; i++)
	{
		data.id = 100 + i;//获取数据
		sprintf(data.name, "stu%d", i);//获取数据
		data.math = 100 - i;//获取数据
		data.prev = data.next = NULL;//prev和next指向NULL
		llist_insert(handler, &data, TAILINSERT);
		//插入数据结点
	}

	llist_display(handler);//遍历链表
	
	printf("====================\n");
/*
	find = llist_find(handler, "stu9");//查找结点
	if(find == NULL)//判断是否没有找到
		printf("Not Find It!\n");
	else
		printf("Find It!	%d	%s	%d\n",find->id, find->name,find->math);
*/
#if 0
	ret = llist_delete(handler, &find_id);
	if(ret != 0)
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(handler, find_name, &save);
	if(ret != 0)
		printf("Fetch It Is Failed!\n");
	else
		printf("Fetch It!	%d	%s	%d\n",save.id, save.name, save.math);
#endif
	printf("====================\n");

	llist_display(handler);//遍历链表

	llist_destroy(handler);//销毁链表

	return 0;
}

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#ifndef __LLIST_H
#define __LLIST_H

#define HEADINSERT 0//头插法
#define TAILINSERT 1//尾插法
#define NAMESIZE 20//字符数组的成员个数

typedef struct llist_node//链表中结点的结构体
{
	int id;//数据域
	char name[NAMESIZE];//数据域
	int math;//数据域
	struct llist_node *prev;//prev指针指向前一个结点
	struct llist_node *next;//next指针指向后一个结点
}LLIST;

LLIST *llist_create();//创建头结点

int llist_insert(LLIST *, const void *, int );//插入数据

void llist_display(LLIST *);//遍历链表

void llist_destroy(LLIST *);//销毁链表

LLIST *llist_find(LLIST *, const void *);//查找结点

int llist_delete(LLIST *, const void *);//删除结点

int llist_fetch(LLIST *, const void *, void *);//取出结点

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

LLIST *llist_create()
{
	LLIST *handler = NULL;//指向头结点的指针

	handler = malloc(sizeof(LLIST));//为头结点开辟空间
	if(handler == NULL)//判断头结点空间是否开辟失败
		return NULL;//开辟空间失败,结束函数,返回NULL
	
	handler->prev = handler->next = handler;
	//让头结点的前后指针都指向自己

	return handler;//返回指向头结点的指针
}

int llist_insert(LLIST *handler,const void *data,int mode)
{
	LLIST *p = handler;//代替handler指针进行移动
	LLIST *newnode = NULL;//指向新创建的数据结点

	newnode = malloc(sizeof(LLIST));//为数据结点开辟空间
	if(newnode == NULL)//判断数据结点是否开辟失败
		return -1;//开辟空间失败,结束函数,并且返回-1
	
	memcpy(newnode, data, sizeof(LLIST));//拷贝数据

	switch(mode)
	{
		case HEADINSERT : break;
		case TAILINSERT : p = p->prev; break; 
		default : free(newnode); return -2;
	}
	newnode->next = p->next;
	newnode->prev = p;
	newnode->next->prev = newnode;
	newnode->prev->next = newnode;
	return 0;
}

void llist_display(LLIST *handler)
{
	LLIST *cur = NULL;//指向每一个数据结点

	for(cur = handler->next;cur!=handler;cur=cur->next)
		printf("%d	%s	%d\n",cur->id,cur->name,cur->math);
}

void llist_destroy(LLIST *handler)
{
	LLIST *cur = NULL;

	for(cur=handler->next;cur!=handler;cur=handler->next)
	{
		cur->next->prev = cur->prev;
		cur->prev->next = cur->next;
		free(cur);//释放数据结点
	}
	free(cur);//释放头结点
}

LLIST *llist_find(LLIST *handler, const void *find_data)
{
	LLIST *cur = NULL;

	for(cur=handler->next;cur!=handler;cur=cur->next)
	{
		if(cur->id==*(int *)find_data || 
			!(strcmp(cur->name, find_data)))
		{
			return cur;
		}
	}
	return NULL;
}

int llist_delete(LLIST *handler, const void *find_data)
{
	LLIST *cur = NULL;

	cur = llist_find(handler, find_data);
	if(cur == NULL)
		return -1;
	
	cur->prev->next = cur->next;
	cur->next->prev = cur->prev;
	free(cur);

	return 0;
}

int llist_fetch(LLIST *handler, const void *find_data, void *save)
{
	LLIST *cur = NULL;

	cur = llist_find(handler, find_data);
	if(cur == NULL)
		return -1;

	cur->prev->next = cur->next;
	cur->next->prev = cur->prev;
	memcpy(save, cur, sizeof(LLIST));
	free(cur);

	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist

04ds_05day

Thu, 16 Feb 2023 08:03:05 +0800

04ds_05day

==============================
2022-8-5
==============================

note

一.早测
 完成有头双向循环链表的功能
 1.创建头结点
 2.插入数据结点
 3.遍历链表
 4.销毁链表
 5.查找结点
 6.删除结点
 7.拿出结点
只写声明和实现,不用写调用(llist.c 和 llist.h)

=================================
作业
1.把这一周讲过的内容都完完整整的复习一遍
2.把三个版本的通用性强的链表重新实现一遍
3.在纸上写链表的代码
=================================

通用性强的链表

结点图

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


#include <stdio.h>
#include <string.h>
#include "llist.h"

#define NAMESIZE 20//字符数组的成员个数

struct stu//客户自己创建的数据结构体
{
	int id;
	char name[NAMESIZE];
	int math;
	int age;
	int tel;
};

void print(const void *data)
{
	const struct stu *p = data;
	printf("%d	%s	%d	%d	%d\n",p->id,p->name,p->math,p->age, p->tel);
}

int id_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const int *k = key;

	return !(p->id - *k);
}

int name_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const char *k = key;

	return !(strcmp(p->name, k));
}

int tel_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const int *k = key;

	return !(p->tel - *k);
}

int main(void)
{
	LLIST *handler = NULL;//handler指针指向头结点
	struct stu data;//存放客户自己的数据
	struct stu save;//存储拿出的数据
	struct stu *find = NULL;//指向找到的数据
	int i = 0;//循环变量
	int ret = 0;//接收返回值
	int find_id = 100;
	int find_tel = 10002;
	char *find_name = "stu4";

	handler = llist_create(sizeof(struct stu));
	//创建头结点
	if(handler == NULL)//判断头结点是否创建失败
		return -1;//创建失败,结束程序,并且返回-1
	
	for(i = 0; i < 5; i++)
	{
		data.id = 100 + i;//存储数据
		sprintf(data.name, "stu%d", i);//存储数据
		data.math = 100 - i;//存储数据
		data.age = 20 + i;//存储数据
		data.tel = 10000 + i;//存储数据
		llist_insert(handler,&data,TAILINSERT);//插入数据
	}

	llist_display(handler, print);//遍历链表

	printf("============================\n");
/*	
	find = llist_find(handler, &find_tel, tel_cmp);//查找
	if(find == NULL)//判断是否没有找到
		printf("Not Find It!\n");
	else
	{
		printf("Find It!\n");
		print(find);
	}
*/
#if 0
	ret = llist_delete(handler, &find_tel, tel_cmp);
	if(ret != 0)
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(handler, &find_tel, tel_cmp, &save);
	if(ret != 0)
		printf("Fetch It Is Failed!\n");
	else
	{
		printf("Fetch It!\n");
		print(&save);
	}
#endif

	printf("============================\n");

	llist_display(handler, print);//遍历链表

	llist_destroy(handler);//销毁链表

	return 0;
}

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#ifndef __LLIST_H
#define __LLIST_H

#define HEADINSERT 0
#define TAILINSERT 1

typedef void (*llist_op)(const void *);//定义函数指针类型
typedef int (*llist_cmp)(const void *,const void *);

struct llist_node//数据结点的结构体
{
	void *data;//data指针指向数据
	struct llist_node *prev;//prev指针指向前驱
	struct llist_node *next;//next指针指向后继
};

typedef struct llist_head//头结点的结构体
{
	int size;//保存客户创建的结构体的大小
	struct llist_node head;//
}LLIST;

LLIST *llist_create(int );//创建头结点

int llist_insert(LLIST *, const void *, int );//插入数据

void llist_display(LLIST *, llist_op);//遍历链表

void llist_destroy(LLIST *);//销毁链表

void *llist_find(LLIST *, const void *, llist_cmp);//查找

int llist_delete(LLIST *, const void *, llist_cmp);//删除

int llist_fetch(LLIST *, const void *, llist_cmp, void *);

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

LLIST *llist_create(int size)
{
	LLIST *handler = NULL;//指向头结点的指针

	handler = malloc(sizeof(LLIST));//为头结点开辟空间
	if(handler == NULL)//判断头结点空间是否开辟失败
		return NULL;//开辟失败,结束函数,并且返回NULL
	handler->size = size;//把客户结构体大小存储起来
	handler->head.prev = &handler->head;//前驱指向自己
	handler->head.next = &handler->head;//后继指向自己
	return handler;//把指向头结点的指针返回
}

int llist_insert(LLIST *handler,const void *data,int mode)
{
	struct llist_node *p = &handler->head;//保存头结点地址
	struct llist_node *newnode = NULL;//保存新建的数据结点

	newnode = malloc(sizeof(struct llist_node));//数据结点
	if(newnode == NULL)//判断数据结点是否开辟失败
		return -1;//开辟失败,结束函数,并且返回-1
	
	newnode->data=malloc(handler->size);//开辟数据空间
	if(newnode->data == NULL)//判断数据空间是否开辟失败
	{
		free(newnode);//释放数据结点的空间
		return -2;//数据空间开辟失败,结束函数,并且返回-2
	}
	memcpy(newnode->data, data, handler->size);//拷贝数据

	switch(mode)
	{
		case HEADINSERT : break;
		case TAILINSERT : p = p->prev; break;
		default : free(newnode->data); free(newnode);
					return -3;
	}
	newnode->next = p->next;
	newnode->prev = p;
	newnode->next->prev = newnode;
	newnode->prev->next = newnode;
	return 0;
}

void llist_display(LLIST *handler, llist_op op)
{
	struct llist_node *cur = NULL;
	for(cur=handler->head.next;cur!=&handler->head;cur=cur->next)
		op(cur->data);
}

void llist_destroy(LLIST *handler)
{
	struct llist_node *cur = NULL;
	
	for(cur=handler->head.next;cur!=&handler->head;cur=handler->head.next)
	{
		cur->next->prev = cur->prev;
		cur->prev->next = cur->next;
		free(cur->data);
		free(cur);
	}
	free(handler);
}

struct llist_node *_find(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	for(cur=handler->head.next;cur!=&handler->head;cur=cur->next)
		if(cmp(cur->data, find_data))
			return cur;
	return NULL;
}

void *llist_find(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	cur = _find(handler, find_data, cmp);
	if(cur == NULL)
		return NULL;
	return cur->data;
}

int llist_delete(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	cur = _find(handler, find_data, cmp);
	if(cur == NULL)
		return -1;
	///////cur指针已经指向要删除的结点
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;
	free(cur->data);
	free(cur);
	return 0;
}

int llist_fetch(LLIST *handler, const void *find_data, llist_cmp cmp, void *save)
{
	struct llist_node *cur = NULL;

	cur = _find(handler,find_data,cmp);
	if(cur == NULL)
		return -1;
	
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;
	memcpy(save, cur->data, handler->size);
	free(cur->data);
	free(cur);

	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist

可变长的通用性强的链表

=================================

可变长的结构体

 需要把可变长的因子放到结构体定义的最后

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <stdio.h>
#include <stdlib.h>

struct aaa
{
	void *data;
	struct aaa *prev;
	struct aaa *next;
};

struct bbb
{
	struct bbb *prev;
	struct bbb *next;
	char data[0];
};

int main(int argc, char *argv[])
{
	struct bbb *newnode = NULL;

	printf("sizeof(struct aaa) = %ld\n", sizeof(struct aaa));
	printf("sizeof(struct bbb) = %ld\n", sizeof(struct bbb));

	//newnode = malloc(sizeof(struct bbb));//开辟16byte空间
	newnode = malloc(sizeof(struct bbb) + 40);//开辟56byte空间

	return 0;
}

=================================

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


#include <stdio.h>
#include <string.h>
#include "llist.h"

#define NAMESIZE 20//字符数组的成员个数

struct stu//客户自己创建的数据结构体
{
	int id;
	char name[NAMESIZE];
	int math;
	int age;
	int tel;
};

void print(const void *data)
{
	const struct stu *p = data;
	printf("%d	%s	%d	%d	%d\n",p->id,p->name,p->math,p->age, p->tel);
}

int id_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const int *k = key;

	return !(p->id - *k);
}

int name_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const char *k = key;

	return !(strcmp(p->name, k));
}

int tel_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const int *k = key;

	return !(p->tel - *k);
}

int main(void)
{
	LLIST *handler = NULL;//handler指针指向头结点
	struct stu data;//存放客户自己的数据
	struct stu save;//存储拿出的数据
	struct stu *find = NULL;//指向找到的数据
	int i = 0;//循环变量
	int ret = 0;//接收返回值
	int find_id = 100;
	int find_tel = 10002;
	char *find_name = "stu4";

	handler = llist_create(sizeof(struct stu));
	//创建头结点
	if(handler == NULL)//判断头结点是否创建失败
		return -1;//创建失败,结束程序,并且返回-1
	
	for(i = 0; i < 5; i++)
	{
		data.id = 100 + i;//存储数据
		sprintf(data.name, "stu%d", i);//存储数据
		data.math = 100 - i;//存储数据
		data.age = 20 + i;//存储数据
		data.tel = 10000 + i;//存储数据
		llist_insert(handler,&data,TAILINSERT);//插入数据
	}

	llist_display(handler, print);//遍历链表

	printf("============================\n");
/*	
	find = llist_find(handler, &find_tel, tel_cmp);//查找
	if(find == NULL)//判断是否没有找到
		printf("Not Find It!\n");
	else
	{
		printf("Find It!\n");
		print(find);
	}
*/
#if 0
	ret = llist_delete(handler, &find_tel, tel_cmp);
	if(ret != 0)
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(handler, &find_tel, tel_cmp, &save);
	if(ret != 0)
		printf("Fetch It Is Failed!\n");
	else
	{
		printf("Fetch It!\n");
		print(&save);
	}
#endif

	printf("============================\n");

	llist_display(handler, print);//遍历链表

	llist_destroy(handler);//销毁链表

	return 0;
}

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


#ifndef __LLIST_H
#define __LLIST_H

#define HEADINSERT 0
#define TAILINSERT 1

typedef void (*llist_op)(const void *);//定义函数指针类型
typedef int (*llist_cmp)(const void *,const void *);

struct llist_node//数据结点的结构体(可变长的结构体)
{
	struct llist_node *prev;//prev指针指向前驱
	struct llist_node *next;//next指针指向后继
	char data[0];//可变长的因子
};

typedef struct llist_head//头结点的结构体
{
	int size;//保存客户创建的结构体的大小
	struct llist_node head;//
}LLIST;

LLIST *llist_create(int );//创建头结点

int llist_insert(LLIST *, const void *, int );//插入数据

void llist_display(LLIST *, llist_op);//遍历链表

void llist_destroy(LLIST *);//销毁链表

void *llist_find(LLIST *, const void *, llist_cmp);//查找

int llist_delete(LLIST *, const void *, llist_cmp);//删除

int llist_fetch(LLIST *, const void *, llist_cmp, void *);

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

LLIST *llist_create(int size)
{
	LLIST *handler = NULL;//指向头结点的指针

	handler = malloc(sizeof(LLIST));//为头结点开辟空间
	if(handler == NULL)//判断头结点空间是否开辟失败
		return NULL;//开辟失败,结束函数,并且返回NULL
	handler->size = size;//把客户结构体大小存储起来
	handler->head.prev = &handler->head;//前驱指向自己
	handler->head.next = &handler->head;//后继指向自己
	return handler;//把指向头结点的指针返回
}

int llist_insert(LLIST *handler,const void *data,int mode)
{
	struct llist_node *p = &handler->head;//保存头结点地址
	struct llist_node *newnode = NULL;//保存新建的数据结点

	newnode = malloc(sizeof(struct llist_node) + handler->size);//数据结点
	if(newnode == NULL)//判断数据结点是否开辟失败
		return -1;//开辟失败,结束函数,并且返回-1
	
	memcpy(newnode->data, data, handler->size);//拷贝数据

	switch(mode)
	{
		case HEADINSERT : break;
		case TAILINSERT : p = p->prev; break;
		default : free(newnode); return -3;
	}
	newnode->next = p->next;
	newnode->prev = p;
	newnode->next->prev = newnode;
	newnode->prev->next = newnode;
	return 0;
}

void llist_display(LLIST *handler, llist_op op)
{
	struct llist_node *cur = NULL;
	for(cur=handler->head.next;cur!=&handler->head;cur=cur->next)
		op(cur->data);
}

void llist_destroy(LLIST *handler)
{
	struct llist_node *cur = NULL;
	
	for(cur=handler->head.next;cur!=&handler->head;cur=handler->head.next)
	{
		cur->next->prev = cur->prev;
		cur->prev->next = cur->next;
		free(cur);
	}
	free(handler);
}

struct llist_node *_find(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	for(cur=handler->head.next;cur!=&handler->head;cur=cur->next)
		if(cmp(cur->data, find_data))
			return cur;
	return NULL;
}

void *llist_find(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	cur = _find(handler, find_data, cmp);
	if(cur == NULL)
		return NULL;
	return cur->data;
}

int llist_delete(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	cur = _find(handler, find_data, cmp);
	if(cur == NULL)
		return -1;
	///////cur指针已经指向要删除的结点
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;
	free(cur);
	return 0;
}

int llist_fetch(LLIST *handler, const void *find_data, llist_cmp cmp, void *save)
{
	struct llist_node *cur = NULL;

	cur = _find(handler,find_data,cmp);
	if(cur == NULL)
		return -1;
	
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;
	memcpy(save, cur->data, handler->size);
	free(cur);

	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist

=================================

封装通用性强的链表

main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110


#include <stdio.h>
#include <string.h>
#include "llist.h"

#define NAMESIZE 20//字符数组的成员个数

struct stu//客户自己创建的数据结构体
{
	int id;
	char name[NAMESIZE];
	int math;
	int age;
	int tel;
};

void print(const void *data)
{
	const struct stu *p = data;
	printf("%d	%s	%d	%d	%d\n",p->id,p->name,p->math,p->age, p->tel);
}

int id_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const int *k = key;

	return !(p->id - *k);
}

int name_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const char *k = key;

	return !(strcmp(p->name, k));
}

int tel_cmp(const void *data, const void *key)
{
	const struct stu *p = data;
	const int *k = key;

	return !(p->tel - *k);
}

int main(void)
{
	LLIST *handler = NULL;//handler指针指向头结点
	struct stu data;//存放客户自己的数据
	struct stu save;//存储拿出的数据
	struct stu *find = NULL;//指向找到的数据
	int i = 0;//循环变量
	int ret = 0;//接收返回值
	int find_id = 100;
	int find_tel = 10002;
	char *find_name = "stu4";

	handler = llist_create(sizeof(struct stu));
	//创建头结点
	if(handler == NULL)//判断头结点是否创建失败
		return -1;//创建失败,结束程序,并且返回-1
	
	for(i = 0; i < 5; i++)
	{
		data.id = 100 + i;//存储数据
		sprintf(data.name, "stu%d", i);//存储数据
		data.math = 100 - i;//存储数据
		data.age = 20 + i;//存储数据
		data.tel = 10000 + i;//存储数据
		llist_insert(handler,&data,TAILINSERT);//插入数据
	}

	llist_display(handler, print);//遍历链表

	printf("============================\n");
/*	
	find = llist_find(handler, &find_tel, tel_cmp);//查找
	if(find == NULL)//判断是否没有找到
		printf("Not Find It!\n");
	else
	{
		printf("Find It!\n");
		print(find);
	}
*/
#if 0
	ret = llist_delete(handler, &find_tel, tel_cmp);
	if(ret != 0)
		printf("Delete It Is Failed!\n");
	else
		printf("Delete It!\n");
#else
	ret = llist_fetch(handler, &find_tel, tel_cmp, &save);
	if(ret != 0)
		printf("Fetch It Is Failed!\n");
	else
	{
		printf("Fetch It!\n");
		print(&save);
	}
#endif

	printf("============================\n");

	llist_display(handler, print);//遍历链表

	llist_destroy(handler);//销毁链表

	return 0;
}

llist.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


#ifndef __LLIST_H
#define __LLIST_H

#define HEADINSERT 0
#define TAILINSERT 1

typedef void (*llist_op)(const void *);//定义函数指针类型
typedef int (*llist_cmp)(const void *,const void *);
typedef void LLIST;

LLIST *llist_create(int );//创建头结点

int llist_insert(LLIST *, const void *, int );//插入数据

void llist_display(LLIST *, llist_op);//遍历链表

void llist_destroy(LLIST *);//销毁链表

void *llist_find(LLIST *, const void *, llist_cmp);//查找

int llist_delete(LLIST *, const void *, llist_cmp);//删除

int llist_fetch(LLIST *, const void *, llist_cmp, void *);

#endif

llist.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "llist.h"

struct llist_node//数据结点的结构体(可变长的结构体)
{
	struct llist_node *prev;//prev指针指向前驱
	struct llist_node *next;//next指针指向后继
	char data[0];//可变长的因子
};

struct llist_head//头结点的结构体
{
	int size;//保存客户创建的结构体的大小
	struct llist_node head;//
};

LLIST *llist_create(int size)
{
	struct llist_head *handler = NULL;//指向头结点的指针

	handler = malloc(sizeof(LLIST));//为头结点开辟空间
	if(handler == NULL)//判断头结点空间是否开辟失败
		return NULL;//开辟失败,结束函数,并且返回NULL
	handler->size = size;//把客户结构体大小存储起来
	handler->head.prev = &handler->head;//前驱指向自己
	handler->head.next = &handler->head;//后继指向自己
	return handler;//把指向头结点的指针返回
}

int llist_insert(LLIST *h,const void *data,int mode)
{
	struct llist_head *handler = h;
	struct llist_node *p = &handler->head;//保存头结点地址
	struct llist_node *newnode = NULL;//保存新建的数据结点

	newnode = malloc(sizeof(struct llist_node) + handler->size);//数据结点
	if(newnode == NULL)//判断数据结点是否开辟失败
		return -1;//开辟失败,结束函数,并且返回-1
	
	memcpy(newnode->data, data, handler->size);//拷贝数据

	switch(mode)
	{
		case HEADINSERT : break;
		case TAILINSERT : p = p->prev; break;
		default : free(newnode); return -3;
	}
	newnode->next = p->next;
	newnode->prev = p;
	newnode->next->prev = newnode;
	newnode->prev->next = newnode;
	return 0;
}

void llist_display(LLIST *h, llist_op op)
{
	struct llist_head *handler = h;
	struct llist_node *cur = NULL;
	for(cur=handler->head.next;cur!=&handler->head;cur=cur->next)
		op(cur->data);
}

void llist_destroy(LLIST *h)
{
	struct llist_head *handler = h;
	struct llist_node *cur = NULL;
	
	for(cur=handler->head.next;cur!=&handler->head;cur=handler->head.next)
	{
		cur->next->prev = cur->prev;
		cur->prev->next = cur->next;
		free(cur);
	}
	free(handler);
}

struct llist_node *_find(LLIST *h, const void *find_data, llist_cmp cmp)
{
	struct llist_head *handler = h;
	struct llist_node *cur = NULL;

	for(cur=handler->head.next;cur!=&handler->head;cur=cur->next)
		if(cmp(cur->data, find_data))
			return cur;
	return NULL;
}

void *llist_find(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	cur = _find(handler, find_data, cmp);
	if(cur == NULL)
		return NULL;
	return cur->data;
}

int llist_delete(LLIST *handler, const void *find_data, llist_cmp cmp)
{
	struct llist_node *cur = NULL;

	cur = _find(handler, find_data, cmp);
	if(cur == NULL)
		return -1;
	///////cur指针已经指向要删除的结点
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;
	free(cur);
	return 0;
}

int llist_fetch(LLIST *h, const void *find_data, llist_cmp cmp, void *save)
{
	struct llist_head *handler = h;
	struct llist_node *cur = NULL;

	cur = _find(handler,find_data,cmp);
	if(cur == NULL)
		return -1;
	
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;
	memcpy(save, cur->data, handler->size);
	free(cur);

	return 0;
}

makefile

1
2
3
4


llist : main.o llist.o
	gcc -o $@ $^
clean :
	rm -rf *.o llist