1.基础知识
1.什么是C语言？
C语言是一种计算机语言
C语言的执行步骤：源程序编辑--》源程序编译（.obj文件）--》连接生成执行程序（.exe）--》执行程序
三种基本结构：顺序---选择---循环
按使用方式分类：交互式程序设计语言
非交互式程序设计语言
优点：易学易用、移植性好
缺点：不支持对硬件的直接操作、代码需要翻译指令序列后才能执行
解释方式：逐句扫描，逐句执行，直接获得结果。
一个C语言程序通常存放在一个源程序中，也可以存放在多个源程序文件中。
一个函数必须完整地包含在一个文件中，不允许跨文件存放。
C编译程序总是以源程序文件为单位编译。
2.计算机语言是什么？
人和计算机交互的语言/C/C++/JAVA/PYTHON
3.语言的发展
二进制语言--》汇编语言--》B语言--》C语言、C++等高级语言
4.进制
二进制 0 1
10进制 0 1 2 3 4 5 6 7 8 9
8进制 0 1 2 3 4 5 6 7
4.字节
bit -比特位 1个比特位存放一个二进制位
byte 1个字节等于8个比特位
kb 1024 byte
5.标识符
1.标记变量、常量、函数等字符序列
2.只能由字母、数字或者下划线组成，且第一个字母必须是字母或下划线
3.C语言的关键字不能作变量名
4.大小写敏感
6.变量
程序运行时，值可以改变的量
变量被声明类型后，会为其分配相应类型的存储单元。
ps：初始化是在程序执行时，对相应的变量赋值，并非编译阶段
const int a=10；常变量无法改变。
7.整型数据
1.十六进制
0x或0X开头，后跟0-9，a-f,A-F,如0x123，0xff
逢16进1
如果需要打印0x，printf参数需要%#x
2.八进制
0开头，后跟0-7
整型常量后加L表示长整型
整型常量后加U表示无符号整型
如果需要打印0x，printf参数需要%#o
实型常量
1.十进制小数形式：0.0 1.5 .......
2.指数形式 XX E后跟整数，可以带符号（前后都不可以省略
整型提升
整数溢出
8.常量
程序运行时值不能改变的量（常数）
1.直接常量-----整型、实型、字符、字符串
2.标识符常量----#define 标识符 类型
1.整型常量（以补码存储在内存中）
整数在内存中存的都是补码，而打印出来的是原码
正整数原码，反码，补码相同
****整型常量后跟L表示长整型数
****整型常量后跟U表示无符号整数
负数——溢出——看首位溢出求补码
十进制：非0数字开头，但包含0
八进制：数字0开头
十六进制：0x开头
二进制：0101
2.实型常量
只有十进制-----表示方法：小数、指数（E后面必须为整数，E之前必须有数字）
3.字符型常量
4.字符串常量
默认最后加上'\0',字符串结束标志
5.符号常量
#define 符号常量名 数值------#define PI 3.14 ------无法再改变（即不能再被赋值）
2.格式
#include <stdio.h> //包含一个stdio.h的文件 std-标准 i-input o-output
int main()//主函数-程序的入口，main函数有且只有一个
{//函数体
int s,a=8,b=12;
s=a*b;
printf("%d",s);
return 0;
}
/*int main() //main之前的int表示main函数调用返回一个整型值
{
return 0;
}*/
注释
； 语句终止符
/* */ 多行注释
// 单行注释
TIPS:
（1）一个C语言程序必须有且仅有一个名为main的函数；
（2）一个C语言源程序通常存放在一个源程序文件中（单文件程序），也可以分别存放在多个源程序文件中（多文件程序）；
（3）程序中所有函数（包括main函数）在源程序文件中安排的位置和顺序是任意的；
（4）一个函数必须完整地包含在一个文件中，不允许跨文件存放；
（5）不同的C编译系统对源程序文件的扩展名要求不同，如此处的源程序文件必须以“.c”作为后缀；
（6）一个C源程序文件是C源程序的一个程序模块，C编译程序总是以源程序文件为单位编译。
3.数据类型
1.主要的数据类型
分为基本数据类型，构造数据类型，指针类型，空类型四大类
3个比特位能存放2^3种二进制，往下推算一个具体的范围
char 字符类型
char ch='A'; 单字符是用单引号’ ‘； %c 打印字符格式的数据 0-2^8-1
short 短整型
short a=10； %d 打印短整型 0-2^16-1
int 整型
int age=20; %d 打印整型十进制数据 0-2^32-1
long 长整型
long a=10；%d 打印长整型 0-2^32-1
long long
更长的整型 0-2^64-1
_bool 类型
表示true 或者false
_complex和_imaginary
表示复数和虚数
float 浮点型
float a=1.22 ;%f 打印浮点型格式的数据 0-2^32-1 有效位数为7位,小数点后6位
存储方式：计算机将浮点数分成小数部分和指数部分进行表示，分开存储这两个部分
浮点数通常只是实际值的近似值，例如7.0可能被存储为6.999999
double 双精度浮点型
double d=3.14； %lf 打印双精度浮点型 0-2^64-1 有效位数为16位,小数点后15位
%x 打印十六进制 %p以地址的形式打印
2.数据类型的区分
1.sizeof（） 计算向内存申请的空间
#include <stdio.h>
int main()
{
short age=20;//向内存申请2个字节16个bit，用来存放20；
printf("%d\n",sizeof(char));//1
printf("%d\n",sizeof(int));//4
printf("%d\n",sizeof(long));//4
printf("%d\n",sizeof(short));//2
printf("%d\n",sizeof(long long));//8
printf("%d\n",sizeof(float));//4
printf("%d\n",sizeof(double));//8
return 0;
}
3.数据存储
1.内置类型
char float double short int long
类型的意义：
1.使用这个类型开辟内存空间的大小
2.有符号数
正数的原码、反码、补码都相同（整数在内存中存储的是二进制补码）
3.无符号数
原码、反码、补码都相同
2.自定义类型
3.大端和小端存储模式
3.变量的分类
变量的存储方式可以分为静态存储和动态存储。
静态存储：变量定义时分配存储单元并保持不变，直到程序结束。//全局变量
动态存储：程序执行时才会分配存储单元，使用即释放。//形参
变量的存储类型:
auto/register\static\extern
局部变量自动分为auto变量，自动变量在使用时应该先赋初值，否则会不确定的垃圾值。
c语言规定，变量必须定义在当前代码块的最前面
#include <stdio.h>
int num2=20;//全局变量,定义在代码块之外的变量
int main()
{
int num1=10;//局部变量，定义在代码块中的变量
//当全局变量和局部变量的名字相同时，局部变量优先
//全局变量和局部变量不用使用同一个值
return 0;
}//局部变量不能够被全局变量使用。
4.变量的作用域和生命周期
1.作用域
局部变量的作用域：局部变量的代码块中
全局变量的作用域：全局变量作用在整个工程中定义，可以任意，只需要声明
语法：extern（声明外部符号） +变量类型 + 变量名；
//aaa.c文件
int global=1;
//bbb.c文件
#include <stdio.h>
int main()
{
//声明变量
extern int global;//声明外部的global变量，可以在函数体外，作用的区域不同。
extern int ADD(int,int);//声明函数
printf("%d\n",global);
return 0;
}
2.生命周期
局部变量的生命周期：
进入作用域生命周期开始，出作用域生命周期结束
#include <stdio.h>
int main()
{
{
int a=10;
printf("%d",a);//可用
}
printf("%d",a);//不可用
return 0;
}
2.全局变量的生命周期是整个程序的生命周期。
4.常量的分类
1.字面常量
直观写出的值
5;//字面常量
2.const修饰的常量
#include <stdio.h>
int main()
{
const int num=4;
//const 常属性，修饰常变量，导致被锁定不能更改
printf("%d",num);
num=8;
printf("%d",num);
return 0;
}
使用const是常属性，但是仍然还是变量。
3.#define定义的标识符常量
#include <stdio.h>
#define MAX 10//#define 常量名 常量值
int main()
{
int arr[MAX]={0};
printf("%d",MAX);
return 0;
}
4.枚举常量
枚举：一 一列举的值
枚举关键字：enum
1.枚举值是常量不是变量，不能再赋值
2.默认从0开始
3.只能把枚举值赋给枚举变量enmu sex s=MALE;
4.可以在枚举定义的时候赋予初值，未赋予的依顺序执行
#include <stdio.h>
enum Sex
{
MALE,
FEMALE,
SECRET
};//MALE,FEMALE,SECRET-枚举常量
int main()
{
enum Sex s=FEMALE;//语法 enum+类+变量=枚举常量
s=SECRET;
s=5;//枚举类型创建的变量可以更改
SCRET=5;//错误，枚举常量无法更改
printf("%d",MALE);//默认0，不可变
printf("%d",FEMALE);//默认1
printf("%d",SECRET);//默认2
printf("%d",s);//默认2
return 0;
}
5.字符串
通过” “的是字符串,\0 -0,'a'-97,'A'-65--ASCII编码
#include <stdio.h>
int main()
{
char arr[]="abc";//字符串双引号形式默认结尾放\0，\0为字符串的结束标志
char arr1[]={'a','b','c',0};//如果不加0,后面打印随机值
printf("%s",arr);
printf("%s",arr1);
return 0;
}
#include <stdio.h>
#include <string.h>
int main()
{
char arr[]="abc";
char arr1[]={'a','b','c'};
printf("%d",strlen(arr));//3，字符串最后\0，只要碰到\0就会中断
printf("%d",strlen(arr1));//3之后随机值，直到匹配到0
return 0;
}
1.gets和puts函数
gets函数输入一句话，包含空格，不包含回车符,遇到回车返回。
puts函数输出字符串，并且自动换行
puts（字符数组或者字符串常量）
#include <stdio.h>
int main()
{
char str[20];
gets(str);
puts(str);
}
2.字符指针
1.字符指针可以指向一个字符数组（输出地址）
2.也可以直接指向一个字符串（输出字符串）
6.转义字符
\ 进行转义
\n 换行符
\t 水平制表符
\v 垂直制表符
\ddd ddd表示1-3个八进制数字 如\130 \32--32作为8进制代表的10进制数字作为ASCII的码值
这边格式化输出都使用%c
\xdd dd表示2个16进制数字 如\X30 为48--
7.选择语句
#include <stdio.h>
int main()
{
int a=4,b=7;
if (a>b)
{
printf("%d\n",a);
}
else
{
printf("%d\n",b);
}
return 0;
}
8.循环语句
1.while循环
#include <stdio.h>
int main()
{
int line =0;
printf("外部\n");
while(line <200)
{
printf("while循环内部%d\n",line);
line++;
}
if(line>=200)
printf("循环外部\n");
return 0;
}
2.do while 循环
3.for循环
9.函数
函数的自变量可以时常量，变量或者表达式。
在函数调用时，实参的类型，个数，顺序要与形参的类型，个数，顺序一致。
函数的return有两种形式
void f()
{
return;//没有返回值的只能使用return；
}
int max(int a，int b)
{
return 3;//有返回类型的必须使用return+参数
}
1.自定义函数
#include <stdio.h>
int ADD(int a,int b)//int 为函数的返回类型
{
int z=x+y；
return z;//z为整数
}
int main()
{
int b=0,c=0,s=0;
scanf("%d%d",&b,&c);
s=ADD(b,c);
printf("%d",s);
return 0;
}
2.库函数
10.数组
定义：一组相同类型的数字集合
int arr[10]={1,2,3};//定义存放10个整数数字的数组
char ch[5];
float arr2[5];
printf("%d",arr[3]);//以下标的方式访问元素
1 2 3 4 5 6 7 8 9 10
下标0 1 2 3 4 5 6 7 8 9
#include <stdio.h>
int main()
{
int i=0;//如果数组的数量少于长度，补0
int arr[10]={1,2,3,4,5,6,7,8,9,10};
while (i<10)
{
printf("%d",arr[i]);
i++;
}
return 0;
}
11.操作符
1.算术操作符
+ - * / % ++ -
5/2=2 5%2=1
优先级：-（负号） 》*/% 》+ -
+ - 右结合性 其他左结合性
++ -- 优先级高于所有算术操作符 具有右结合性 只能用整型变量和指针变量
2.移位操作符
<<左移 >>右移 二进制位左移右移 左弃右补原则
#include <stdio.h>
int main()
{
int a=1;
int b=a<<1;
printf("%d",b);
return 0;
}
00000000000000000000000000000001
00000000000000000000000000000010
3.位操作符
（2进制位）
&按位与 （同真为真） |按位或（有真为真） ^按位异或（取是否相等）
#include <stdio.h>
int main()
{
int a=3;//00000011
int b=5;//00000101
int c=a&b; //0001
printf("%d",c);
return 0;
}
4.赋值运算符
= 赋值 （== 判断相等） 可以int a=b=c=5;赋值
+= -= /= >>= <<= *= ^=
a=(b=2)+(c=3);a=2+3=5
赋值运算符具有右结合性，优先级仅高于逗号运算符
ps：将较长的整形数赋值给较短的整型变量，发生截断
如： char c；c=300;c-->44 c=300%256;
ps：不能同时给多个变量赋值！！！
5.单目操作符
! 逻辑反操作 a=1；！a=0 a为真，！a为假
- a； 负号（正号会省略）
sizeof（变量（数据类型））变量类型占空间的大小----单位字节
sizeof（1.5）----为double类型
#include <stdio.h>
int main()
{
int arr[10]={0};
int len=sizeof(arr)/sizeof(arr[1]);//计算数组的元素个数
//数组总大小/数组单个字符的大小
printf("%d",len);
return 0;}
~ 按位取反
对一个数的二进制位取反 int a=0；int b=~a；
b=-1;b是有符号的整型，最高位表示的是符号位
//why?
源码、反码、补码
源码符号位不变，其他按位取反得到反码，反码按位+1得到补码
//11111111111111111111111111111 补码
//11111111111111111111111111110 反码
//10000000000000000000000001 原码
负数在内存中存储的是二进制的补码，打印的是这个数的源码
只要是整数，在内存中存储的都是二进制的补码
强制类型转换
int a=（int）3.14；//从double转换为int
自动类型转换
6.关系操作符
>= != <= == > <
7.逻辑操作符
&& 逻辑与 a&&b 都是真为真，有一个假为假，前面假，后面不执行
|| 逻辑或 a||b 有一个为真即真，都为假才假，前面为真，后面不执行
！ 逻辑非 ！真为假
8.条件操作符
exp1？exp2：exp3 exp1成立输出exp2否则输出exp3
9.逗号表达式
exp1,exp2.exp3
整个表达式的值为exp3，并且从左到右开始计算
10.下标引用操作符
arr【4】；
11.函数调用操作符
int sum=ADD(a,b); 函数调用的（）是函数调用操作符
12.指针运算符
解引用（取内容） *
取地址 &
12.常见关键字
auto 自动 auto int a=10；局部变量/自动变量 默认省略
break case char const continue default do double
else enum extern float for goto if int swith union联合体（共用体） unsigned void while
register（寄存器关键字，计算机存储数据存储在硬盘，内存，高速缓存，寄存器，存储的空间越来越小，但是访问速度越来越快）
语法： register int a=10；把a定义成寄存变量，速度快。(只有整型、和字符型可以声明为寄存器变量）
typedef 类型重定义(取别名）（typedef unsigned int u_int;// 将无符号的整型命名为u_int)
13.static修饰器
static 修饰局部变量，局部变量的生命周期变长，出作用域不再销毁
#include <stdio.h>
void test()
{
static int a=1;//static静态局部变量，使得出作用域不会被销毁
a++;
printf("a=%d\n",a);
} //进入作用域但是被销毁
int main()
{
int i=0;
while(i<5)
{
test();
i++;
}
return 0;
} //输出22222
static修饰全局变量，改变的是全局变量的作用域，让 静态全局变量只能在自己所在的源文件内部使用，出了便不能使用。
static修饰函数， 和修饰全局变量相似，改变的函数的链接属性（正常的函数具有外部链接属性，但只要static修饰了，就变成了源文件的内部属性）
14.#define定义标识符（宏）
#define 定义标识符常量
#define MAX 100 不可以被修改
#define 定义宏 （宏是带参数的）
#include <stdio.h>
int MAX(int a,int b)//函数定义方式
{
if (a>b)
return a;
else
return b;
}
#define MAX(X,Y) (X>Y?X:Y)//宏定义，将MAX(X,Y)的值传给（X>Y?X:Y)
int main() //宏定义可以嵌套 #define MIN(X,Y) MAX(X,Y),不会为形参分配内存
{
int a=10;
int b=20;
int max=MAX(a,b); //函数定义
printf("max=%d",MAX);
max=MAX(a,b);
printf("max=%d",max);
return 0;
}
#undef sum 取消定义 任意位置
15.指针
1.定义
1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间
2.指针的大小固定为4/8字节
3.指针有类型，指针的类型决定了指针的-整数的步长，指针解引用操作时的权限
4.指针的运算
2.如何产生地址
32位 32根地址线 2^32二进制序列 每个内存块是二进制序列的地址 能访问2^32个空间 ，每个空间是一个字节
#include <stdio.h>
int main()
{
int a=10;//4个字节，内存里创建变量取名为 a，有自己的地址，放的值为10
int* p=&a;//p存放a的地址，类型定义int*
创建一个p空间，p中放的是a的地址
//专门存放变量的地址-指针变量
printf("%p\n",&a);
printf("%p\n",p);
*p=20;//解引用操作符，通过p的地址找到a
*p是a，*p=20；就是将a内存空间的值，由10改为20
return 0;
}
#include <stdio.h>
int main()
{
char a='s';
char* p=&a;
*p='n';
printf("%c",*p);
printf("%c",a);
return 0;
}
指针大小（固定），32位，32个比特位，4个字节
指针大小，64位，64个比特位，8个字节
16.结构体
#include <stdio.h>
//#define STU struct stu
STU 法三 使用宏定义定义了结构体
{
};
STU b,c;//
struct Book //创建一个结构体类型
{
char name[20];//C语言
short price;//55
}b1;-----直接定义变量法1
int main()
{//利用结构体类型创建一个该类型的结构体变量,按照顺序
struct Book b1={"name",55}; //法2，定义结构再定义结构变量
struct BOOK* P=&b1;//结构体指针变量的类型
printf("%s\n",(*p).name);//结构体变量.成员
printf("书名：%s",b1.name);//写法一
printf("书名：%s",p->name);//结构体指针->成员
printf("价格：%s",b1.price);
b1.price=20;//需要按照顺序
return 0;
}
数组名本质是一个地址,赋值只能用strcpy（）
strcpy（b1.name，”C++"）;
#include <stdio.h>
#include <string.h>
struct Book //创建一个结构体类型
{
char name[20];//C语言
short price;//55
};
int main()
{//利用结构体类型创建一个该类型的结构体变量,按照顺序
struct Book b1={"Cyuyan",20};
struct Book* p=&b1;
strcpy(b1.name,"dsdsdsd");
printf("%s\n",p->name);
printf("%d\n",(*p).price);
return 0;
}
原理： . : 结构体变量.成员 -> :结构体指针->成员
数组其实取得是地址 无法通过.数组变量赋值。 比如：int name []; 变量.name 是非法的。仅仅赋值如此。
结构数组
和结构体一样。
结构体指针
struct 结构名 *结构体指针变量名；结构变量的首地址赋予指针变量
访问成员--------1.（*结构体指针）.成员名 2.结构体指针->成员名
结构指针赋值不能使用结构名
17.分支与循环
结构化：顺序--选择--循环 注意 else与就近的未匹配的if匹配
优质if风格if （5==a).....
#include <stdio.h>
int main()
{
int age=20;
if(age<18)
printf("未成年");
else if(age>18&&age<30)
printf("青年");
else//可有可无
printf("中年");
return 0;
}
1.分支语句
由；隔开的语句。
1.if语句
//判断一个数是否为奇数
/*
#include <stdio.h>
int main()
{
int i=0;
for(i=0;i<101;i++)
{
i%2==0?printf("%d不是奇数\t",i):printf("%d是奇数\n",i);
}
return 0;
}*/
#include <stdio.h>
int main()
{
int a=1;
while(a<101)
{
if(a%2!=0)
printf("%d为奇数\n",a);
else
printf("%d为偶数\n",a);
a++;
}
return 0;
}
2.switch语句：
遇到break结束，否则一直执行。default是所有的条件都不符合执行。最后一句可加可不加break；switch允许嵌套使用,都没匹配到从defaut开始执行
当scanf函数后面接收的是一个地址的时候，此时不需要加“&”
#include <stdio.h>//switch语句
int main()
{
int day=0;
scanf("%d",&day);
switch(day)//---（必须整型表达式）int/char和枚举
{
case 1: //case后写整型常量表达式
printf("sss");
break;
case 2:
printf("aaa");
default://无顺序可言
printf("输入错误");
}
return 0;
}
2.循环语句
1.while循环
while（表达式）
循环语句；
#include <stdio.h>
int main()
{
int i=0;
while(i<11)
{
printf("%d\n",i);
i++;}
return 0;
}
getchar()
int ch=getchar();从键盘输入一个字符
putchar（）；从键盘输出一个字符==printf()
#include <stdio.h>
int main()
{
int ch=0;
//ctrl+z
//EOF - end of file --》-1
while((ch=getchar())!=EOF)
{
putchar(ch);
}
return 0;
}
ps：scanf获取空格之前的内容
#define _CRT_SECURE_NO_WARNINGS
//输入一个字符，输出一个字符
#include <stdio.h>
int main()
{
//int i=0;
//while((i=getchar())!=EOF)
//{
//putchar(i);
//}
int set = 0,ch=0;
char password[20] = { 0 };
printf("请输入密码：");
scanf("%s", password);//输入密码，并保存在password中，输入缓冲区123456\n，读取123456，\N被下面的getchar读取
//缓冲区还剩余一个\N，读取\n
while ((ch = getchar())!= '\n')
{
;
}
printf("请确认Y/N:");
set = getchar();//Y/N ---输入回车默认
if (set == 'Y')
{
printf("确认成功");
}
else
{
printf("放弃确认");
}
return 0;
}
int main()
{
int ch = 0;
while ((ch = getchar()) != EOF)
{
if (ch<'0' || ch>'9')
continue;
putchar(ch);
}
return 0;
}
2.for循环
for（表达式1；表达式2；表达式3）
循环语句；
ps：不可在for循环体内修改循环变量，防止for循环失去控制
建议for语句的循环控制变量取值采用前闭后开区间的写法
#include <stdio.h>
int main()
{
int i = 0;
for (i = 1; i <= 10; i++)
{
if (i == 5)
break;
printf("%d", i);
}
return 0;
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
for (i = 0; i <11; i++)//前闭后开
{
printf("%d ", arr[i]);
}
return 0;
}
1.关于for的省略
1.for循环的初始化，调整，判断都可以省略
如果for循环的判断条件省略，判断条件就是恒为真
2.不要随便省略
int main()
{
int i = 0, j = 0;
for (; i < 10; i++)
{
for (; j < 10; j++)//j初始值在函数体外部创建，此种方式j=10并没有销毁
printf("hehe\n");
}
return 0;
}
//判断循环次数 循环0次，k=0为假
int main()
{
int i=0,k=0;
for (i=0,k=0;k=0;i++,k++)
k++;
return 0;
}
3.do while语句
循环体至少会循环一次
do{ 循环语句
}while（）；
int main()
{
int i = 0;
do {
printf("%d", i);
i++;
} while (i < 10);
return 0;
}
综合代码实践
//计算1！+2！+....+10！
int AAA(int n)
{
int i = 1, s = 1,sum=0,b=0;
for (i = 1; i < n + 1; i++)// 1 2 3
{
s = 1;
for (b = 1; b < i + 1; b++)// 1 - 1 2 - 123
{
s = b * s;//1
}
sum = sum + s;//1
}
return sum;
}
int main()
{
int n = 0, x = 0;
scanf_s("%d", &n);
x = AAA(n);
printf("%d", x);
return 0;
}
普通找法：复杂度为O（n）
//数组中找到10
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
//在数组中找到10
int i = 0,k=10;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < sz; i++)
{
if (k == arr[i])
{
printf("找到了,下标是%d",i);
break;
}
}
if (i == sz)
{
printf("没有了");
}
return 0;
}
二分查找法：复杂度logn 2
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int left = 0;
int right = sz - 1;
int k = 7;
while (left<=right)
{
int midden = (right + left) / 2;
if (arr[midden] > k)
{
right = midden - 1;
}
else if (arr[midden] < k)
{
left = midden + 1;
}
else
{
printf("找到了,下标是%d",midden);
break;
}
}
if (left>right)
{
printf("找不到");
}
return 0;
}
编写代码，字符从两端向中间汇聚
#include <string.h>
#include <Windows.h>
#include <stdlib.h>
int main()
{
char arr1[] = "welcome to bit!!!!!!!!";
char arr2[] = "######################";
int left = 0;
int right = strlen(arr1) - 1;
while (left<=right)
{
arr2[left] = arr1[left];
arr2[right] = arr1[right];
printf("%s\n", arr2);
Sleep(500);
system("cls");//清空操作 库函数 <stdlib.h>
left++;
right--;
}
printf("%s", arr2);
return 0;
}
编码实现，模拟用户登录场景，并且只能登录三次
#include <string.h>
int main()
{
int i = 0;
char arr[] = { 0 };
for (i = 0; i < 3; i++)
{
printf("请输入密码");
scanf("%s", arr);// strcat(字符数组1,字符数组2或字符串);将2拼接到1后，并添加\0，保证字符数组1足够大
if (strcmp(arr, "123456")==0)//==不能使用等于比较字符串
{//左边大于右边返回正数，左边小于右边，返回负整数。
printf("登录成功\n");
break;
}
else
{
printf("密码错误");
}
}
if (i == 3)
printf("密码均错误");
return 0;
}
//写代码将三个数从大到小输出
#include <stdio.h>
int main()
{
int a=0, b=0, c=0;
scanf("%d%d%d", &a, &b, &c);
if (b > a)
{
int temp = a;
a = b;
b = temp;
}
if (a < c)
{
int temp = a;
a = c;
c = temp;
}
if (b < c)
{
int temp = b;
b = c;
c = temp;
}
printf("%d%d%d\n", a, b, c);
return 0;
}
//写一个代码打印1-100之间所有3的倍数的数字
#include <stdio.h>
int main()
{
int i = 0;
for (i = 1; i < 101; i++)
{
if (i % 3 == 0)
printf("%d\t", i);
}
return 0;
}
//给定两个数，求这两个数的最大公约数,辗转相除法
#include <stdio.h>
int main()
{
int m = 36; int n = 24,r=0;
while (m%n)
{
r = m % n;
m = n;
n = r;
}
printf("%d", n);
return 0;
}
//打印1000-2000之间的闰年,1.能被4整除并且不能被100整除2.能被400整除
#include <stdio.h>
int main()
{
int i = 0; int count = 0;
for (i = 1000; i < 2001; i++)
if ((i % 4 == 0) && (i % 100 != 0))
{
printf("%d\t", i);
count++;
}
else if (i % 400 == 0)
{
printf("%d\t", i);
count++;
}
printf("共%d个闰年", count);
return 0;
}
//打印100到200之间的素数，试除法
#include <stdio.h>
int main()
{
int i = 0;
for (i = 100; i <= 200;i++)
{
int n = 0;
for (n = 2; n <i; n++)
{
if (i%n == 0)
break;
}
if (n == i)
{
printf("%d ", i);
}
}
return 0;
}
#include <stdio.h>
#include <math.h>
int main()
{
//i=a*b a和b至少一个数字小于i的开平方或者i/2
int i = 0;
for (i = 100; i <= 200; i++)
{
int n = 0;
for (n = 2; n <= sqrt(i); n++)
{
if (i%n== 0)
{
break;
}
}
if (n > sqrt(i))
{
printf("%d ", i);
}
}
return 0;
}
//1-100有多少个9
#include <stdio.h>
int main()
{
int i = 0, count = 0;
for (i = 1; i <100; i++)
{
if (i % 10 == 9)
{
count++;
}
if (i / 10 == 9)
count++;
}
printf("%d", count);
}
//计算1/1-1/2+1/3-1/4-1/5+....+1/99-1/100
法一：分开求
#include <stdio.h>
int main()
{
int i = 0;
double a = 0;
double t = 0;
double s = 0;
for (i = 1; i < 101; i += 2)
{
s = 1.0/ i + s;
}
for(i=2;i<101;i+=2)
{
t = 1.0 / i + t;
}
a = s - t;
printf("%lf", a);
return 0;
}
法二：
#include <stdio.h>
int main()
{
int i = 0;
double sum = 0;
int flag = 1;
for (i = 1; i < 101; i++)
{
sum += flag * 1.0 / i;
flag = -flag; //调整+-项
}
printf("%lf", sum);
return 0;
}
//求最大值
#include <stdio.h>
int main()
{
int arr[] = { -1,-2,-3,-4,-5,-6,-18,-8,-9,-10 };
int i = 0; int max = arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
for (i=1;i<=sz;i++)
{
if (arr[i] > max)
max = arr[i];
}
printf("%d", max);
return 0;
}
//输出9*9乘法口诀表
#include <stdio.h>
int main()
{
int i = 0, j = 0,s=0;
for (i = 1; i < 10; i++)
{
for (j = 1; j < i+1; j++)
{
s = i * j;
printf("%d*%d=%d\t",i,j,s);
}
printf("\n");
}
return 0;
}
18.函数
函数可以嵌套调用，但是不能嵌套定义
0.输出函数
1.putchar函数
输出单个字符
putchar（整型表达式/字符常量/字符变量）；
2.getchar函数
输入一个单个字符 getchar（）；
3.scanf函数
输入用 空格 或者tab进行分隔
4.getch函数
（和getchar差不多，只是最后不需要回车，也不回显）
5.getche
和getchar差不多，只是最后不需要回车
#include <stdio.h>
#include<conio.h>
void main()
{
char ch1,ch2;
int a;
ch1=getchar();
ch2=getchar();
scanf("%d",&a);
//假设输入1234，则c1=1，c2=2，a=34
printf("ch1=%c,ch2=%c\n",ch1,ch2);
printf("a=%d\n",a)；
}
6.输出字符数据：
putchar、putc、puts（字符串）
int putchar（int c）；
显示输出字符c 返回值：正常返回字符的代码值，出错返回eof（-1）
注意：该函数带有一个参数c，为显示的ascii符，有一个int的返回值
1.库函数（本身提供的函数）
自定义函数
函数返回类型取决于定义时的类型
库函数：
strlen--string length 字符串长度有关
strcpy-string.h 字符串的拷贝
例如：char arr1[]="bit";
char arr1[]="asdda";
strcpy（arr2，arr1）;
memset修改部分的值
#include <stdio.h>
#include <string.h>
int main()
{
char arr[]="hello world";
memset(arr,'*',5);替换的长度不能比原来的总长度长
//第一个参数需要改的字符串
//第二个参数，代替的字符
//第三个参数，取前多少个
printf("%s",arr);
return 0;
}
strncpy（将字符串的指定数量的复制到字符串1）
#include <stdio.h>
#include <string.h>
int main()
{
char str[20]="111defghij";
strncpy(str,"adcdef",3);
puts(str);
}
2.自定义函数
语法：
ret_type fun_name （para1，*）
{
statement
}
ret_type 返回类型 fun_name 函数名 statement 函数体
//写一个函数，交换a和b的值
int get_max(int x,int y)
{
if(x>y)
return x;
else
return y;
}
int main()
{
int a=10;
int b=20;
int max=get_max(a,b);
printf("max=%d",max);
return 0;
}
void swap(int* a,int* b)//指针变量接收
{
int temp=0;
temp=*a;//temp等于a地址的值
*a=*b;//a地址的值等于b地址的值
*b=temp;//b地址的值等于temp
}
int main()
{
int a=10;
int b=5;
swap(&a,&b);//传地址
printf("%d\t%d",a,b);
return 0;
}
3.函数的参数
实参：真实传递的参数（常量、变量、表达式、函数等，必须有确切的值）
形参：函数名后括号的参数（形式参数，不是真实的参数），当函数调用的时候才会实例化（开辟内存空间），当函数调用完成后，形式参数自动销毁，因此只在函数中有效。形参只能是变量,在被定义的函数中,必须指定形参的类型。
//当实参传给形参的时候，形参是实参的临时拷贝，对形参的修改不会改变实参
4.函数的调用
1.传值调用
形参创建自己的内存空间
2.传址调用
传输内存地址，让函数内部直接操作函数外部的变量
3.代码
//写函数打印100-200的素数
int is_prime(int i)
{
int n=0;
for(n=2;n<100;n++)
{
if(i%n==0)
return 0;
}
return 1;
}
int main()
{
int i=0;
for(i=100;i<=200;i++)
{
if(is_prime(i)==1)
printf("素数：%d",i);
}
return 0;
}
//判断是否是闰年
int is_leap(int a)
{
if((a%4==0&&a%100!=0)||(a%400==0))
return 1;
else
return 0;
}
int main()
{
int year=0;
for(year=1000;year<=2000;year++)
{
if(is_leap(year)==1)
printf("%d是闰年\n",year);
}
return 0;
}
//写一个函数，实现整型二分查找
int binary_search(int arr[],int k,int sz)
{
int left=0;int right=sz-1;
while(left<=right)
{
int mid=(left+right)/2;
if (arr[mid]<k)
{
left=mid+1;
}
else if(arr[mid]>k)
{
right=mid-1;
}
else
{
return mid;
}
}
return -1;
}
int main()
{
int arr[]={1,2,3,4,5,6,7,8,9,10,11};
int sz=sizeof(arr)/sizeof(arr[0]);
int a=0;
int k=7;
int ret=binary_search(arr,k,sz);//数组传参仅仅传数组第一个元素地址,占4字节
if(ret==-1)
{
printf("找不到");
}
else
{
printf("找到了，下标是%d\n",ret);
}
return 0;
}
//写一个函数，每调用一次，num的值增加1
void ADD(int* num)
{
(*num)++;
}
int main()
{
int num=0;
ADD(&num);
printf("%d\n",num);
ADD(&num);
printf("%d\n",num);
ADD(&num);
printf("%d\n",num);
return 0;
}
5.函数的嵌套
printf("%d",printf("%d",printf("%d",43)));
printf返回值是字符的个数
6.函数的声明和定义
int ADD(int);//声明函数，否则报错，函数的声明可以放在主函数外，也可以放在主函数内
int main()
{；
}
int ADD(int a)
{；}
引入自己写的代码模块使用#include "声明的文件 "
声明的文件放在头文件中。定义放在源文件中。
7.函数的递归
程序自身直接或者间接调用自己，把大型复杂的问题层层转化为与原问题相似的规模较小的问题来求解：把大事化小
必要条件：
存在限制条件，当满足这个限制条件时，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。
函数调用都在栈区申请空间：递归无休止调用stackoverflow
//接收一个整型值（无符号），按照顺序打印它的每一位，例如：1234--1 2 3 4
void print(int n)
{
if(n>9)
{
print(n/10);
}
printf("%d ",n%10);
}
int main()
{
unsigned int num=0;
scanf("%d",&num);//递归
print(num);//(1234) (123)4 (12)3 4
return 0;
}
//编写函数不允许创建临时变量，求字符串长度
方法1：
#include <string.h>
int my_strlen(char* str)//str存放的是地址
{
int count=0;
while(*str !='\0')
{
count++;
str++;//地址+1
}
return count;
}
int main()
{
char arr[]="bit";
int a=my_strlen(arr);
printf("%d",a);
return 0;
}
方法2：
#include <string.h>
int my_strlen(char* str)//str存放的是地址
{
if(*str !='\0')
return 1+my_strlen(str+1);
else
return 0;
}
int main()
{
char arr[]="bit";
int a=my_strlen(arr);
printf("%d",a);
return 0;
}
8.迭代与递归
//求n的阶层
法1:
int Facl(int n)
{
int i=0;
int ret=1;
for(i=1;i<=n;i++)
{
ret*=i;
}
return ret;
}
int main()
{
int n=0,ret=0;
scanf("%d",&n);
ret=Facl(n);
printf("%d\n",ret);
return 0;
}
法2：
int Facl(int n)
{
if(n<=1)
return 1;
else
return n*Facl(n-1);
}
int main()
{
int n=0,ret=0;
scanf("%d",&n);
ret=Facl(n);
printf("%d\n",ret);
return 0;
}
//斐波那契数列 1 1 2 3 5 8 13 21 34 55...
int Fib(int n)
{
if(n<=2)
{
return 1;
}
else
{
return Fib(n-1)+Fib(n-2);
}
}
int main()
{
int n=0;
int ret=0;
scanf("%d",&n);
ret=Fib(n);
printf("ret=%d\n",ret);
return 0;
}
19.数组
1.定义
Int arr[常量]={0}；只能是常量
数组是相同类型元素的集合
char arr[]="sdaasd" sizeof字符串长度时，包括‘0’
strlen默认返回的是无符号整数，需要（int）强制转换
当数组的元素个数大于赋值的个数时，剩余默认补0
C语言规定不能一次性引用整个数组，引用时只能逐个元素引用。
#include <string.h>
int main()
{
char arr[]={'a','b','c'};
char arr1[]="abc";
printf("%d\n",sizeof(arr));//3
printf("%d\n",sizeof(arr1));//4 占空间大小包括\0
printf("%d\n",strlen(arr));//11 3后面直到找到\0为止,所以是随机值
printf("%d\n",strlen(arr1));//3 \0之前的
return 0;
}
数组遍历
int main()
{
char arr[]="abcdefg";
int i=0;
for(i=0;i<7;i++)
{
printf("%c ",arr[i]);
}
return 0;
}
2.一维数组在内存中的存储
3.二维数组的存储
默认把一行放完，放到下一行，剩余补0
语法：int arr[3][4]={{1,2,3,4},5} 或者{1,2,3,4,5,6}
横可以省略，列不可以省略
二维数组地址和一维数组一样，按照数据类型连续递增
int main()
{
int arr[3][4]={{1,2,3},{4,5}};
int i=0;
for(i=0;i<3;i++)
{
int j=0;
for(j=0;j<4;j++)
{
printf("%d ",arr[i][j]);
}
printf("\n");
}
return 0;
}
二维数组可以想象成一维数组的行与列划分
int main()
{
int arr[3][4]={{1,2,3},{4,5}};
printf("%d",arr[0][3]);
return 0;
}
4.数组作为函数参数
数组传参，只传首元素地址（除了下面两个）
1.sizeof（数组名）---表示两个数组
2.&数组名-----数组名代表整个数组，取出的是整个数组的地址
//冒泡排序
//法1 法2：有序的情况下
#include <stdio.h>
void bubble_sort(int arr[],int sz)//确定趟数
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
int j = 0;
for (j = 0;j<sz-i-1;j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
int arr[] = { 9,8,7,6,5,4,12,3 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr,sz);
for (i = 0; i < sz; i++)
{
printf("%d ",arr[i]);
}
return 0;
}
20.指针
1.定义
利用地址，值直接指向存在电脑中另一个地方的值，地址能找到所需的变量单元，地址指向该单位。即通过指针能找到以它为地址的内存单元。指针就是变量，用来存放地址的变量（存放在指针中的值都被当成地址处理）
int *p; *表示说明p是一个指针.
指针变量初始化必须类型相符。不可用整型常量赋值。
指针变量不能相加 不能相乘 也不能相除 如果两个指针变量指向的是同一块连续空间中的不同存储单元 则这两个指针变量才可以相减
2.指针和指针类型
指针类型决定了指针进行解引用操作的时候，能访问空间的大小
int* p;*p能够访问4个字节
char* p；*p能访问1个字节
double* p；*p能访问8个字节‘
指针类型决定了指针的步长。int* p；p+1-->4 char* p;p+1---->1(单位 字节）
1.int main()
{
int arr[10] = { 0 };
int* p = arr;//数组名，指的是数组首元素地址
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = 1;
}
//printf("%d", arr);
return 0;
}
2.
int main()
{
const char* p = "sasasfasf";//常量字符串，无法再改变
printf("%c", *p);//*p='w';报错segment
printf("%s", p);//p是首元素的地址，从p的地址处开始打印
return 0;
}
3.野指针
1.局部变量未初始化
指针指向位置是不可知的（随机的、不正确的）
int main()
{
int* p;//局部变量不初始化，默认是随机值；局部的指针变量，被初始化随机值
return 0;
}
2.指针越界访问
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i < 12; i++)
{
p++;//p指向的范围超过了数组arr的范围时，p是野指针
}
return 0;
}
3.指针指向的空间释放
主函数中指针变量指向一个已经被释放的函数内存空间
int* test()
{
int a = 10;
return &a;
}
int main()
{
int* p = test();
*p = 20;//空间已经被释放
return 0;
}
4.如何避免
1.指针初始化
当指针不知道指向哪儿，可以进行int* p=NULL；
表名指向一个空值。
2.小心指针越界
3.指针指向空间释放为空
pa=NULL；（即不再使用这个指针）
指针空间为空便不能访问
4.指针使用之前检查有效性
4.指针-指针
指针-指针（得到的是中间的元素个数）【指向同一个空间】
int main()
{
int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
printf("%d",&arr[9]-&arr[0]);
return 0;
}
int mystrlen(char* str)
{
char* start = str;
char* end = str;
while (*end != '\0')
{
end++;
}
return end - start;
}
int main()
{
char arr[] = "bit";
int len=mystrlen(arr);
printf("%d\n",len);
return 0;
}
5.指针的关系运算
int main()
{
int arr[10] = { 1,2,3,6,5,6,7,8,9,10 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr;
for (i = 0; i < sz; i++)
{
printf("%d",*p);
p++;
}
}
7.指针数组--数组
存放指针的数组
int main()
{
int a = 10;
int b = 20;
int c = 30;
int* pa = &a;
int* pb = &b;
int* pc = &c;
int* arr[3] = { pa,pb,pc };
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d\n", *arr[i]);
}
return 0;
}
8. 指针数组
由下标【】访问数组元素，最终编译为指针，所以p[i] 等价于 *(p+i)
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdef";
char* p1 = "abcdef";
char* p2 = "abcdef";
//if (arr1 == arr2)//数组首元素地址，内存地址不同
if(p1==p2)//指向同一个地址
{
printf("hehe\n");
}
else
{
printf("haha\n");
}
return 0;
}
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 6,7,8,9,10 };
int arr3[] = { 11,12,1,3,4 };
int* p[] = { arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ",*(p[i]+j));
}
printf("\n");
}
return 0;
}
9.数组指针
1.定义
数组指针是指针。
int* p=NULL;整型指针--指向整型的指针（存放整形的地址）
数组指针--指向数组的指针（存放数组的地址）
arr -----首元素地址
&arr[0]----首元素地址
&arr---数组的地址
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*p)[10] = &arr;//p为数组指针，【10】指向10个元素，每个元素int类型
char* arr[5];
char*(*pa)[5]=&arr;
return 0;
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*p)[10] = &arr;//p为数组指针，【10】指向10个元素，每个元素int类型
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d\n", (*p)[i]);
}
return 0;
}
2.二维数组遍历
void print(int (*p)[5],int x,int y)
{
int i = 0;
for (i = 0; i < x; i++)
{
int j = 0;
for (j = 0; j < y; j++)
{
printf("%d ", *(*(p + i)+j));
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
print(arr,3,5);
return 0;
}
10.数组参数和指针参数
11.函数指针
&函数名 函数名 ----- 都是取函数的地址
int (*pa)(int ,int)=Add;
//函数指针--是指向函数的指针---存放函数的指针
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10, b = 20;
int arr[10] = { 0 };
//int(*p)[10] = &arr;
int(*pa)(int, int) = Add;
printf("%d\n",(*pa)(2,3));//间接寻址调用
return 0;
}
void Print(char* str)
{
printf("%s\n",str);
}
int main()
{
void (*p)(char*) =Print; //char* 指向的参数类型
(*p)("hello world");
return 0;
}
定义返回值为指针的函数
int *func（）
21.结构体
1.定义
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
结构体类型不占用实际空间
2.语法
结构的声明
// 描述一个学生的数据，名字，年龄，电话，性别
struct stu //struct结构体关键字 stu结构体标签 //定义结构体类型
{
char name[20];
short age;
char tele[12];
char sex[5];
}s1,s2,s3//;//一个全局的结构体变量s1
//}s1={"zhangsan",20,"15613","dada"}
int main()
{
struct stu s;//创建结构体局部变量
}
typedef struct stu //struct结构体关键字 stu结构体标签 //定义结构体类型
{
char name[20];
short age;
char tele[12];
char sex[5];
}stu;//typedef给结构体类型取别名stu
int main()
{
stu s={"zhangsan",20,"12564564848,"男"};//创建结构体局部变量并初始化值
stu s2={"lisi",20,"12564564848,"男"}
return 0;
}
3.结构成员的类型
结构的成员可以是普通变量、数组、指针甚至是其他结构体
4.结构体变量的定义和初始化
struct s
{
int a;
char c;
char arr[20];
double d;
};
struct t
{
char ch[10];
struct s v;
char* pc;
};
int main()
{
char arr[] = "hello,world";
struct t f = { "hello",{10,'d',"yes",3.154},arr };
printf("%s\n", f.ch);
printf("%d\n", f.v.a);
printf("%c\n", f.v.c);
printf("%s\n", f.v.arr);
printf("%lf\n", f.v.d);
printf("%s\n", f.pc);
return 0;
}
5.结构体传参
typedef struct stu
{
char name[20];
short age;
char tele[12];
char sex[5];
}Stu;
void Print(Stu temp)
{
printf("%s\t", temp.name);
printf("%d\t", temp.age);
printf("%s\t", temp.tele);
printf("%s\n", temp.sex);
}
void Print1(Stu* temp)
{
printf("%s\t", temp->name);//指针结构体传参，必须使用->
printf("%d\t", temp->age);
printf("%s\t", temp->tele);
printf("%s\n", temp->sex);
}
int main()
{
Stu s = { "李四",20,"15371911176","男" };
Print(s);
Print1(&s);
return 0;
}
6.结构体内存对齐
规则：放在偏移量为0的
22.文件
文本文件（以ascii形式存储）/二进制文件
如果有整数10000 存入磁盘 ：二进制4字节 文本：5字节
1.定义
程序文件、数据文件
.c .obj .h .exe
文件是以ascii码或者其他文字语言的交换编码存储的文件。
文件操作的基本步骤
打开文件，获取句柄--》对文件进行操作--》通过句柄关闭文件
处理文件，必须创建文件句柄指针变量并打开文件，输入函数读取数据，输出函数写入数据。操作结束，关闭文件。（不关闭可能会丢失数据）
文件缓冲区
系统为当前的写入或者读取创建文件缓冲区，从内存向磁盘输出数据先送到输出缓冲区，缓冲区满了才送到磁盘中，同理放到输入缓冲区。
2.语法：
FILE*指针名；
文件句柄指针=fopen(文件名字符串，文件打开方式)；
fclose（文件句柄指针）；
3.文本文件的操作
int main()
{
int a;
FILE*fp = fopen("E:\\\#C\\C\\c\#\\523test\\523test\\523test.c", "r");
while (!feof(fp))
{
a = fgetc(fp); //返回整数值，每读一个，指针自动往后移动一位
if (!feof(fp))
putchar(a);
}
fclose(fp); //fclose函数返回值为0，非0表示错误
fp==NULL;
return 0;
}
fgets(保存文本的数组，保存在数组的最大字符数，文件的句柄指针)读取文件字符
fputc（字符，文件指针） 写入一个字符
636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
