专插本-C语言笔记

---

概念

1)程序结构是三种: 顺序结构 、选择结构(分支结构)、循环结构。
2)读程序都要从 main()入口, 有且只有一个 main 函数。
由main（）函数开始main（）函数结束
3)数据以二进制的形式保存；地址:数据存放的位置
4)Bit（位）：0或1
byte （字节） => 1byte==8bit
5）“ ”：字符串常量；‘ ’：字符常量
6）编译预处理不是 C 语言的一部分，不占运行时间，不加分号；在程序编译前进行一种预处理
7）C 语言编译的程序称为源程序，它以 ASCII 数值存放在文本文件中。
8）在函数中不可以再定义函数，但是可以声明
声明： 没有分配空间
定义： 创造了对象并分配了空间
9）算法：可以没有输入，但是一定要有输出。
10）break 可用于循环结构和 switch 语句。
11）逗号运算符的级别最低，赋值的级别倒数第二。
12）C 语言本身没有提供输入输出功能
13）由 printf 输出的数据都隐含右对齐
14）格式控制%m.nf：
多于 n 时，第一位小数做四舍五入处理；
少于 n 时，在小数的右边补零
15）函数由函数头和函数体组成
提示：在这里插入图片描述 这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

第一章 C 语言的基础知识

1、基础认识

1）C 语言编写的程序称为源程序，又称为编译单位。
2）每个 C 语言程序写完后，都是先编译（.c），后链接（.obj），最后运行（.exe）
3）这个过程中注意只有.exe 文件才可以运行

2、标识符

1）由字母，数字，下划线组成；第一个不能为数字
2）标识符分为关键字、预定义标识符、用户标识符

3、进制转换

图片引用：https://blog.csdn.net/huang1600301017/article/details/85332693

二进制：第一位（0[表示正数]、1[表示负数]）；16进制Max=2^15-1

4、整数与实数

1）C 语言只有八、十、十六进制，没有二进制。
但是运行时候，所有的进制都要转换成二进制来处理

3）小数合法写法：
C 语言小数点两边有一个是零的话，可以不用写
1.0 在 C 语言中可写成 1.
0.1 在 C 语言中可以写成.1

4）实型数据的合法形式：
e 前 e 后必有数，e 后必为（正负）整数
2.333e-1 等于 2.333×10-1

5）整型一般是 4 个字节,
字符型是 1 个字节，
双精度一般是 8 个字节：
long int x; 表示 x 是长整型
unsigned int x; 表示x 是无符号整型。

5、算术表达式和赋值表达式

核心：表达式一定有数值！
！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

A、算术表达式：+，-，*，/，%

“/” 两边都是整型的话，结果就是一个整型：3/2 的结果就是 1.
“/” 如果有一边是小数，那么结果就是小数：3/2.0 的结果就是1.5
%符号两边要求是整数[注意!!!]

B、赋值表达式：表达式数值是最左边的数值

a=b=5;该表达式为 5，常量不可以赋值。
1）int x=y=10: 错误，定义时，不可以连续赋值。
2）int x,y;x=y=10; 正确，定义完成后，可以连续赋值。
或者 int x=10，y=10；
3）赋值的左边只能是一个变量（a=b=c=1不能a，b，c=1）
4）int x=7.7；=》x 是 7
5）float y=7；==》x 是 7.00000 （%.1f：7.0）

C、复合的赋值表达式：

a*=2+3;等价于 a=a*(2+3);

D、自加表达式

++在前：先加后用，++在后：先用后加

E、逗号表达式

优先级别最低
z=（2，3，4） ==》 z 等于 4
z= 2，3，4 ==》 z 等于 2

补充：

1）空语句不可以随意执行，会导致逻辑错误。
2）注释不是 C 语言，不占运行时间，没有分号。不可以嵌套！
两种注释，以//开头的单行注释；以/开始，以/结束的块式注释
3）强制类型转换：
一定是 （int）a 不是 int（a），注意类型上一定有括号的。

4）三种取整丢掉小数的情况：
（１）int a =1.6；
（２）(int)a；
（３）1/2； 3/2；

