C语言笔记

C语言笔记

c = 3;
printf(“%d”, c);

%d 十进制
%o 八进制
%x 十六进制

计算 1.0 + 2.0

#include <stdio.h>
void main(){
float a;
float b;
float c;
a = 1.0;
b = 2.0;
c = a + b;
printf(“%f”, c);
}
stdio.h 是printf的包

//总结

1. c程序是由函数构成的，函数是程序的基本单位
2. 程序要运行，必须要有一个main函数（主函数），有且只有一个，程序运行时，就从main函数开始，直到main函数结束，程序就终止。
3. main函数在程序中的任意位置，不一定在程序的开头，运行时从main函数开始
   4.函数与函数之间时调用与被调用的关系
4. 函数的构成，函数头 + 函数体
   函数的头： 函数的返回值类型 函数名称（形参）
5. 函数分为系统定义的和用户定义的
   7.注释 // /段落注释/

C程序的开发步骤

1. 写程序，存为 .c的文件
2. 编译器（翻译）开始编译程序，生成 .obj文件（目标文件）
3. 链接： 多个obj文件会连接在一起，生成.exe 文件（可执行文件）
4. 运行： 运行.exe文件

数据类型
作用： 决定数据在内存中，开辟多大的空间
整形： short 　 int long
2 4 >=4
浮点 float double
4 8
字符 char
1
空类型 void 构造类型（人为创造的）
struct 结构体
union 共用体
enum 枚举
数组类型
逻辑类型 true false
整形： short int log 等价于 signed int 、 signed float 、 signed long
有符号整型 signed int signed 是系统缺省的 正、负都可以放置
无符号 unsigned int 只能存放正数

//源码 补码
内存中是二进制存储。 且是二进制补码的形式

内存中将最高位当作符号位
补码就是源码的基础上，保留了符号位不变，将其他的位取反后加1 得到补码

结论，正数的补码和源码是相同的，负数的补码需要取反加1
1字节，有符号范围是 -128 ～ 127
无符号，范围是 0 ～ 255

2.浮点： float 单 double 双
4字节 小数点后6位
double 8字节，小数点后15位有效
3.字符 char 1字节，存字符 a b c d

各种类型又分常量和变量
常量，运行过程中其值保持不变的量
变量，运行过程中其值可以进行改变

例如： int a

整型常量和整型变量
整型常量有三种表达方式：
1> 十进制整型： 用0～9之间的数组成 %d
2> 八进制整型： 用0～7之间的数组成，没有 8 9 ，且用0开头 %o
注意： 018 error 八进制没有8
3> 十六进制整型： 用0～9/a-f/A-F 之间的数组成，且用 0x开头 %x
如 0xff

总结：
整型数据中默认的类型是int 如果表示long 型
如 5 int 5L
八进制一定没有 8/9
十六进制 只有 0～9/a-f/A-F

例如：
int a = 50;
int b = 050;
int c = 0x50;
printf(“%d %d %d”, a,b,c)

浮点型
指数表达方式 aeb a,b必须存在并且 b不能为小数
例如 2.5E2
浮点型数据的默认类型是double，如果要表示float 用 F/f
例如 2.5F 2.5f

字符型常量
普通字符串常量，用单引号扩起来的1个字符
‘a’ ‘b’ ‘A’

‘a’ 97
‘A’ 65
‘0’ 48

转义字符： 用单引号扩起来，且用 \ 开头
如 ‘\n’ 表示回车
‘\b’ 退格
‘\0’ 表示空字符，ASCII值是 0
‘0’ 和 ‘\0’ 是否相等，答案是不等
一个是0 一个是48
两种特殊的转义字符
‘\ddd’ ddd表示1-3位八进制数据 ‘\123’
‘\xhh’ hh表示1-2位十六进制 ‘\xff’

字符与整数是一一对应的，二者可以通用
char c = ‘A’ 等价于 char c = 65

数字字符和数字的转换 ± 48 ‘0’
char char=‘2’;
printf(“%d”, ch); //50
printf(“%d”, ch - ‘0’); //2

