C语言基本知识要点：

1. 目录

一．基本数据类型

1. 数据类型划分

2. 基本数据类型的基本知识（32位系统）

（1） 整型：short 2字节，int 4个字节，long 4个字节

（2） 字符型：char 2个字节(一一对应ASCII码)

（3）浮点型：

3.进制转换

（1）八进制转二进制

八进制数据的1位对应二进制数据的3位

（2）十六进制转二进制

4. 数据在内存中的存储方式

（1）正数的源码 反码 补码一样

（2）负数的源码 反码 补码

二. 运算符

1．赋值运算符（=）（单目运算符）

2. 算术运算符

3. 关系运算符

4. 逻辑运算符

5. 位运算

6. 复合运算符  （双目运算符）

7. 自增自减

8. 条件表达式（三目运算符）

9. sizeof运算符

三. 标准输入和标准输出函数

1．标准输入（scanf）

2. 标准输出（printf）

四. 流程控制语句

1. 控制语句类型

2. 判断结构

（1）if…else…

（2）switch…case…

3. 循环结构

（1）for语句

（2）while语句

（3）do…while…

（4）Return（结束语句）

（5）goto

（6）break

（7）continue

五. 数组

1 . 一维数组

（1） 定义

（2）数组的初始化

2. 二维数组

3.字符数组

（1）字符串操作函数

六. 指针

1. 指针的定义

2. 定义格式：

3. 指针的赋值

4. 取地址和取内容

5. 指针运算

6. 指针和数组

7. 指针和函数与数组

8. 指针和字符串

9. 修饰类关键字  const

七. 函数

1. 函数的特点

2. 函数的定义

3. 函数的声明

4. 函数的调用

5. 形参和实参

6. 数组传参（传首地址/数组名）

7. 全局变量和局部变量

（1）局部变量

（2）定义在函数外部

8. extern和static

（1）静态的static

（2）extern：外部的

9. 缓冲区

八. 结构体

1. 结构体的使用

一．基本数据类型

1. 数据类型划分

（1）基本数据类型：整形（int , short,long） 浮点型(float, doubt) 字符型(char)

（2）构造数据类型：数组，指针，结构体，枚举，共用体

2. 基本数据类型的基本知识（32位系统）

（1） 整型：short 2字节，int 4个字节，long 4个字节

类型的含义：用于存放整数，

有符号（int）-2^31 ~+2^31 -1

有符号（unsigned int）0~2^32-1  (4294967295)

格式控制符:%d  %o  %x  %#x   %u  %ld  %lu

（2） 字符型：char 2个字节(一一对应ASCII码)

类型的含义：存放字符，数字

有符号：(char)   -128~127

无符号：（unsigned char）0~ 255

格式控制符:    %c   %d

（3）浮点型：

float 4个字节  单精度 保留小数点后6位

doubt 8个字节  双精度 保留小数点后12位

类型的含义：存放小数

格式控制符:     %f     %lf

3.进制转换

（1）八进制转二进制

八进制数据的1位对应二进制数据的3位

如：44  对应二进制 100 100 二进制从低位起每三位对应一个八进制数

（2）十六进制转二进制

十六进制数据的1位对应二进制数据的4位

如： 87 对应二进制为 1111 0111 二进制从低位起每四位对应一个十六进制数

4. 数据在内存中的存储方式

（1）正数的源码 反码 补码一样

源码：1111 0111

反码：1111 0111

补码：1111 0111

（2）负数的源码 反码 补码

源码： 1 011 0111  

反码： 1 100 1000   负数的最高位为符号位固定取1，其他为根据源码取反。

补码：  1 100 1001    符号位不变，反码+1

注意：补码转源码也可以取反加1（取反后得到的不是反码）

二. 运算符

1．赋值运算符（=）（单目运算符）

（=） ： 将右边的数值赋值给左边

注意事项：左值必须是变量

2. 算术运算符

+  -   *   /    %（基本上与数学上一样，%有不同）

（%）:  % 取余/求余  取余数只能使用整数进行求余运算