6、字符

1）字符数据合法形式：

字符错误的形式：‘65’（一位数） “1”（单引号）
字符是可以进行算术运算的，记住： ‘0’-0=48
大写字母和小写字母转换的方法： ‘A’+32=‘a’ （相差 32）

2）转义字符：

转义字符分为一般转义字符、八进制转义字符、十六进制转义字符
一般转义字符 ：\0、 \n、 \’、 \”、 \
八进制转义字符 ： ‘\141’ （不写0）
十六进制转义字符 ：’\x6d’ （不写0， x 是小写）
字符型和整数
char a = 65 ;
printf(“%c”, a); 得到的输出结果：a
printf(“%d”, a); 得到的输出结果：65

7、位运算

1）位运算的考查：（若有小数，int它）
=》 <<左移一位表示乘以 2；
=》 >>右移一位表示除以 2。
例 2： 异或的位运算符号 ” ^ ”
0 异或 1 得到 1
0 （1）异或 0 （1） 得到 0

第二章

1、数据输出

1）使用 printf 和 scanf 函数时，要在最前面加上#include “stdio.h”
2）printf 可以有多个参数
3）printf（“a=%d，b=%d”，12, 34）==》 终端显示：a=13，b=34
4）int x=017；（加#就是完整呈现所有数值位数）

5）一个格式说明，两个输出变量，后面的 y 不输出
Int x=12,y=34;
printf（“%d ”，x，y）；====》12
6)

举例说明：

printf（“%2d”，123 ）； 第二部分有三位，大于指定的两位，原样输出 123
printf（“%5d”，123 ）； 第二部分有三位，小于指定的五位，左边补两个空格 123
printf（“%10f”，1.25 ）；（默认带六位小数），没有六位的补 0,。结果为 1.250000
printf（“%5.3f”，125 ）； 小数三位，整个五位，结果为 1.250（小数点算一位）
 printf（“%3.1f”，1.25 ）；小数一位，整个三位，结果为 1.3（要进行四舍五入）

7)最基本的数据类型包括整型、实型、字符型

8)整型常量有十进制、八进制数、十六进制数三种形式

2、数据输入

1）scanf（“a=%d，b=%d”，&a，&b）
A、终端输入： a=12，b=13
B、scanf 的第二个部分一定要是地址

2）指定输入的长度

A、终端输入：1234567
scanf（“%2d%4d%d”，&x，&y，&z）；	x：12，y：3456，z：7
B、终端输入：1 234567	 
scanf（“%2d%4d%d”，&x，&y，&z）；	x:1，y:2345，z:67

3）输入时候字符和整数的区别

scanf（“%d”，&x）；这个时候输入 1，（整数 1）
scanf（“%c”，&x）；这个时候输入 1，（字符‘1’ASCII 为整数 49）

4）putchar ,getchar 函数的考查
char a = getchar() 获取输入的一个字符给变量 a（getchar没有参数的）
putchar(‘y’) 输出字符 y

5）scanf 函数的格式
scanf(“%d %d %*d %d”,&a,&b,&c);输入1 2 3 4 =》a=1 b=2 c=4
（*d==》跳过输入的数）

6）保留三位小数，第四位四舍五入的程序

y=（int） （x*100+0.5）/100.0		保留两位，对第三位四舍五入 
y=（int） （x*1000+0.5）/1000.0 		保留三位，对第四位四舍五入
y=（int）（x*10000+0.5）/10000.0 	保留四位，对第五位四舍五入

（x和y都是float；y=（int）x这样吧小数部分去掉的）

第三章

1）注意

C 语言中是用非 0 表示逻辑真的，用 0 表示逻辑假的
C 语言有构造类型，没有逻辑类型

2)关系表达式：

A、表达式的数值只能为 1（表示为真），或 0（表示假）
int x=1,y=0,z=2;
x<y<z =》1
（1<0<2 =》1<0[0] =》 0<2[1]）
B、=是赋值；==是等于

3)补充

A、逻辑运算符号：&& || ！
B、！> && > || 优先的级别（！=和==优先级一样）
C、例题