字符串常量
C语言中没有字符串类型，但有字符串数据，采用字符数组形式存放
字符串常量定义： 用双引号扩起来的0个或多个字符组成的序列，且系统自动加 \0 字符做结尾

例如 “” 空串
“abc” 组成 ‘a’ ‘b’ ‘c’ ‘\0’ 共4个字符，每个字符都占用内存空间

重点理解2个概念
字符串占据内存空间的大小
字符串占据内存空间的大小，可以用sizeof() 运算符计算
printf(“%d”, sizeof(“abc”)); 4
字符串的长度，是从指定的位置（默认从头开始），向后数，直到首次遇到 \0 字符前的字符个数
“abc” 长度为3
printf(“%d”, strlen(“abc”)); 3

字符串与字符的区别

1. 界定符不通
   串 “” 字符 ‘’
   2.长度不同
   串： 0个或者多个 字符： 固定1个
   例如： “” 长度为0
   ‘’ ‘ab’ 都是错误的

例如：（这是一个题型误区）
“\ba\016ef” sizeof 6 strlen 5 ‘\b’ ‘a’ ‘\016’ ‘e’ ‘f’ ‘\0’
“\ba\086ef” sizeof 8 strlen 2 ‘\b’ ‘a’ ‘\0’ ‘8’ ‘6’ ‘e’ ‘f’ ‘\0’

//strlen 函数的包是 <string.h>

标识符
定义： 程序中用来表示变量名，函数名，符号常量名，数组等
分类： 系统定义和用户定义的

系统定义和
1.关键字： 数据类型： short int char float double long
命令字： if else while for break continue
存储类别： auto static register extern
运算符： sizeof

关键字不可以被修改，必须是小写

2. 预定义标识符
   包括库函数名，和编译处理命令
   库函数： printf strlen strcpy scanf
   编译预处理命令： include define

说明： 预定义标识符可以被用户修改的，但会失去原有的功能

int define = 10；

用户自定义的标识符由 数字，字母，下划线三种符号组合而成，且首字符不能是数字

int a3 ok
int 3a error

说明
1.不能使用关键字做用户自定义标识符
2.不能用数字开头
3.可以使用系统预定义标识符
4.标识符中严格区分大小写

类型提升和强制类型转换
//字符运算是返回的是 int

强制类型转换 (int)2.5
float x = 2.5;
int k = (int)x;

x float
k int

数据的输入和输出

进入内存 输入，离开内存 输出
文件：
打开 输入
保存 输出
%f 默认小数后保留6位

输入和输出函数

1. 单个字符的输入和输出
   getchar （从键盘上输入任意一个字符） putchar
   2.有格式的输入和输出
   scanf printf
2. 字符串的输入和输出
   gets puts

1，getchar
ch = getchar();

2. putchar()
   char ch = ‘a’
   putchar(ch); a
   putchar(ch - 32); A

3. printf
   //输入格式
   %d 有符号十进制
   %o
   %x
   %u 无符号十进制
   %f
   %e 指数形式
   %c 单个字符
   %s 字符串
   输出百分号 %%
   printf(“%d%%”, 80); 80%

附加格式： l
例如 %ld %lo %lx 输出long型

位宽，（输出的时候，可以进行占位）
printf(“%5d”, 1234); _1234
printf(“%.2f”, 1.26); 1.27 (保留2位小数)
printf(“%5.2f”, 1.267); _1.27 (5代表的是总共5位算上小数点，2是保留2位小数)
printf(“我们的成绩是%f”, 80); 我们的成绩是80
printf(“%d”, a,b,c); 只能输出一个a值
格式说明，决定了输出的类型和个数
格式说明符中只有 %e %x 允许使用大写，其他的必须是小写
输出% 使用 %%

4. scanf
   int a;
   float b;
   scanf(“%d%f”, &a, &b);
   scanf(“a=%d,b=%f”, &a, &b);
   普通字符要原样输入 => 输入的值应该是 a=1,b=2
   格式说明
   %d
   %o
   %x
   %u
   浮点
   %f 表示float
   %lf 表示double
   %e 输入指数型
   %c
   %s
   输入是与 d o x 进行组合表示long型
   %ld %lo %lx
   m 表示位宽，是输入需要截取多少
   scanf(“%3d”, &a);
   输入 12345 ， a=123
   输入 12 a=12