除法运算结果的精度和除号两端精度较高的数据保持一致。

3. 关系运算符

>  <  ==  !=  >=  <= （他们的运算结果要么为0，要么为1）

（==）：if语句中常用符，表示两个数是否相等

运算结果是：真假 –》  1  0

4. 逻辑运算符

&& （逻辑与） || （逻辑或） ！（逻辑非）（逻辑运算结果也是只有真假  1   0 ）

&& ：表达式1 && 表达式2全真才为真，有假就是假，在实际使用中，如果表达式1不成立，表达式2不再运行

|| ：  表达式1 || 表达式2有真就是真，全假才为假，在实际使用中，如果表达式1成立，表达式2不再运行

!：   表达式  真变假   假变真

5. 位运算

 & （按位与）  | （按位或）  ~ （按位取反）  ^ （异或相同为0）

<<（按位左移）  >> （按位右移）

位运算：所有的运算都要按照二进制的形式进行

6. 复合运算符  （双目运算符）

+=  -=  *=  /=   %=  &=  |=  ~=  ^=  <<=  >>=

运算符的优先级问题：复合运算符的优先级和赋值运算符一样了，都变低了。

7. 自增自减

++   --

++：自增   增加1     --：自减  减少1

a++;//a的值增加1     ++a;// a的值增加1

a--;// a的值减少1      --a;// a的值减少1

当不涉及第三方变量赋值的时候，++在前在后是一样的，运算结果都是数值增加1

当涉及第三方变量赋值的时候，++在前在后有区别

8. 条件表达式（三目运算符）

？:

(表达式1)?(表达式2):(表达式3)

判断表达式1的结果，如果为真，那么整个表达式的结果是表达式2的结果，如果为假，那么整个表达式的结果是表达式3的结果。

9. sizeof运算符

sizeof  运算符

作用：求任意对象的大小

任意对象：数据类型  变量

大小：实际占用内存空间的大小

三. 标准输入和标准输出函数

1．标准输入（scanf）

scanf:从键盘读取数据到程序

scanf(“格式控制符1…”,变量1地址，变量2地址。。。);

格式控制符：

%d  读取整数

%c  读取字符

%s  读取字符串

%f  读取浮点数

scanf的双引号里边，写的内容只要格式控制符，不要出现其余内容。

注意：scanf括号里边最好不要写多个变量地址好格式控制符，一到两个就行，双引号里边，写的内容只要格式控制符。

2. 标准输出（printf）

printf函数从程序输出数据到屏幕（终端）原样输出

printf(“要输出的内容”);

printf(“hello world\n”);

格式化输出—》输出变量将变量按照固定的格式转化为字符串，并且打印在屏幕上。

printf(“格式控制符1…”,输出变量1，输出变量2…);

注意事项：格式控制符的数量和输出变量的数量要求一一对应。

格式控制符：

%d：以十进制形式输出数据

%c：输出字符

%s：输出字符串

%o：八进制形式输出

%x：十六进制形式输出

%#x：十六进制形式输出，前边添加0x

%f：输出浮点型数据  单精度  float

%lf：输出浮点型     双精度  double

%u：无符号类型

%p：输出地址

四. 流程控制语句

1. 控制语句类型

     顺序结构  ， 判断结构  ，循环结构

2. 判断结构

（1）if…else…

if(条件1)