int main（）{
	int a=1，b=1；
	printf（“%d %d %d”，！！a--||--b，a，b）；
	return 0；
}

！！抵消掉后=》a--（a还是1）=》因为||，--b不用运行
（||如果左边是1则不运算右边，&&如果左边是0则不运算右边的）
答案：1 0 1

C、表示 x 小于 0 大于 10 的方法
正确：(0<x)&&(x<10)
错误：0<x<10 （ 0<x 得到的结果为1或0；再和10比较永远都是1）

4）if 语句

A、else 是与最接近的 if 且没有 else 的语句匹配。
B、if 、for只管后面一个语句，要管多个，请用大括号
C、格式

if（a= =t）printf(“a”);
else if（b= =t）printf(“b”);
else if（c= =t）printf(“c”);
else pritnf(“d”);

5）条件表达式

变量=表达式 1 ？表达式 2 ：表达式 3 （前真后假）
例题：

int a=1，b=2，c=3，d=4，e=5；
k=a>b？c：d>e？d：e;

答案：k=5

6）switch 语句

A、没有 break 时候，从匹配的 case 开始执行到最后遇到break跳出switch语句
B、switch 只可以和break 一起用，不可以和 continue 用
C、格式

switch(x)  
{case : ….	case 2: ….
}

（x：是整型常量，字符型常量，枚举型数据；不可以是变量）

第四章

1、三种循环

A、for（） ； while()； do- while()三种
B、for 循环当中必须是两个分号，千万不要忘记
C、注意结束的条件，否则成了死循环
D、do-while()循环的最后一个 while();的分号一定不能够丢
do－ while 循环是至少执行一次循环。

2、Break和continue

Break：结束整个循环
Continue：结束本次循环

3、嵌套循环：一般用来处理二维数组

4、括号在这里的重要性

a = 3 != 2 和 （a=3）！=2 的区别：
（！=号的级别高于=号 所以第一个先计算 3！=2）
第一个 a 的数值是得到的 1；第二个 a 的数值是 3。

5、每行输出五个

for（i=1；i<=100；i++）{
printf（“%d”，i）；
if(i%5==0) printf(“\n”);
}

6、偶数表示

i%2==0 表示整除 2，同时表示是概数是偶数

7、逆序输出数据

int i=123;
while（i！=0）{
	printf（“%d”，i%10）； 
	i=i/10;
}

8、常出的考题

第五章

1、概念：

1. 函数：是具有一定功能的一个程序块，是 C 语言的基本组成单位。
2. 函数不可以嵌套定义。但是可以嵌套调用。
3. 函数名缺省返回值类型，默认为 int。
4. C 语言由函数组成，但有且仅有一个 main 函数！是程序运行的开始！

2、如何判断 a 是否为质数：

void iszhishu（ int a ）{
Int i;
for（i=2；i<a/2；i++）{
if(a%i==0){
printf（“%d不是质数\n”,a）;
Return;
}
}
printf(“%d是质数！\n”,a)；
}

3、如何求阶乘n！

int fun(int n){
int p=1;
for(int i=1;i<=n;i++) p=p*i;
return p;
}

4、函数的参数可以是常量，变量，表达式，函数调用

add（int x，int y）{
	return x+y；
}
int main（）{
	int sum；
	sum=add（add（7,8），9）；
}

请问 sum 的结果是多少？ 结果为 24

8、函数的参数，返回数值（示意图）：

9、参数之间的传递

实参（一开始有具体值的）和形参之间传数值和传地址的差别：
数值的话，形参的变化不会改变实参的变化（单向传递）
传地址的话，形参的变化就会有可能改变实参的变化（双向传递）

10、函数声明

函数名，函数的返回类型，函数的参数类型。
不一定要有：形参的名称
例如：
A、函数
int *fun（int a[] , int b[]）
{
…………
}
B、函数声明

int *fun（int *a , int *b）	注意数组就是指针
int *fun（int a[] , int b[]）	这种写法也是正确的
int *fun（int b[] , int c[]）	参数的名称可以随便写
int *fun（int * , int *）		参数的名称可以不写 