//输入中不能使用 .n ，输入数据不能指定精度
多个数据输入，需要使用分割标记
比如 scanf(“%d%d”); 如果想要输入3和4就没法输入了，系统会认为好似34
所以需要分割符
隐式分割符有 空格 回车 tab
显示的分割符 scanf(“%d,%d”, &a, &b);
这个时候就可以使用 ,

对于字符型数据，则不能用隐式分割标记，则要连续输入
char c1, c2;
scanf(“%c%c”, &c1, &c2); AB

单目运算符
++ – + - ! ~ & *
三目
? :
双目 除了单目和三目都是

优先级别

1. 运算符结合操作数的先后顺序
   结合性
   优先级别相同看结合性
   右结合性（从右向左）
   单目 条件 赋值
   其余的都是左结合性

例如： -a++ 等价于 -(a++)

算数运算符

• • • / % ++ – + -

1. 除法
   结合类型提升
   取余 ，两个操作数必须是整型

2. 幂的运算
   函数 pow(a,b)

3. 开平方
   sqrt(a); a的开平方
   abs(a); 绝对值整型
   fabs(a); 求浮点型的绝对值
   log(a); 默认就是以e为底的对数

以上函数使用的包在 math.h

4. ++ – 自增 自减
   形式，前缀 后缀

++a 先进行+1，在使用
a++ 先使用在 +1

对于函数参数的求值顺序，从右向左计算
int a = 2;
printf(“%d%d”, a, ++a); 3,3

//全是前缀的计算
int a = 5, z;
z = ++a * --a;
//z = 25

运算符的优先级别
++ – + - 高于 * / % 高于 + -
单目 高于 双目 高于 三目

C语言中使用 1 代表true 0 代表false
5 > 2 // 1
5 < 2 // 0

关系运算符高于 == ！=
例如 a = 5 > 2 等价于 a = (5 > 2)

逻辑非! (就是取反)
!5 // 0
!0 //1

逻辑与 &&
5 && 3 //1
5 > 2 && 3 < 1 // 0

逻辑或 ||
5 > 2 || 3 < 1 // 1

&& 和 || 具有短路运算

// 赋值过程中类型发生改变

1. int a = 2.5; a的值就会变成2，截断小数部分
2. float a=2; a 的值是 2.0

//按位与，或，非
按位的操作都是针对二进制的
～ 按位取反，0变成1 ， 1变成0
& 按位与，只有对应位同为1，结果才是1
｜ 按位或 ， 只要对应位有1，结果就为1
^ 异或 ， 不同为1，相同为0

例如：
2^3
0000 0010
0000 0011
0000 0001

//移位
9 -> 1001

>> 向右移位， 双目， 例如 9 >> 2
规则，所有位向右移动，右端被挤掉了，左端有空余，空余用0占位
0000 00 10  相当于除2
<< 向左移位，双目，例如： 9 << 2
规则，所有位向左移动，左端被挤掉了，右端空余，空余用0 占位
00 100100 相当于乘2

三元运算符
逗号运算符
从左到右依次计算每个逗号， 最后一个逗号的结果为表达式的结果
例如：
int x=14, y=15;
y=((x=3*y, x+6), x-1)
y = 44

其他

& 取地址
* 指针运算符 如： *a 取 a房间的内容
sizeof() 计算占内存空间的大小

重点理解
int a=-1, b=1, c;
c = ++a == b-- ? a + 2 : b + 3;
//c = 3, 因为运算过程中有个b–

if 控制语句，如果不写 {}, 那么就到第一个分号结束

如果不写 {} 可能需要进行else 配对

swich 控制语句 （和ruby完全不相同）
#include <stdio.h>
int main() {
  switch(3){
    case 4: printf("%s", "4");
    case 2: printf("%s", "2");
    case 3: printf("%s", "3");
    default: printf("%s", "5");
  };
  return 0;
}