{

   语句1；

else

{

语句2;

}

（2）switch…case…

switch(变量)

{

case 常量1:语句1;break;

case 常量2:语句2;break;

…..

case 常量n:语句n;break;

default:语句n+1;break;

}

3. 循环结构

一件事情重复多次运行

起始条件：决定了循环什么时间开始

循环条件：决定了循环什么时间结束

条件修正：决定了循环执行多少次

循环体：决定了循环做什么事情

（1）for语句

从起始条件开始，判断循环条件，条件满足，就执行循环体，执行条件修正，再次判断循环条件，条件满足，执行循环体，不满足，就结束。

for(始条件;循环条件;条件修正)

{

循环体;

}

（2）while语句

起始条件;

while(循环条件)

{

循环体;

条件修正;

}

for循环和while循环无差别的，可以使用for循环实现，也可以使用while循环实现。

（3）do…while…

起始条件;

do

{

循环体;

条件修正;

}while(循环条件);

while和do…while的区别

while循环是先判断循环条件，再执行循环体，如果循环条件不满足，直接结束。

（4）Return（结束语句）

无论程序在做什么，遇到return，立刻结束。返回值给调用者

（5）goto

跳转到程序的任意位置去执行

使用方法：goto  标识;  

跳转到标识的位置去执行

标识的定义方法：

基本原则还是符合C语言命名原则，在命名后边加上冒号，就变成了一个标识。

（6）break

跳出switch语句

switch(变量)

{

case 常量1:语句1；break;

….

default：语句n；break;

}

跳出循环

遇到break，循环结束

（7）continue

继续

结束本次循环，开始下一次循环

五. 数组

1 . 一维数组

一维数组：存放大量相同类型的数据一行数据

数组开辟的空间连续 数组名就是数组首地址

（1） 定义

格式：数据类型  数组名[数组长度];

数据类型：代表数组可以存放的类型

数组名：变量名  符合C语言命名规则即可

[]：不可省略，代表定义的是数组

数组长度：决定了数组可以存放多少内容

列如 int arr[10]

数据类型 ： int []

存放数据类型  int

数组的大小 ： 10*4字节（int []）

数组元素大小： 4 字节 (int )

（2）数组的初始化

（1） 定义，不初始化

int num[5];

数组里边默认是垃圾值。

（2） 定义，全部初始化

int num[5] = {1,2,3,4,5};

赋什么值，就是什么值。

1 2 3 4 5

（3） 定义，部分初始化

int num[5] = {1,2,3};

赋值部分，给的是什么就是什么，未赋值部分，不再是垃圾值，变成0.

数组整体清0：

int num[5] = {0};

（4） 定义，省略数组长度

int num[] = {1,2,3,4};

当省略数组长度的时候，后边必须赋值，此时数组的实际长度由赋值的个数决定。

2. 二维数组

二维数组：存放大量相同类型的数据几行几列的形式

数据类型   数组名[行长度][列长度];

数据类型：数组里边可以存放的数据类型

数组名：变量名

[]：不可省略，代表定义的是数组

行长度：整个数组有几行

列长度：整个数据有几列—》一行有几个

float num[3][5]:代表定义了一个二维数组，数组名是num，里边可以存放3*5个float类型的数据，占用3*5*4字节的空间。

3.字符数组

    存放内容：数组存放字符和字符串

（1）字符串操作函数

        getc():  从键盘读取一个字符，强转成int类型返回。现阶段，我们在使用的时候，键盘传参程序，该函数的功能就变成了从键盘读取一个字符到程序。

putc():将数据c强转成unsigned char类型，写入stream文件。现阶段，我们使用的时候，stream传参stdout，函数就变成了将数据c强转成unsigned char类型，显示在屏幕上。

gets():从键盘读取字符字符串，强转成int类型返回。现阶段，我们在使用的时候，键盘传参程序，该函数的功能就变成了从键盘读取字符串到程序。

         fget():从stream读取数据，存放在s指向的buf里边，s的大小是size字节。现阶段我们使用的时候，stream传参stdin

puts():输出字符串s和换行到屏幕

strcpy():字符串复制将src字符串复制到dest字符串里边

strlen(): 求字符串长度，不包含结尾的’\0’

strstr():字符串检索从字符串haystack检索needle第一次出现的位置

strcat():字符串拼接将src字符串拼接到dest字符串结尾覆盖dest结尾的’\0’，添加新的’\0’在完整的字符串结尾

strcmp():字符串比较将字符串s1和s2逐个字符进行比较，比较ASCII码值，遇到不一样的字符或者’\0’才会停止。

S1>S2：返回值大于0

S2==S2：返回值等于0

S1<S2：返回值小于0

六. 指针

指针：存放地址

1. 指针的定义

指针是构造数据类型

C语言的数据类型：

基本数据类型：字符   整型   浮点型

构造数据类型：数组  指针  结构体 共用体  枚举

2. 定义格式：

基本数据类型  *变量名;

基本数据类型：代表指针指向空间的大小

*：必不可少，代表定义的是指针

变量名：符合C语言命名规则即可

指针里边存放的是地址

每一个空间都会有一个唯一的地

3. 指针的赋值

指针是存放地址的

char ch;//定义一个字符变量，存放字符

char *p;//定义一个指针变量，存放地址

ch = ‘A’;

p = &ch;//给指针变量赋值

指针初始化时一定要赋值 不知道赋什么一律赋NULL 就是0

没有赋值的指针为野指针，赋NULL的称为空指针

4. 取地址和取内容  

&  *

&：在指针应用里边，叫做取地址

使用的时候，后边跟着一个变量，运算结果是获取变量的地址。

*：在指针应用里边，有两个作用

（1）在指针定义的时候，代表定义的是一个指针

（2）在指针使用的时候，叫做取内容

在使用的时候，后边跟的是地址，运算结果是获取地址里边的内容。

数据类型的学习方法：

指针：构造数据类型

类型的表示：基本数据类型+*

类型的大小：64位：8字节

32位：4字节

类型的含义：存放地址

5. 指针运算

指针固定大小 8字节

指针加1，指针里边存放的内容增加指针指向空间的大小

指针的定义：

数据类型  * 变量名;

数据类型：指针指向空间的类型

使用指针定义的变量被称作指针变量—》指针变量的类型是：数据类型  *

指向的空间的类型：数据类型

6. 指针和数组

指针数组：是数组，数组里边存放的是指针

数组的定义：数据类型  数组名[]；

数据类型：数组里边可以存放的类型

char str[10];  字符数组

int num[20]；整型数组

float f[12]；浮点型数组

要存放大量的地址：

地址  addr[10];

指针式存放地址的---》指针

指针  addr[10];--》指针数组

指针的定义：数据类型  *变量名;

char *  char ********

int *   int **

float *  float*****

指针数组定义：数据类型 *  addr[10];

存放地址（指针）的数组  —》 指针数组

int *addr1[10] = {&a,&b,&c,&d,&e};//指针数组

7. 指针和函数与数组

指针函数：是函数，函数的返回值是指针

函数指针：是指针，指向函数

指针的定义：数据类型  *变量名;

函数的定义：函数返回值类型  函数名(形参列表)

函数指针的定义，是从函数原型出发，函数返回值类型原样写，形参列表原样写，只需要将函数名称修改为指针变量名即可。

int  fun(int a,float num[]);

定义一个函数指针

int  (*p)(int a,float num[]) = fun;

函数指针指向的是一类函数。

p是一个指针变量，开辟8字节空间。

p的类型是：int  (*)(int a,float num[])

p指向空间的类型是：int  (int a,float num[])

函数指针数组：是数组，存放函数指针，指针指向函数

数组：数据类型  数组名[]

函数指针数组是数组，数组里边存放的是函数指针，在定义的时候，得根据函数指针的定义走。想要去定义函数指针，需要根据函数原型走。

int fun(char *str,int num[]);//函数原型

int (*p)(char *str,int num[]);//函数指针

int (*xys[4])(char *str,int num[]);//函数指针数组

8. 指针和字符串

可以使用一个字符串直接初始化一个指针

可以通过该指针访问字符串，但是不能通过该指针修改字符串内容—》文字常量区只读。

但是可以改变指针的指向---》可以指向其他的字符串。

char *p = “hello world”;

printf(“%s\n”,p);

字符串“hello”是存放在文字常量区的，p里边实际存放的是文字常量区里边的地址（字符h的地址）。

（1） 堆区：手动开辟，手动释放

（2） 栈区：自动开辟和释放，先进后出的原则存放局部变量  形参等内容

（3） 全局变量区：自动开辟和释放存放全局变量  静态变量。

（4） 文字常量区：只读存放文字常量的

（5） 代码段：存放二进制代码

9. 修饰类关键字  const

被const修饰的变量变成常量，不可改变(只读)。

const int a = 10;

const修饰的变量，只能在定义的同时赋值，后续不可更改。

const修饰指针

const后边有谁，就修饰谁。

const修饰谁，谁不可改变。

数据类型  * 变量名;

const 数据类型  * 变量名;

数据类型 const * 变量名;

数据类型  * const 变量名;

int *p;

const int *p;//const修饰*p，*p不可变，p可变

int const *p;//同上

int *const p;//const修饰p，p不可变，*p可变。

七. 函数

1. 函数的特点

函数分成主函数和子函数

主函数，名称必须是main，一个工程里边必须有且只能有一个，主函数是不需要被调用的，我们所谓的程序的执行，就是从主函数开始到主函数结束。

子函数，名字随便写，只要符合C语言命名规则，一个工程里边理论上没有数量限制，子函数不会自己执行，只有被主函数调用，才能去执行。

函数只有在调用的时候，才会去开辟空间，一旦程序执行结束，空间就会被释放。

2. 函数的定义

作用：具体的功能实现代码

格式：

函数返回值类型  函数名(形参列表)

{

函数体;

}

函数返回值类型：程序执行结束之后的传出参数类型 具体类型根据实际功能决定没有返回值，可以使用void

形参列表：函数执行时候的传入参数没有传参，可以使用void

函数体：函数的功能实现代码

3. 函数的声明

作用：告诉编译器，该函数存在

格式：函数返回值类型  函数名(形参列表);

4. 函数的调用

作用：让程序执行

格式：函数名(实参列表);

5. 形参和实参

形参：形式上的参数，在函数定义的时候写的参数（函数结束和空间会被释放）

可以理解为占位置

实参：实际使用的参数，在函数调用的时候，实际传递给函数的参数。（在堆区开辟空间）

传参原则：

要几个给几个   数量

        要什么给什么   类型

6. 数组传参（传首地址/数组名）

参数：数组（数据来源）

返回值：

整型和浮点型数组

使用的时候，需要传递数组首地址和数组元素个数字符数组—》字符串可以只传递首地址

值传递：把数值传递给子函数使用

地址传递：把地址传递给子函数，子函数可以修改地址指向空间的数据。

7. 全局变量和局部变量

（1）局部变量

定义在函数内部

作用时间：从定义开始，到定义它的函数运行结束

作用范围：从定义开始，到定义它的函数结束

存放在栈区

定义，未赋值，默认是垃圾值

全局变量

（2）定义在函数外部

作用时间：从定义位置开始，到整个程序结束。

作用范围：从定义位置开始，到整个文件结束。

存放在全局变量区

定义，未赋值，默认是0值。

8. extern和static

（1）静态的static

修饰全局变量：代表这个全局变量只能在本文件使用

（1） 修饰函数：代表这个函数只能在本文件使用

（2） 修饰局部变量：代表定义了一个静态变量

作用时间：和全局变量一样—》延长了使用时间。

作用范围：和局部变量一样

存储在全局变量区

解决程序执行完毕，空间被释放的问题

（2）extern：外部的

修饰全局变量：代表这个全局变量来自外部文件/允许被其他文件使用。

修饰函数：代表这个函数来自外部文件

堆区：手动，局部变量   形参

栈区：自动，局部变量   形参

全局变量：全局变量，静态变量

文字常量区：常量

代码段：二进制代码

9. 缓冲区

输入缓冲区和输出缓冲区

输出缓冲区：printf在输出数据的时候，并不是直接将数据输出在屏幕的，而是先放在输出数据缓冲区里边，当满足一定条件，才会输出。

遇到\n

程序正常结束

缓冲区满,在ubuntu下是1024字节

使用缓冲区清理函数fflush  fflush(stdout);

printf：从程序输出数据到屏幕

scanf：从键盘读取数据到程序

输入数据缓冲区：

在实际使用的时候，从键盘输入的数据是被放在输入数据缓冲区里边的，当我们按下回车，才会被程序读走。但是此时，在输入数据缓冲区会留下回车字符。

解决方案：在scanf之后加上getchar读取回车。

八. 结构体

1. 结构体的使用

基本数据类型：char   int  float

数组：数据类型  []

指针：数据类型  *

类型的表示：

关键字：struct

结构体来说，类型是不确定的，我们在使用结构体的时候，需要先去定义结构体类型，再使用该类型去定义变量。

(1) 定义结构体类型

struct  结构体类型名称

{

要存放的数据类型+变量名;

};

struct  test

{

int a;

float num[10];

char *str[10];

unsigned long *p;

struct hello x;

};

使用结构体类型来定义变量

struct  test   abc;

使用结构体类型struct test定义了一个变量，名字是abc,里边可以存放一个整型变量a，一个浮点型数组num，一个char *类型的数据str，一个unsigned long *类型的指针p，一个struct hello结构体x。

(2) 类型的大小：

按照结构体单个元素的最大值的整数倍开辟空间，保证能存下所有的数据即可。

要注意内存地址对齐。开辟的首地址必须能够被类型大小整除。

实际应用的时候，直接使用sizeof即可

类型的含义：存放不同类型的数据

元素的使用:点（.）。 指针使用 箭头（->）

(3) 结构体使用步骤

第一步：定义结构体类型

元素的使用格式:变量名.元素名

struct  test

{

int a;

float num[10];

char *str[10];

unsigned long *p;

struct hello x;

};

第二步：使用类型定义结构体变量

struct test  xyd;

第三步：使用元素

xyd.a：整型变量   int  a怎么使用，现在就怎么使用

xyd.num：浮点型数组，数组名是xyd.num，可以存放10个float类型的数据

xyd.str：指针数组，数组名是xyd.str，可以存放10个char *类型的数据

xyd.p：指针变量，可以存放地址

xyd.x：结构体变量，也可以访问里边的元素

2. 结构体定义变量的3种方式

（1） 在定义类型的同时定义变量

struct test

{

int a;

char name[10];

}b,n,m,d;

struct test  x,y;

（2） 在定义好类型之后，再去定义变量

  struct test

{

int a;

char name[10];

};

struct test  x,y;

（3） 在定义类型的同时定义变量，同时省略类型名称

struct

{

int a;

char name[10];

}b,n,m,d;

3. 结构体赋值

(1) 整体赋值—》仅限于定义的时候

struct test

{

int a;

char name[10];

};

struct test a = {123,”hello”};

(2) 单独赋值

struct test b;

b.a = 123;

scanf(“%d”,&b.a);

scanf(“%s”,b.str);

strcpy(b.str,“hello”);

b.str[0] = ‘W’;

(3) 相互赋值

struct test   a,b,c = {12,”你好”};

a = c;

b.a = c.a;

strcpy(b.str,c.str);

4. 结构体数组

数组定义：数据类型  数组名[];

数据类型：数组里边可以存放的数据类型

结构体类型   数组名[数组长度];

struct test

{

int a;

char name[10];

};

struct test num[20];

5. 结构体指针

指针的定义：数据类型  *变量名

数据类型：指针指向空间的类型

struct test

{

int a;

char name[10];

};

struct test m;

struct test *p = &m;   p+1   16

struct teat **q = &p;  q+1   8

m.a   int类型的变量

m.name  char类型的数组

*p就是m

*p.a   int类型的变量

*p.name  char类型的数组

p->a     int类型的变量

p->name  char类型的数组

6. 共用体

（1） 共用体/联合

类型的表示

先去定义数据类型

关键字：union

union  数据类型名

{

能存储的内

容；

}；

使用数据类型去定义变量

类型的大小：

按照单个最大元素的整数倍去开辟空间

保证可以存放最大元素

类型的含义

里边的元素是共用内存空间的。

（2）大小端：数据存储格式

大端模式：网络传输的数据格式

       高字节存放在低地址，低字节存放在高地址

小端模式：X86架构  

高字节存放在高地址，低字节存放在低地址。

高字节     低字节   对于数据

7. 枚举

（1）构造数据类型

类型的表示

默认是不存在的

定义枚举类型

关键字:enum

enum  数据类型名称

{

具体的取值

};

默认数值从0开始，依次递增

我们可以直接赋值，改变默认数值

（2）使用枚举类型定义变量

类型的大小：

固定4字节

类型的含义：使用固定的表达来表示数字

里边存放的是某个变量的可能取值。

类似宏定义。

枚举是数据类型，可以定义变量的

九. 链表

1. 链式表（链表）是什么？

是数据结构—》数据的链式存储结构—》空间可以不连续—》见缝插针。--》需要手动开辟和手动释放—》堆区。

线性表：数据结构—》数据的线性存储结构---》数组—》空间必须连续。

2. 链表的基本概念

节点：链表是由一个一个的节点组成的。每个节点里边是存储数据的。

头节点：链表的第一个节点被称作头节点

头节点数据域一般不赋值

尾节点：链表的最后一个节点被称作尾节点

尾节点指针域一般是NULL

数据域：存放数据

指针域：存放下一个节点的地址

3. 链表的分类：

(1) 按照指针域的指向划分

单向链表

单向循环链表

双向链表

双向循环链表

(2) 按照头节点是否存放数据划分：

有头链表

无头链表

4. 链表的实现：

链表节点划分成数据域和指针域。数据域存放数据，指针域存放下一个节点的地址---》节点类型使用什么类型？---》结构体

链表节点的实现依赖于结构体。

5. 相关函数

malloc：开辟size字节空间，并且返回空间首地址，空间没有被初始化。

free:释放ptr指向的空间

memset:将s开始的连续n字节填充为c

bzero:将s开始的连续n字节填充为0

十. 文件操作

1. 文件操作的两种方式

1）基于文件描述符的文件操作，无缓冲区，也称为低级文件的操作，属于底层文件系统，函数90多个

文件描述符：就是数字，0,1,2分别表示标准输入，标准输出，标准出错

2）基于文件指针的访问操作，带缓冲区，称为高级的文件操作，属于高级文件系统，也是标准C文件操作库函数， ANSI C库函数 300多个

对文件进行的操作有打开文件，关闭文件，读写文件。其中打开文件是第一步，可以说是为其它操作做准备的

2. 文件指针

每打开一个文件，就会返回一个指针（FILE*类型）称为文件指针，这个指针指向了这个文件相关的所有信息，即我们就可以用这个指针代表这个文件，通过这个指针可以对这个打开的文件进行各种操作。

3. 相关函数

(1) fopen()

函数:函数功能：文件打开函数

函数原型：fp=fopen(文件名，使用文件方式);

FILE *fopen(const char *path,const char *mode); //文件名 模式

如果成功，将返回一个文件指针，失败则返回NULL（其实就是0）

(2) fclose()

     函数:函数功能：文件的关闭

函数原型：fclose(文件指针)int fclose(FILE *stream)

函数返回值：成功关闭文件返回值为0，否则返回EOF(-1)；

(3) fread()

       函数功能：数据块读，读取多个数据

函数原型：size_t  fread(void *ptr,size_t size,size_t nmemb,FILE *stream);

         fread(buffer,size,count,fp);   

函数说明：fread 从文件流 stream 中读取 nmemb 个元素，写到 ptr 指向的内存中，每个元素的大小为 size 个字节。

函数注意：所有的文件读写函数都从文件的当前读写点开始读写，读写完以后，当前读写点自动往后移动 size*nmemb个字节

(4) fwrite()

函数函数功能：数据块写，写入多个数据

函数原型：size_t fwrite(void *ptr, size_t size, size_t nmemb, FILE *stream);

  fwrite(buffer,size,count,fp)

函数说明： fwrite 从 ptr 指向的内存中读取 nmemb 个元素，写到文件流 stream 中，每个元素 size 个字节

函数返回值：返回所写的数据块的数目，nmemb（count）（实际值）

调用不成功返回值是0

注意：以上，buffer参数，对fread来说，它是读入数据的存放地址，对fwrite来说，是输出数据的地址

(5) fprintf()

函数功能：输出内容到文件中

函数原型：int fprintf(FILE *stream, const char *format, ...);

   fprintf(文件指针, 格式字符串, 输出列表);

函数说明：将数据经过格式化控制符的作用，输出内容到文件指针所指向的 内存中

(6) fscanf()

函数功能：从文件中读取内容

函数原型：int fscanf(FILE *stream, const char *format, …);

          fscanf(fp, 格式字符串,输入表列);

函数说明：从文件指针fp所指向的内存中按一定的格式字符串读入

(7) fgetc， fputc

一次读写一个字符，单个字符的读写函数

1、fgetc()函数  int fgetc(FILE *stream);

函数返回值：  fgetc()会返回读取到的字符，若返回EOF则表示到了文件尾。

2、fputc()函数  int fputc(int c, FILE *stream);

(8)  fgets， fputs

1、fgets()函数

   函数原型：char *fgets(char *s, int size, FILE *stream);

函数功能：从文件流stream中读取size字节大小的数据到s所指的内存中(数 组名或者指针)

2、fputs()函数

   函数原型：int fputs(const char *s, FILE *stream);

函数功能：将s所指的内存中的数据输出到文件流中

注意：fgets 和 fputs 从文件流 stream 中读写一行数据;

puts 和 gets 从标准输入输出流中读写一行数据。

(9) 文件定位 fseek

1、文件定位

指读取或设置文件当前读写点，所有的通过文件指针读写的函数，都是聪明和文件的当前读写点读写数据的.

常用的函数有：

#include <stdio.h>

int fseek(FILE *stream, long offset, int whence);

//设置当前读写点到偏移 whence，长度为 offset 处

fseek 设置当前读写点到偏移 whence 长度为offset处，whence可以是

SEEK_SET (文件开头

SEEK_CUR(文件当前位置

SEEK_END(文件末尾

十一.  栈.队列.数

1. 栈的定义

    　堆栈（Stack）可以看成是一种“特殊的”线性表，这种线性表上的插入和删除运算限定在表的某一端进行的。　　(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。　　(2)当表中没有元素时称为空栈。　　(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。
栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。

2. 队列的定义

　队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表。                　　（1）允许删除的一端称为队头（Front）。　　（2）允许插入的一端称为队尾（Rear）。　　（3）当队列中没有元素时称为空队列。　　（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。　　队列的结构特点是先进队的元素先出队。假设有队列Q=(a1,a2,...,an),则队列Q中的元素是按a1,a2,...,an的次序进队,而第一个出队的应该是a1,第二个出队的应该是a2,只有在ai-1出队后, ai才可以出队(1≤i≤n)。     　队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"），每次离开的成员总是队列头上的（不允许中途离队），即当前"最老的"成员离队。　

3.树和二叉树

(1) 树型结构：

　　树型结构是以分支关系定义的层次结构，它是一种重要的非线性结构。　　 树型结构在客观世界中广泛存在，例如人类的家庭族谱以及各种社会组织机构都可以用树形结构来表示，又如在计算机文件管理和信息组织方面也用到树形结构。

（2） 树的概念：

树（ tree ）是由一个或多个结点组成的有限集合T 。 其中：（1）一个特定的结点称为该树的根（root）结点 ; （2）结点之外的其余结点可分为m（m ≥ 0）个互不相交的有限集合 T1 ,T2 ,......,Tm ，且其中每一个集合本身又是一棵树，称之为根的子树（subtree）。注意：    树的递归定义刻画了树的固有特性：一棵非空树是由若干棵子树构成的，而子树又可由若干棵更小的子树构成。