11、库函数

a、库函数是已经写好了函数，放在仓库中，可以直接引用使用。
b、常用的库函数

第六章

1、概念

指针所占内存大小一样
指针变量的本质是用来放地址，而一般的变量是放数值的

2、int *p

1） *p 是数值，p 是地址
2）*p 可以当做变量来用；*的作用是取后面地址 p 里面的数值
3）p 是当作地址来使用；可以用在 scanf 函数中：scanf（“%d”，p）；

3、* p++ 和（* p）++

*p++ =>最后再考虑星号

例题：

int *p,a[]={1,3,5,7,9};
p=a;

答案：*p++等于3     （*p）++等于2

4、二级指针

*p：一级指针：存放变量的地址
**q：二级指针：存放一级指针的地址
A、例题：

int x=7；
int*p=&x，**q=p；

答案：*p 为7；*q 为p；**q 为7

B、注意：**q=&x 的写法错误；因为二级指针只能存放一级指针的地址

5、指针的三名主义

数组名：表示第一个元素的地址。
数组名不可以自加，他是地址常量名。
函数名：表示该函数的入口地址。
字符串常量名：表示第一个字符的地址。

6、移动指针

char *s=“meikanshu”
while（*s）{
	printf（“%c”，*s）；
	s++；
}

这个 s 首先会指向第一个字母 m 然后通过循环会一次打印出一个字符，
s++是地址移动，打印了一个字母后，就会移动到下一个字母！

7、指针变量初始化

方法一：int a=2，*p=&a；(定义的同时初始化)
方法二：int a=2，*p；p=&a；(定义之后初始化)

8、传数值和传地址

9、函数返回值是地址

int *fun（int *a，int *b）{  ==》可以发现函数前面有个*，说明函数运算结果是地址
	if（*a>*b）return a；=》return  a 可以知道返回的是 a地址
 	else return b；
}
main（）{ 
	int x=7，y=8，*max；
	max = fun（&x，&y）； ==》由于 fun（&x，&y）的运算结果是地址，所以用 max 来接收。
	printf（“%d”，*max）；
}

10、补充

指针变量是存放地址的。并且指向哪个就等价哪个，所有出现*p 的地方都可以用它等价的替换

例如：int a=2，*p=&a；（声明：p=&a）
p=p+2;
(由于p 指向变量ａ,所以指向哪个就等价哪个，这里p 等价于ａ，可以相当于是 a=a+2)

第七章

1、基本概念

1）存放的类型是一致的。多个数组元素的地址是连续的
2）一维数组的初始化：
int a[5]；int a[]
注意赋值的个数a[5]里面只能放五个数
3）一维数组的定义：
int x=5，int a[x]；==>不合法，因为x是变量；需改成int x=5；int a[x]；
define P 5 int a[P]； 合法，define 后的的 P 是符号常量
4）二维数组初始化
int a[2][3]；int a[][2]
可以省略行的个数，不能省略列的个数

2、重要概念

a[10]
1）a是数组名，是第一个元素的地址，a[0]等价于&a
2）a是地址常量，a++或者a=a+2都是错的
3）a是一维数组名，是列指针，a+1就是下一列

a[3][3] [行][列]

1)a是数组名，是第一个元素的地址，是a[0][0]的地址
2)a是地址常量，同上
3)a是二维数组名，是行指针，a+1就是下一行
4)a[0]、a[1]都是地址常量，不可以进行赋值操作，都是列指针，a[0]+1,a[1]+1都是下一列
5)在二维数组中，a是行元素，a[0]是列元素

3、做题技巧

A、题目：

a[3][3]={1,2,3,4,5,6,7,8,9}

1 2 3
4 5 6
7 8 9

*（a[0]+1）等于2
*（a[1]+2）等于6

B、二维数组的行指针

Int a[1][2]
a是一个行指针，a+1下一行，搭配（）p[2]指针
a[0],a[1]是一个列指针，a[0]+1下一个数组元素，搭配p[2]指针数组使用