注意3点

1. 当switch 表达式的值会和下面case进行判断，找到第一个成功的，正常执行，下面的case将不在进行判断，默认全部都会执行
2. 代码书写顺序，影响结果，按从上到下顺序执行 （牢记，按照过程式编程）
3. default 是全部不满足才会走，放到下面走了，是因为没有break全部都执行了

//循环结构
while
do while
for 循环的每个条件都可以进行省略
break 结束循环
continue 结束当前循环

//函数的构成
函数头和函数体
函数头： 函数头构成：函数的返回值类型+函数名称（形参）
函数体就是 {}

//函数分类
1.系统定义， printf， scanf， getchar， putchar， abs， pow, fabs, sqrt, log
2.用户定义的
学习函数掌控三方面

1. 学习定义一个函数
2. 学习使用一个函数
3. 学习声明一个函数
   例如：
   //存在返回值类型
   int add(int a, int b){
   int k;
   k = a + b;
   return k;
   }

//没有返回值类型
void add(int a, int b){
int k;
k = a + b;
}

如果有返回值类型，那么就必须进行返回值类型的标注， 也就是那个int
如果没有返回值，就不需要返回值类型，但是需要定义 void

//函数的调用 （调用就向rails类方法的调用）
例如：
void main(){
int a = 3, b = 4;
int t;
t = findMax(a,b); a,b实参
printf(“%d”, t);
}

//判断输入的字符是数字字符

if(ch >= ‘0’ && ch <= ‘9’)

//函数的声明
当函数的定义位置在，调用位置之下，需要对函数进行声明；
声明就是定义函数的那句话
例如： int add(int a, int b); //函数的声明 （a, b 可以省略，写2个int也行）

//局部变量和全局变量
方法内部是局部变量，和ruby一样，但是和块不一样，别有误区

//存储类别： 4个关键字
auto
static
register
extern
作用： 决定变量或函数存储位置和生命周期，使用范围

auto 自动的 仅修饰局部变量，没有初值， 被存储在动态区，系统默认类别

static 静态的 可以修饰局部变量也可以修饰全局变量，还可以修饰函数
静态局部变量 静态全局变量 静态函数

register 寄存器 仅修饰局部变量，没有初值，被存储在cpu的寄存器中

extern 外部的 修饰全局和函数
用来扩展全局变量和函数的的使用范围， 不能起定义变量的作用

extern 可以扩展文件，所以全局变量就可以夸文件
static的全局变量只能在本文件中使用
static的局部变量也可以保存这个值，当循环调用方法的时候，值保留了上一次的

//数组
数组的定义
int a[10]; //去内存定义了连续的10个房间
define n 10
int a[n]; 这样可以，可以使用字符常量

错误的定义方式
int a[2.5]
int a(10)
int a = 10;
int a[n]
int a[0…9]
int a[]
int a[0]

正确的
int a[10];
int a[2+4];
#define N 100
int a[n]

//一维数组的初始化赋值
int a[5] = {1,2,3,4,5};
int a[5] = {1,2,3}; //为部分元素赋值
说明：初始化赋值时， 只要给元素赋值剩余的才是0, 光定义默认不是 0

int a[]; error
int a[] = {1,2,3}; ok
定义的时候不能不写长度，但是如果定义兼赋值就可以不给长度了；

数组取地址值 &a[0] 、 &a[1]

//对于数组的求值，可以使用循环然后取下标的方式
数组名能表示空间首元素的地址值，但是他是常量不能做 a++ error
数组名+1 (a+1) 表示下一个房间的地址
例如：
int a[5]={1,3,5,7,9};
a a+1 a+2
&a[0] &a[1] &a[2]

//一维数组做函数的参数（也就是函数传递数组）

//二维数组
两种赋值方式
int a[3][4]={1,2,3,4,5,6,7,8,9}; //按内存存放形式进行赋值
int a[3][4]={
{1,2,3,4},
{5,6,7,8},
{9,0,0,0},
}

