1.什么是程序：程序是用来完成特定功能的一系列指令
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。
要理解指针就要先理解计算机的内存。计算机内存会被划分为按顺序编号的内存单元。每个变量都是存储在内存单元中的，称之为地址。
#include <stdio.h>
int main ()
{
int var = 20; /* 实际变量的声明 此时的 VAR 这个变量是存在某个地址的，地址对应某个内存单元，该单元中存储了数据20 */
int *ip; /* 指针变量的声明 定义了一个指针 即一个内存单元的地址变量 */
ip = &var; /* 在指针变量中存储 var 的地址 就是将地址值赋值给指针这个变量*/
/* 在指针变量中存储的地址 利用&符号直接输出了var所存储的数据的内存单元的地址*/
printf("Address of var variable: %p
", &var );
/* 在指针变量中存储的地址 ip代表的是这个赋值到的地址的值 所以输出的是地址值 */
printf("Address stored in ip variable: %p
", ip );
/* 使用指针访问值 *ip代表的是定义到这个内存单元之后，内存单元中所存储的数据的值也就是将20赋值给var中20这个值 */
printf("Value of *ip variable: %d
", *ip );
return 0;
}
指针是一个变量，所以可以使用任何合法的变量名。在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。
然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。
但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。
所有指针在创建时都要初始化，如果不知道他指向什么就讲 0 赋值给他。必须初始化指针，没有被初始化的指针被称为失控指针(野指针）。
#include <stdio.h>
int main ()
{
int *p = 0;
int a ;
p = &a;
printf ("输入一个数字
");
scanf ("%d",p);
printf("%d
",*p);
}
实例定义了变量 a 和指针变量 p。p = &a;表示指针变量指向了变量 a，p 中存放的地址为 a 的地址 &a，*p 所指的是 p 中存放的地址 a 内存单元中的值。
/*按照偏移值访问函数形参内容实验*/
//二级指针
void Pros(char* a,int b,int e,char et)
{
char **p=&a;
//a==*p
printf("%p %p %p %p
%p
",&a,p,a,*p,&b);
printf("%s
",*p);
p++;
printf("%d
",*p);
p++;
printf("%d
",*p);
p++;
printf("%c
",*p);
return;
}
//一级指针访问
void Test(char* a,int b)
{
char *p=(char*)&a;
//a!=*p;
//printf("%p %p %p %p
",&a,p,a,*p);
//printf("%p
",&b);
//得出结果一级指针自加+1 二级指针自按照元素内容大小自加
//printf("%d %p
",*(++p),p);
//printf("%d %p
",*(p+8),p+8);
//a=a[0]一个printf函数以' '结束
//此时p=&a把元素首地址给了p或者说a只记录一个元素首地址的地址
//同等汇编语句 a：db 'Hello' b:db '16'
//所以 p=&a != p=a ;
/*
char *a="Hello";
char *b=(char*)&a;
printf("%p %p %p %p",&a,b,a,&(a[0]));
*/
//printf("%c %p %p
",*a,a,&(a[0]));
//printf("%c %p %p
",*(a+1),a+1,&(a[1]));
printf("%c
",*(*(char**)p));
//if p=a; *p=a;
p=a;
printf("%s",p);
return;
}
int main()
{
//Pros("Hello",5,66666,'a');
Test("Hello",16);
//指针转换问题
/*
char *a="Hello";//&a变量里面存储着a所指向的变量地址
//char **p=&a;
char *b=(char*)&a;
char **p=&a;
printf("%p %p %p %p
",&a,b,a,*b);
printf("%p %c
",&(*a),*(&(*(a+1))));
printf("%p %c
",a,*a);//此时a->H，*a=H;
printf("%p %c
",(*p),*(*p));
//p=&a,*p=a所指向的第一个元素的地址还需要一解才能访问正确数据
//所以1级指针需要解2次 所以进行强制转换
printf("%c
",*(*(char**)b));
//原试解 现在b=&a,*b= &a->a所以如果此时想正确访问H必须在解
*/
return 1;
}
参考地址
指针的一些复杂说明：
int p; -- 这是一个普通的整型变量
int *p; -- 首先从 p 处开始,先与*结合,所以说明 p 是一个指针, 然后再与 int 结合, 说明指针所指向的内容的类型为 int 型。所以 p 是一个返回整型数据的指针。
int p[3] -- 首先从 p 处开始,先与[] 结合,说明 p 是一个数组, 然后与 int 结合, 说明数组里的元素是整型的, 所以 p 是一个由整型数据组成的数组。
int *p[3]; -- 首先从 p 处开始, 先与 [] 结合, 因为其优先级比 * 高,所以 p 是一个数组, 然后再与 * 结合, 说明数组里的元素是指针类型, 然后再与 int 结合, 说明指针所指向的内容的类型是整型的, 所以 p 是一个由返回整型数据的指针所组成的数组。
int (*p)[3]; -- 首先从 p 处开始, 先与 * 结合,说明 p 是一个指针然后再与 [] 结合(与"()"这步可以忽略,只是为了改变优先级), 说明指针所指向的内容是一个数组, 然后再与int 结合, 说明数组里的元素是整型的。所以 p 是一个指向由整型数据组成的数组的指针。
int **p; -- 首先从 p 开始, 先与 * 结合, 说是 p 是一个指针, 然后再与 * 结合, 说明指针所指向的元素是指针, 然后再与 int 结合, 说明该指针所指向的元素是整型数据。由于二级指针以及更高级的指针极少用在复杂的类型中, 所以后面更复杂的类型我们就不考虑多级指针了, 最多只考虑一级指针。
int p(int); -- 从 p 处起,先与 () 结合, 说明 p 是一个函数, 然后进入 () 里分析, 说明该函数有一个整型变量的参数, 然后再与外面的 int 结合, 说明函数的返回值是一个整型数据。
int (*p)(int); -- 从 p 处开始, 先与指针结合, 说明 p 是一个指针, 然后与()结合, 说明指针指向的是一个函数, 然后再与()里的 int 结合, 说明函数有一个int 型的参数, 再与最外层的 int 结合, 说明函数的返回类型是整型, 所以 p 是一个指向有一个整型参数且返回类型为整型的函数的指针。
int *(*p(int))[3]; -- 可以先跳过, 不看这个类型, 过于复杂从 p 开始,先与 () 结合, 说明 p 是一个函数, 然后进入 () 里面, 与 int 结合, 说明函数有一个整型变量参数, 然后再与外面的 * 结合, 说明函数返回的是一个指针, 然后到最外面一层, 先与[]结合, 说明返回的指针指向的是一个数组, 然后再与 * 结合, 说明数组里的元素是指针, 然后再与 int 结合, 说明指针指向的内容是整型数据。所以 p 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数。
2.语言的分类：
低级语言：机器语言，汇编语言
高级语言：C，BASIC.....
面向对象的语言：C++,VB,JAVA...
高级语言编写的程序有两种方式被翻译成计算机能识别的目标程序：
（1）编译执行是将源程序翻译为一个可执行的目标程序，该目标程序脱离编译环境和源程序，独立存在和执行
（2）解释执行是将源程序逐句解释成二进制指令，解释一句执行一句，不生成可执行文件，执行速度比编译方式慢
4.计算机系统结构： ——冯.诺依曼
（1）计算机由控制器，运算器，存储器，输入设备和输出设备5个部分构成
（2）计算机用二进制，指令和数据均以二进制数形式表示和存放
（3）计算机按照程序规定的顺序将指令从存储器中取出，并逐条执行
程序设计的本质：设计能够利用计算机的5个部分完成特定任务的指令序列
5.算法及其特性，表示方法：
定义：解决一个问题所采用的一系列步骤
特性：有穷性，确定性，输入，输出，可行性
表示方法：自然语言，伪代码，流程图，N-S流程图
6.结构化程序设计方法：
（1）程序组织结构化（原则是对任何程序都以顺序结构，选择结构，循环结构作为基本单元进行组织）
（2）程序采用自顶向下，逐步细化，功能模块化的方法
8. void main(int argc, char *argv[])
argc:命令行中参数的个数
argv[ ]：指针数组，每个元素指向命令行中的字符串
C程序由函数构成且至少包括一个main()函数，而man函数只能有两个参数，一般写为argc和argv这种形式，可在操作命令状态下，调用main函数
其实大部分时间不写，也不调用main函数
2016年10月31日 21:23:34
大一的课本看了一下，感觉没什么干货，找到了以前自己写的两本笔记本，每天跟新笔记本的内容
一本是在大一暑假自学郝斌视频的时候记录的，另外一本是在大二上图书馆找的书自己整理的，以后的内容会结合两本一起更新。
1.什么是程序：程序是用来完成特定功能的一系列指令
2.语言的分类：
低级语言：机器语言，汇编语言
高级语言：C，BASIC.....
面向对象的语言：C++,VB,JAVA...
高级语言编写的程序有两种方式被翻译成计算机能识别的目标程序：
（1）编译执行是将源程序翻译为一个可执行的目标程序，该目标程序脱离编译环境和源程序，独立存在和执行
（2）解释执行是将源程序逐句解释成二进制指令，解释一句执行一句，不生成可执行文件，执行速度比编译方式慢
4.计算机系统结构： ——冯.诺依曼
（1）计算机由控制器，运算器，存储器，输入设备和输出设备5个部分构成
（2）计算机用二进制，指令和数据均以二进制数形式表示和存放
（3）计算机按照程序规定的顺序将指令从存储器中取出，并逐条执行
程序设计的本质：设计能够利用计算机的5个部分完成特定任务的指令序列
5.算法及其特性，表示方法：
定义：解决一个问题所采用的一系列步骤
特性：有穷性，确定性，输入，输出，可行性
表示方法：自然语言，伪代码，流程图，N-S流程图
6.结构化程序设计方法：
（1）程序组织结构化（原则是对任何程序都以顺序结构，选择结构，循环结构作为基本单元进行组织）
（2）程序采用自顶向下，逐步细化，功能模块化的方法
8. void main(int argc, char *argv[])
argc:命令行中参数的个数
argv[ ]：指针数组，每个元素指向命令行中的字符串
C程序由函数构成且至少包括一个main()函数，而man函数只能有两个参数，一般写为argc和argv这种形式，可在操作命令状态下，调用main函数
其实大部分时间不写，也不调用main函数
——————————————2016年11月1日 18:34:38————————————
1. C语言的数据类型
基本类型： 所谓“基本”，是指其值不可以再分解的数据类型。
整型
实型：
单精度
双精度
字符型
枚举类型
构造类型：利用现有的一个或多个数据类型构造新的数据类型
数组类型
结构体类型
共用体类型
指针类型：用于表示某个变量在内存中的地址
空类型：类型说明符为void，常用来定义没有返回值的函数
2. 变量
变量必须先定义后使用。定义变量时，系统自动检测出所需要的存储空间大小，然后为变量分配存储单元
标识符只能由字母、数字和下划线组成，且第一个字符必为字母或下划线
变量赋初值：（1）初始化：在定义变量的同时给变量赋初值
（2）先定义后赋值
3. 常量
（1）字面常量：整型常量，实型常量，字符型常量（必用‘’）
（2）符号常量：用一个标识符代表一个常量 #define 标识符 常量
（3）const常量：只读常量：const 类型标识符 变量标识符 = 初始化数据
或者 类型标识符 const 变量标识符 = 初始化数据
只能在定义时初始化，之后不能进行赋值，有点像java里的final
4. 八进制前缀是0，十六进制前缀是0X
5.整型数据的输入和输出
（1）标准输入输出文件
#include<stdio.h>
#include:预处理命令，将头文件包含到用户的源程序
stdio.h:标准输入输出头文件，提供输入和输出函数的原型
（2）printf的用法：
① printf("字符串")
② printf("输出控制符"，输出参数)
③ printf("输出控制符1 输出控制符2....."，输出参数1，输出参数2.....)
个数必须匹配
④ printf("输出控制符 非输出控制符（如转义字符）"，输出参数)
为什么需要输出控制符：
① 如01组成的代码可以表示数据也可以表示指令
② 如果01组成的代码表示数据，那么同样的01代码组合以不同的输出就有不同的输出结果
（3）scanf用法：
将从键盘输入的字符转化为输入控制符所规定格式的数据，然后存入以输入参数的值为地址的变量中
① scanf("输入控制符"，输入项地址列表)
② scanf("非输入控制符 输入控制符"，输入参数)
非输入控制符必须原样输入
例：scanf("m%d",&i)
若键盘敲入：m123n，则输出i显示123
scanf("%d,%d,%d",&i,&j,&k);
printf("i = %d,j = %d, k = %d",i , j, k);
若键盘敲入：1（空格）2（空格）3
则输出：i = 1,j = (乱码，不可预知)，3 = （乱码）
所以输入的字符不会丢弃
scanf("%c",&a);会记录回车符，即' '也会输入到a中，但%s就不会，%s以空格和回车作为结束
6.整型数据在内存中的存储方式
以补码的形式存储，正数的源码、反码、补码一样；负数的补码=反码+1
7. 实型常量与变量
名称 位数 有效数字
float 32 6~7
double 64 15~16
long double 64 15~16
浮点数的有效数字位决定数据的精度
浮点型数据非准确存储
实型数据的输入和输出：
m.n m为域宽 n为精度
高精度与低精度运算，结果为高精度
8.实型数据在内存中的存储方式
有效位数之外的将舍弃，因此有效数字的位数决定精度
将一个实属表示成小数部分和指数部分，分别存放
如：+123.567
+ 123567 + 3
数的符号位|数字部分|指数的符号位| 指数
9.字符型常量、转义字符与变量
（1） 字符常量：用‘’将其括起来
（2） 转义字符：“”后跟一个字符，代表一个特殊控制字符
（3） 字符型变量：char,一个字符型变量占一个字节的内存空间，可存放一个字符
字符型数据的输入输出：
（1）基本输入输出函数：i = getchar(),putchar(i)
(2) 格式输入输出函数：scanf,printf
字符串用“”括起来，包括转义字符
10. 运算优先级
算数 > 关系 > 赋值 > 逻辑
逗号表达式：表达式1，表达式2....表达式n
总表达式的值为右边表达式n的值，且,是所有级别中最低的
如：
i = 1+1，2+2；//i为4
11. 数据类型的转换
（1）隐式转换：① 转换使数据的字节长度变长，精度变高.
如float到double,short和char到int
② 赋值时，等号两边数据精度不同，则右边变为左边
如： int i = 1.234; //i为1
（2）强制类型转换：
（类型名）（表达式）
只将结果进行临时转换，不改变变量的数据类型
如：double k = 1.234;
int i = (int)k ; // i 为 1
int *p;
p = (int *)malloc(siezof(int)); //其中 （int *） 是强制类型转换
——————————————————2016年11月2日 23:57:42——————————————
1. 逻辑运算符和逻辑表达式
a&&b&&c a为假时，不再判断b,c；只有a真，b真的情况下，才判断c
a || b || c a为真，则不再判断b,c；只有a假，b假的情况下，才判断c
2. if
if(表达式) //表达式为真，else后面不跟判断语句
语句;
else //else总与它前面最近的未配对的if配对
语句；
3.switch
switch(变量或常量) //各个case和default的先后次序不影响运行
{
case 常量表达式 : 语句 ; //可在每个case后加break，来跳出switch否则将执行下一个case
....... .....
default : 语句; //若匹配的case没有语句，将执行下一个case的语句
}
4.表达式1 ？ 表达式2：表达式3
1为真，则执行2，否则执行3
5.while
while（表达式P） //先判断P，为真则进入循环
｛循环语句｝ //在循环语句中要有使P为假的语句
6.do....while
do
{循环语句}
while(表达式P)； //P为真时，执行循环
7.for
for(表达式1；表达式2；表达式3) //先执行表达式1，通常为赋值；表达式2为真，则循环；表达式3通常改变循环变量
｛循环语句｝ //三个表达式均能省，但‘;’不行
8. break
（1）跳出switch结构，并继续执行switch结构之后的语句
（2）跳出最近的循环语句，并继续执行循环结构之外的语句
（3）不能直接用于if
continue
结束本次循环，继续进行下次循环 //不能直接用于switch内
9.goto
无条件转向语句： goto 语句符号；
与if组合，可成为循环体；在循环体内可跳出循环体；
但goto使程序流程无规律，限制使用
——————————————————2016年11月4日 18:06:24————————————————
1.一维数组的定义：
数据类型 <数组名>[常量表达式] ——不包括变量
int a[0] ； 返回值为a[0]的首地址
在对数组全部元素赋初值时，可以不指定数组的长度，数组长度与初始化的元素个数相等
如： int a[ ] = {1,2,3} ; 数组长度为3
定义：（1）为n个变量连续分配存储空间
（2）所有的变量数据类型必须相同
（3）所有变量所占字节大小必须相同
初始化：
（1）完全初始化： int a[5] = {1,2,3,4,5} ;
（2）不完全初始化： int a[5] = {1,2,3} ; //为初始化部分自动天0
（3）不初始化： int a[5] ; //所有元素为垃圾值
（4）清零 ： int a[5] = {0} ;
只有在定义数组的同时才可以整体赋值，其他情况下整体赋值都为错
2.二维数组的定义
数据类型 <数组名>[常量表达式1][常量表达式2] //表达式1为行，表达式2为列
若二维数组的所有元素都初始化数值或分行初始化数值时，第一维度可以为空，第二维度不能省略
如： int a[][2] = {{1,2},{3,4}} ;
3.多维数组
不存在多位数组，因为内存是线性一维的；n为数组可以当作每个元素是n-1维数组的一维数组
4.字符数组的定义和使用
数组元素在使用时，仅看作字符类型的变量
（1）字符数组的元素用%c格式进行输入输出
（2）字符数组元素可以和其他元素一样处理
（3）未被初始化的元素将被赋值为0，即字符 ‘ ’
5.字符串数组
字符串依次存放在字符数组中，在有效字符的后面以‘ ’作为结束标志
char a[] = {"i am "} ;
char a[] = "i am " ;
（1）使用%s进行输入字符串
（2）使用gets和puts输入输出 gets(s1) gets(2)
6.字符串处理函数 string.h
（1）strlen（字符串）
用于计算字符串的有效字符的长度
（2）strupr（字符串） 小写变大写
strlur（字符串） 大写变小写 都返回字符串的首地址
（3）strcpy（字符串1，字符串2）
将字符串2中的所有字符复制到1中，返回1的首地址
1的长度必须超过2，2可以是常量字符，也可以是字符数组中存放的字符串
（4）strcat（字符数组1，字符数组2）
将2连在1之后，并保存在1中，返回1的首地址
1的长度必须大于字符串1和2的长度之和；
2可以是常量字符串，也可以是字符数组中存放的字符串；
1中的‘ ’被删除，然后连接2
（5）strcmp（字符串1，字符串2）
比较两个字符串大小。从左到右依次比较，知道出现不同字符或‘ ’
若1>2，则返回值为正； = 返回值为0；< 返回值为负
————————————————2016年11月5日 23:14:51————————————————————
函数是C的基本单位
1.函数的定义
函数类型 <函数名> （[<形参表>]）
｛
声明部分；
执行语句部分；
｝
（1）函数中不能再嵌套定义函数
（2）不论return语句返回值为何种类型，都将自动转换为函数类型
（3）空函数什么都不做
2.函数调用
函数定义后，才能调用。
如果函数定义中有形参，在调用时，应传递实际参数
函数调用的一般形式：
<函数名> （[<实参表>]）
（1）实参与形参的类型，个数和位置应一一对应
（2）实参与形参的变量名可一致，也可不一致
若函数写在主函数之后，需加函数声明 声明时要‘；’
3.参数的传递
函数传递的方向是单向传递；实参和形参所占内存不同
如果实参列表包括了多个实参，则执行顺序不确定（VC++中先右后左）
4.函数返回值
（1）无论返回值为何种数据类型，都将自动转换为函数类型
（2）函数类型可以省略，默认为int
（3）return 可以退出或结束函数
（4）一个函数有多个return语句，执行哪一个则带回哪一个的返回值
（5）void 函数无返回值
5.局部变量和全局变量
局部变量：作用范围只在函数内部的变量，函数内部定义
全局变量：函数外部定义，作用范围从定义位置到该文件结束
（1）若局部变量与全局变量名称相同，则优先使用局部变量
（2）全局变量在全部执行过程中都占用内存
（3）尽量避免使用全局变量
6.变量的存储类别和生存期
动态存储方式：（1）函数形式参数 （2）函数内部定义的变量 函数结束时，释放空间
静态存储方式：（1）全局变量 （2）被static定义的局部变量 （静态存储变量默认为0）
（1）auto：默认，现在没什么用了
（2）static：声明静态局部变量（注意与JAVA中的不同）
（3）register：将变量放入cpu内部的寄存器，从而提高效率
（4）extern：声明变量是定义在其他文件中的外部变量
静态存储方式定义的内容，仅能在本函数使用么不能外部引用
7.文件包含
#include <stdio.h> ：标准方式（系统直接在存放C库函数文件的系统目录寻找）
#include "stdio.h" ：先在当前目录寻找，没有再按标准方式寻找
包含系统头文件，通常用 <>
包含自己编写的文件，通常用 ""
8.条件编译：希望程序中一部分语句只在满足一定条件时才能编译
（1）#ifdef 标识符 //若标识符在之前已被宏定义过，则编译1
程序段1
#else
程序段2
#endif
（2）
#ifnded 标识符 //若标识符在之前没被宏定义过，则编译1
程序段1
#else
程序段2
#endif
（3）
#if 表达式
程序段1
#else
程序段2
#endif
——————————————————2016年11月6日 19:29:29————————————————
1.地址和指针
地址：内存单元的编号
指针：内存单元的地址
所以，地址 == 指针
2.变量的指针和指向变量的指针变量
变量的指针：变量的地址
指针变量：用于存放指针的变量
定义： 类型说明符 * 指针变量名 例：int *a;
与指针相关的运算符： （1） &：取地址符
（2） * ：指针运算符（取得该指针的内容）
定义中的*仅是一个表示，指出它后面的变量是指针变量
两个指针变量指向同一块连续空间中的不同存储单元，则可以相减
指针变量只占4个字节
3.数组的指针和指向数组的指针变量
数组名代表数组的首地址，即第0号元素的地址 a == &a[0]
若 p = &a[0] 则 : p+i == a+i ==&a[i]
*与++的优先级相同，所以自右向左： *p++ == *(p++) *++p == *(++p)
4.多维数组
a[i][j] == *(a[i]+j) == *(*(a+i)+j)
5.字符串
字符串的表示形式：
（1）用字符数组从存放或处理字符串
char a[] = "I LOVE" ;
（2）用字符指针指向字符串
char *a = "I LOVE" ;
注意：（1）字符指针变量是一个变量，用于存放字符串的首地址
字符串本身是存放在以该地址为首的一块连续的内存空间中
（2）对字符指针变量赋初值
（3）指针变量未取得确定地址时，不要用
6.指针与函数
函数名是函数所占内存的首地址，也成为函数的指针
指向函数的指针变量：
类型说明符 （*指针变量名）（函数参数列表）;
例： int (*p)(int ,int )
调用： （*指针变量名）(实参表)
例: int max(int x,int y)
{.......}
int main()
{
int (*p)(int ,int);
p = max;
int a,b,c;
c = (*p)(a,b);
.......
}
函数指针变量进行算数运算符时无意义
指向函数的指针，可作为函数参数
返回指针值的函数：
类型说明符 * 函数名 （形参表）
7.指针数组和指向指针的指针
指针数组：每一个元素都为指针类型
类型说明符 * 数组名[数组长度] int *a[6];
注： int (*p)[3] : P表示一个指向二维数组的指针变量，列数为3
int *p[3] :P表示一个指针数组，有三个元素
指向指针的指针：
一个指针变量存放另一个指针变量的地址
类型说明符 **指针变量名
注：（1）char **p == char *(*p)
p是指向一个字符指针变量的指针变量
（2）**p == *(*p)
*P是取得p指向的指针变量，*（*p）取得其值
8.动态内存分配
int *p = (int *) malloc(seizeof(int)) ;
free(p) ;
动态内存由程序员手动分配，释放，在堆中分配
静态内存由系统分配，释放，在栈中分配
calloc函数：一次可以分配n块连续空间
调用：（类型说明符 *）calloc（n,size）
区别：malloc函数不能初始化所分配的内存空间，但calloc可以
calloc会将分配的内存空间中的每一位都初始化为0
1.文件：ASCII码文件（文本文件）与二进制文件
缓冲文件系统与非缓冲文件系统（系统整体效率下降）
2.文件的操作：
（1）用fopen函数打开文件
（2）进行读写操作
（3）用fclose函数关闭文件
3.定义文件类型指针变量：
FILE *变量名