C、脱衣法则

a[2]变成*（a+2）
a[2][3]变成*（a+2）[3]或者*（*(a+2）+3)

文件

结构体

1、结构体成员引用

1）结构体变量名.成员名
2）结构体指针名->成员名
3）（*结构体指针名）.成员名
“ . ”（成员运算符） “->”（指向运算符）

2、共同体

枚举类型enum；共同体union（栈）
sizeof(struct)与sizeof(union)
[struct中为每个成员都独立分配空间；
union只按最大成员的大小进行内存分配，所有成员共享这个内存空间]

3、赋值

struct DATE{int year ;int month;int day;}dd={2018,5,18};
等于struct Date dd{2018,5,18}

其他考点

1、文件

A、Strcat（）：计算长度[长度不算\0]

char s0[10] = {‘A’,‘\0’,‘B’,‘\0’,‘C’}; ====》1
char s1[] = “\t\v\\0will\n”; ====》3
char s2[] = “\x69\141\n”; ====》3
printf(“%ld\t%ld\t%ld\n”,strlen(s0),strlen(s1),strlen(s2));

对于s0字符串，遇到’\0’就结束
对于s1字符串，‘\t’表示一个字符，一直到’\0’结束。
对于s2字符串，\x后两位表示十六进制数，\后边三个数字表示八进制数，'\n’表示一个字符。

用strcat，前面要加#include<string.h>

B、字符串拷贝函数strcpy

格式：strcpy(字符数组1，字符串2)
功能：
将字符串2拷贝到字符数组1中
返回值：返回字符数组1的首地址
说明：
字符数组1必须足够大
拷贝时’\0’一同拷贝

C、字符串连接函数strcat()

格式：strcat(字符数组1,字符数组2)
功能：把字符数组2连到字符数组1后边
返回值：返回字符数组1的首地址
说明：
字符数组1必须足够大
连接前，两串均以’\0’结束，连接后，串1的’\0’取消，新串最后加’\0’

D、字符串比较函数strcmp()

格式：strcmp(字符串1，字符串2)
功能：比较两个字符串
比较规则：对两串从左到右逐个字符比较（ASCII码），直到遇到不同字符或’'\0’为止
返回值：返回int型整数
若字符串1 < 字符串2，返回负整数
若字符串1 > 字符串2，返回正整数
若字符串1 = 字符串2，返回0

2、strlen和sizeof的区别

Sizeof（int）=》4
Sizeof会把/0算进去

3、define f（x（xx））和define f（x）xx

int a,b,c,d,e;
a=1;b=2;c=6,d=4;
e=f(a+b) * f(c+d) 

#define f（x）（xx）替换结果为：e=（a+ba+b)(c+dc+d) = 534=170
#define f（x） xx 替换结果为：e=a+ba+bc+d*c+d=1+2+12+24+4=43

4、malloc（分配内存）

int *p；
p = （int *）malloc（4）；
p = （int *）malloc（sizeof（int）；

以上两个等价 ，malloc 的返回类型是 void * 

5、递归

函数的递归调用一定要记得有结束的条件

6、函数指针

int add(int x, int y){
....
}
main(){
	int （*f）（）；
	f=add;
}

合法调用：add（2,3）；f（2,3）；（*f）（2,3）
f =>add的值 f=》add的地址 两者一样但是&add类型是void（），add的类型是void

7、数组长度

Char a[]={‘a’,’b’,’c’}; 数组长度为3，sizeof（a）为3
Char a[5]={‘a’,’b’,’c’};数组长度为5，sizeof（a）为5

8、scanf和gets的数据

输入：good good study！
scanf（“%s”，a）》good（scanf不接收空格）
gets（a）》good good study！（gets可以接收空格）

9、共同体

union TT{ 
	int a;
	char ch[2];
}

10、文件包含

no1.c 中有个#include”no2.c”把第二个文件的内容给包含过来

判断题：

一个文件必须要有 main 函数。 这句话错了。
例如：no2.c 就没有。 头文件一定是以.h 结束的。 这句话错了。例如：no1.c 中就是#include”no2.c”以.c结尾的。