二维数组的取地址方式
int a[3][4];
行地址
a 等价于 &a[0]
列地址
a[0] &a[0][0]
a[0] + 1 &a[0][1]

//C语言中没有字符串类型，但是有字符数组
char a[5]={‘a’, ‘b’, ‘c’, ‘d’, ‘e’};
如果没给全，默认值是 0 或者 ‘\0’ ,注意不是 ‘0’

可以使用字符串
char s[5]={“abcd”}; 按字符算空间，切记还有一个 ‘\0’
char a[5]=“abcd”;

例如：字符数组常用的循环
int i;
for(i=0;i<strlen(str);i++)
或
for(i=0;str[i] != ‘\0’, i++)

//注意输出字符串
printf(“%s”, …) …这个位置如果是字符数组，需要给数组首个字符的地址；

// 二维字符数组
char st[3,10]={‘a’, ‘b’, ‘c’};
char st[3][10]={“abc”, “def”, “123”};

//函数包
#include <stdio.h> //gets puts
#include <string.h> //strlen strcat strcpy strcmp strupr strlwr

1. gets //从键盘中接收一个字符串（包括回车，包括空格）。 scanf(“%s”, 不能存入回车，空格)
   char st[10];
   gets(st);

2. puts
   char st[] = “abc”;
   puts(st);

3. strlen//计算字符串长度

4. strcat //连接2个字符串
   strcat(s1, s2); 将串2的值，拼接到串1的后面

5. strcpy //拷贝字符串
   strcpy(s1, s2); //将串2拷贝给串1

6. strcmp //比较2个字符串的大小，按照ASCII 进行比较，如果第一个字符相等，则比较下一个字符
   strcmp(s1, s2); //返回值等于 0 则相等，返回值 >0 则 s1 > s2, 返回值 < 0 则 s1 < s2

7. strupr //字符串小写转大写

8. strlwr //字符串大写转小写

//预处理命令
9. 预处理命令用#开头，文件的任意位置，从书写行向下生效, 编译期间进行加工处理，不是在运行期间
#include <stdio.h>

10. 引入方式
    #include <文件名>
    #include “文件名”
    //2种方式查找文件的方式不同， 第一种可以理解为查找系统的包，去include 文件夹中找指定的包
    //第二种方式是首先在当前工作目录下面找，如果没找到再去 incldue 文件夹中去找
    当编译的时候就将引入文件的内容引入到 #include 这行代码处

11. #define 宏定义

不带参数的
#define pi 3.14
使用的时候直接进行替换
int r = 1, s;
s = pi*r*r; //3.14*1*1

带参数的

#define s(x) x*x
注意，使用的时候直接替换
int a=1, b =2;
s(a+b); // a+b*a+b = 1+2*1+2  => 5

//带参数宏替换， 与函数调用的区别
1.执行时间不同
在编译期间 在运行期间
2.执行方式不同
字符串的替换 需要进行计算
3.占用空间的不同
不开辟空间 为参数开辟空间

//指针
指针变量就存内存地址的
定义指针
int * p; p就是指针名
给指针赋值
int a=1;
int p = &a;
取值
*p
例如： 
int a=1, b=2;
int c;
int *p1, *p2;
p1 = &a;
p2=&b;
c = *p1 + *p2
printf("%d", c);

//
int *p;
double *p;
char *p;

//函数的参数是指针
swap(int *a, int *b){
  int t;
  t = *a;
  *a = *b;
  *b = t;
}
int a=1, b=2;
调用
swap(&a, &*b);
//问题，赋值变量的时候为什么不能直接写a 写的是 *a  678行

*&a  就是a的值
*p++ 等价于 *(p++)
理解：int *p 定义指针， p= 给指针变量赋值，约定，指针完成了指向
*p= 给房间的值赋值

//指向数组的指针
int a[5] = {1,2,3,4};
int *p;
p = b+1;
printf("%d", *p); 2
p = b; // 或 p = &a[0]
printf("%d", *p); 1

p++  等价于 p = p+1 //表示指向到下一个元素 如果p是b 那么就相当于编程了b+1

允许指针变量按关系运算，就是按下标运算
p = b;
if (p > p+2){

}

允许指向同一个数组的指针做减法运算，但不能做加法运算： 按下标运算
p2-p1

//当指针变量只想的是数组，那么还有2中形式取数
int a[5] = {1,2,3,4};
int *p =a;
1.下表法
a[0]  a[1]
p[0]  p[1]

2.指针法
*p *(p+1)
*a *(a+1)

//指针数组
int *p[5];
指针指向二维数组
p = b+1; [5,7,0,0]
*(*p+1) 表示7

p= b;
*(*(p+i)+j)

//字符型指针
char *s;
char *ch = 'a';
s = &ch;
s = "abc";
这个时候 s 指向的是字符串的首个地址值
//指针指向函数
int add(int a, int b){
  int k;
  k = a+b;
  return k;
}
void main(){
  int a =1, b =2, m, m2;
  int (*p)();
  p = add;
  m = add(a, b);
  m2 = (*p)(a, b);
  printf("%d,%d", m, m2);
}
定义函数指针的时候，类型要和函数类型一样

//指针书写的写法
int (*p)[4];  //指向数组的指针变量
int *p[4];  //指针数组

//删除算法
从前向后，扫描整个字符串，遇到删除字符不处理，遇到非删除的字符留下，往前放，最后加 '\0'
 

//结构体
构造一种新的数据类型
struct 名 {
  成员1: 数据;
}
多个数据的集合，可以是同类型也可以是不同类型
例如：
struct birth {
  int yaar;
  int month;
  int day;
};
struct 定义结构体关键字
birth 是结构体名
struct birth 结构体的类型，一种新的数据类型

结构体变量的定义
例如： float b;
struct birth a;

定义结构体的时候也可以定义结构变量
struct birth {
  int year;
  int month;
  int day;
}a,b,c;

也可以定义省略结构体
struct {
  int year;
  int month;
  int day;
}a,b,c;

给结构体变量赋值
struct birth a={2023,2,5};

定义后在赋值
struct birth a;
a.year = 1;
a.year; 取值

//在C中不能向ruby一样直接赋值数组
struct student xingda, xionger;
xiongda.id = 3;
xiongda.name= "123"; error //数组不能直接赋值
strcpy(xiongda.name, "123");

xionger = xiongda; //结构体可以这样赋值
结构体占用空间的大小，就是结构体成员大小的总和 sizeof 可以进行判断

//结构体可以进行嵌套
2中方法
struct student {
  int id;
  char name[30];
  struct birth bbtt; //结构体变量做结构体成员
}

struct student {
  int id;
  char name[30];
  struct birth {
    int year;
    int month;
    int day;
  } bbtt;
}

struct student a;
a.birth.year;

//结构体指针
struct student *p;
p = &xiongda;
strcpy(p->name, "abc");
(*p).id = 3;  注意括号不能省略

//结构体数组 
struct stu s[2]= {{1,2,3}, {1,2,3}};
struct stu *p;
p = s;
printf("%d%d%d", s[0].id, p->x, (*p).id);
printf("%d", ++(p->x));

//结构体作为函数的形参
//结构体做为参数的时候也是拷贝值


//共同体union
定义
union xxx {
  double a;
  int b;
  int c;
};

union xxx e,f,g;
说明：共用体变量下的所有成员共用一个空间，成员中占据最大的那一个，也就是double
每个时刻只能有一个成员

赋值
1.初始化赋值，只能给一个成员赋值
2.引用成员的时候 ，每次都是最后使用的成员起作用

//枚举enum
例如：
enum kk {sun, mon}
2 枚举常量值
隐式值
默认从0开始
显示值，给啥值就是啥值

//typedef 关键字
给数据类型起别名
例如：
int 类型的别名 ii
typedef int ii;

//文件指的是磁盘上的文件
C语言把文件中的内容看作一个字符一个字符组成的顺序序列
文件的分类

//读写数据
顺序读取 文本文件
随机读取 二进制文件

打开文件 //建立通道
读写过程 //利用通道读写数据
关闭文件 //关闭通道
C语言本身没有输入输出功能，借用函数来实现的， 函数在 stdio.h