11、字符串赋值

char ch[10]; ch=“abcdefgh”;错！数组名不可以赋值！
char *p={“abcdefgh”}; 错！不能够出现大括号！

12、字符串赋值函数

把s指针中的字符串赋值到t指针中的方法
while（ （*t=*s）！=null ）{s++；t++；} 完整版本
while（ *t=*s ）{s++；t++；} 简单版本
while（ *t++=*s++）； 高级版本

13、typedef

typedef 是取别名，不会产生新的类型，他同时也是关键字
typedef int qq int x 可以写成 qq x
typedef int *qq int *x 可以写成 qq x
Typedef int Num[10] typedef定义数组

14、Static

Static int x；默认值为0
Int x；默认值为不定值

填空题

1）程序设计语言：机器语言、汇编语言、高级语言
2）程序结构是三种: 顺序结构 、选择结构(分支结构)、循环结构
3）基本功能：数据表达、流程控制
4）算法：确定性、有穷性、可行性、1个或多个输出
5）算法表示形式：文字、流程图、伪代码、程序语言设计
5）C语言有32个关键字
6）先编辑源程序、（.c）编译源程序、（.obj）与库函数链接、（.exe）运行目标程序
7）三大类语句：注释语句、定义语句、执行语句（五类：控制语句、函数调用语句、表达式语句、空语句[{ }]）
8）基本类型：整型（int）、实型（float、double）、字符型（char）
9）函数记得加（）：scanf（）、printf（）
10）-128~127：char ；-32768~32767：int
11）证明一个字符是字母：c>=‘A’&&c<='Z’ || c>=‘a’&&c<=‘z’
12）仔细看printf的格式！！！
13）C语言循环语句中，for语句可省略循环条件表达式
14）数组：
首地址：数组名
程序执行时，不检查数组下标是否越界
15）put（数组名+2）==>从第三位开始输出
16）字符串常量不能相加
17）Scanf把读取的数字字符串转换为整形数

局部变量缺少储存类型：auto
不需要形参，放置形式参数表为空 /void
Return语句被执行，程序无条件从一个函数转到另一个函数
声明局部变量不能使用的储存类型：extern
Static：全局变量
自身调用自身：递归

第八章

1）p=&a[0]等价于p=a
2）Int b[10]，*p=b，*q；q=&b[5]=>q-p的值是 5 （地址相减，数组地址连续）
3）Int a[10],*p=a+3,则数组a的最后一个元素是p[ 6 ] （p[0]等于a[3];p[6]等于a[9]）
4）指针是一个特殊变量，里面存储的数值被解释为内存的一个地址
5）保证该程序无错，p的声明 void *p
6）&表示的功能取地址
7）Int a[3][4];若a[0][0]地址为2000，则a[1][0]的地址为2016 （int的内存是4）
8）Int（*p1）（）=>声明指针p1是指向函数的指针，p1里边存的就是函数的入口地址
9）函数分配一个唯一的地址，这个地址称为函数入口

第九章

1）访问该结构变量成员的形式：结构变量名.成员名
2）结构类型的每个成员数据类型可以是基本数据类型也可以是构造类型
3）声明struct {int day；char month；int year；}a，*b；b=&a；引用a.day的其他两种形式：

（*b）.day、b->day

4）Struct stru{int n;}str,*p=&str;(*p).n和

*p->n*

5）结构体和数组的区别：
结构体类型是数目固定、不同数据类型的有序数据集合（数组是相同的数据类型）
6）

Enum ani{
	mouse，cat，dog，rabbit=0，sheep，sow=6，tiger
	}；
	printf(“%d”,cat+sheep+cow)=>8    


(enum默认第一个是0，依次+1；sheep=rabbit+1）

7）Typedef char* STR；STR s； 等于char* s

第十章

1）EOF==-1
2）存储形式，文件可以分成ASCII文件和二进制文件
3）读取不存在的文件返回：null
4）预处理功能：宏定义,文件包含和条件编译
5）宏名都用宏定义中的字符串去替代：宏替代、宏展开