1. 打开文件
   fopen() //打开磁盘中指定的文件
   fopen(“文件名”, “文件的使用方式”)
   函数的返回值类型是个指针

例如
FILE *fp;
fp = fopen(“1.txt”, “w”); //打开文件，以读写的方式
文件的使用种类
“r” 只读
“w” 只写
“a” 追加写
“r+” 读写
“w+” 读写
“a+” 读，追加写

+ 说明既可以读，也可以写
1. w 使用时，刚开始的时候文件会被清空，如果文件不存在，会创建新的
2. r 使用时，文件不被清空，但是会被覆盖，理解为指针放到了开头，没有文件会报错，不会创建新的
3. a 使用时 进行追加，文件不存在会创建

2进制文件，同上但是多个了 b字母
“rb” 只读
“wb” 只写
“ab” 追加写
“rb+” 读写
“wb+” 读写
“ab+” 读，追加写

//如果文件打开成功，指针就指在文件上，如果打开失败，fp指针为 NULL 空指针
//fp指针不负责对文件内容的操作，只负责文件的相关信息， 文件里面的内容是通过 读写位置指针 负责操作的

2. 关闭文件
   切断与文件之间的通道，释放缓存，否则会造成文件数据的丢失
   fclose(文件的指针);
   例如：
   FILE *fp;
   fp = fopen(“1.txt”, “w”);
   fclose(fp);

3. 读写函数
   单个字符的读写函数 键盘单个字符
   fgetc() fputc() getchar() putchar()
   字符串 键盘字符串
   fgets() fputs() gets() puts()
   有格式的输入和输出 键盘有格式的输入输出
   fscanf() fprintf() scanf() printf()
   数据块的读写（二进制的）
   fread() fwrite()

4. fgetc(文件指针)

5. fputc(字符，文件指针)

6. ch = getchar()

7. putchar(‘a’)

8. fgets(地址，长度，文件指针)
   char st[100];
   fgets(st, 100, fp);

9. gets(st);

10. fputs(字符串， 文件指针)
    char st[] = “abc”;
    fputs(st, fp);

11. puts()
    puts(st);

12. fscanf(文件指针，地址格式，地址列表) //输入函数
    从文件中将指定格式的数据读到内存中 （读）
    int a;
    float b;
    fscanf(fp, “%d%f”, &a, &b);

13. fprintf() //输出函数 （写）
    fprintf(文件指针，地址格式，输出列表)
    int a=2;
    float b = 2.5;
    fprintf(fp, “%d%f”, a, b);

14. fread() 读函数
    23 fwrite() 写函数
    例如用法；
    int a[5] = {1,2,3,4,7};
    int b[5];
    //写入文件
    fwrite(a, sizeof(int), 5, fp); //将a中的数据放入文件中， 放入大小为 5个int
    fread(b, sizeof(int), 5, fp); //从文件中读取5个int 大小的数据，放到b中

//文件控制函数
feof()
功能： 判断文件是否读到文件尾，如果读到文件尾部，返回1 ， 如果没有读到 返回 0
feof(fp);

例如： 将A文件的内容拷贝到B文件中
void main(){
FILE *finp, *foutp;
char st;
finp = fopen(“A.txt”, “r”); //只读的方式打开文件
foutp = fopen(“B.txt”, “w”); //使用只写的方式打开文件B
while(!feof(finp)){
st = fgetc(finp);
fputc(st,foutp);
}
fclose(finp); //关闭A文件
fclose(foutp); //关闭B文件
}

//理解文件中的指针
文件指针： 文件的信息
读写位置指针： 文件内容

feof()
fseek() // 读写位置的偏移函数
rewind()

fseek(文件指针，偏移量，起始位置标记)
例如： fseek(fp, 10L, 1);
0 / SEEK_SET //文件的开始位置
1 / SEEK_CUR // 文件的指针的当前位置
2 / SEEK_END //文件的结束位置

rewind() //文件读写位置指针的回绕函数，就是回到开头
rewind(文件指针); //实现文件从头重新开始读写