C语言

汇编语言

B语言 离硬件远

C89 ANSI公布的C语言标准

C99  ISO1999年公布的标准

standard input &standard output

main 主函数 VOID是空类型。函数不产生返回值。每个C语言都必须有一个main。

主函数的输出语句

表述注释部分，不运行

%d 输入输出格式字符串

“sum is ”按原样输出，%d的位置代替一个十进制数值，

逗号，后面是要输出的变量

\n 用于换行

scanf 输入函数

&是取地址，表示变量a，b的地址

scanf printf 内容都用“内容，变量或地址

C程序是由函数构成，仅有一个main函数，函数相当于其他语言的子程序

一个函数由两部分组成

C程序总是从main 函数开始执行，无论main函数在整个程序中的位置

C程序书写格式自由，运行一行写几个语句

每个语句和数据声明的最后必须有一个分号。

C语言本身没有输入输出语句，输入输出由库函数scanf和printf完成。

编辑源程序得到f.c

对源程序f.c进行编译

编译后得到f.obj

将目标程序f.obj与系统提供的库函数连接，得到f.exe

打开VS，选择新建项目

在新建项目界面内，选择VC++ ，因为C++兼容C语言，项目名称随意修改，不用添加后缀

在应用程序设置中，附加选项选择空项目，不选的话会生成一些默认代码，对初学者无用

右键选择源文件，选择添加，在添加菜单中选择新建项

添加新建项后命名，C代码要修改后缀，将cpp改为c。向程序说明这是一个C语言代码

写好代码后，不要直接按F5，程序框会一闪而过，可以按Ctrl+F5调试

错误列表可以在视图中添加

编辑默认Debug ,如果开发完成就要选择Release，这样被人在没有VS的环境下也可以使用

类似于写作文前先写提纲

将问题由抽象逐步具体化

注意模块的独立性，完成一项功能，把一个大任务分为若干个子任务

整型

字符型char

浮点型

枚举类型enum

数组类型

结构体类型struct

共用体类型union

在程序运行过程中不能被改变的量

0，-3整型常量，4.6，-1.23为浮点型常量，‘a’字符常量

#define PRICE 30

变量

十进制

八进制

十六进制

整型数据在内存中的存放形式

整型变量的分类

整型变量的定义

整型数据的溢出

一个整数在-32768到32767 分配位int型

一个整数在-2147483648到2147483647 分配为long型

一个整数后面加字母u或U分配为无符号类型

一个整数后面加字母1或L，认为是long int

十进制小数形式

指数形式

浮点型数据在内存中的存放形式

浮点型变量的分类

浮点型数据的舍入误差

系统将浮点型常量作为双精度来处理

一个浮点型常量可以赋值给一个float ，double，long double型变量

用单撇号括起来的一个字符

特殊的字符常量-控制字符-转义字符，将\后的字符转换为另外意义

用来存放字符常量，只能放一个字符，不能放字符串

在系统中占用一个字节（byte）

并不是把字符本身放入内存，而是将字符对应的ASCII码放入存储单元

ASCII码对应为整数，以整数的形式存储在内存中二进制

用一对双括号括起来的字符序列

'a'是字符常量，“a”字符串常量

int a,b,c=5;

int a=3,b=3,c=3;

float必定转为double，char，short必定转为int

低到高，int ，unsigned，long，double

两个类型混合运算，低的转为高的，必定的按必定转换

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

条件运算符

逗号运算符

指针运算符

求字节数运算符

强制类型转换运算符

分量运算符

下表运算符

基本算术运算符

算术表达式和运算符的优先级与结合性

强制类型转换运算符

自增，自减运算符

有关表达式使用中的问题说明

a=3;

如果赋值运算符两侧的类型不一致，但都是数值型或字符型时，在赋值是要进行类型转换

将浮点型赋值给整型变量，舍弃小数部分

将整型数据赋值给单双精度变量，数值不变，但以浮点数形式保存到变量中

将double数据赋值给float，截取7位有效数字，存放到float变量,如果数字范围超出float范围，会报错

将float 赋值给double，数值不变，有效位数拓展到16位，内存中以8个字节存储

字符型数据赋值给整型变量，由于字符只占1个字节，而整型变量占2个字节，因此将字符数据（8个二进制位）放到整型变量的低8位

将一个int，short，long数据赋值给char变量，只讲低8位原封不动地送到char变量

将带符号的整型数据int赋给long变量，将整型数据16位送到long的低16位

将long型数据赋值给int型变量，只将long的低16位原封不动送到整型变量中

在=之前加上其他运算符构成

凡是二元运算符，都可以于赋值符一起组成复合赋值符

简化程序，提高编译效果

将一个变量和一个表达式连接起来的式子 a=3;

求解过程

赋值表达式左侧标识符称为左值

表达式右侧标识符称为右值

赋值表达式的表达式可以是一个赋值表达式，a=(b=5);按照自右向左的结合顺序

3+5,6+8

printf（“%d,%d,%d”,a,b,c）;

控制语句

函数调用语句

表达式语句

空语句

复合语句

if（(a=b;)>0）t=a;

向终端输出一个字符

从终端输入一个字符

格式控制

输出列表

格式控制和输出列表都是printf函数的参数

格式字符

一般形式

格式说明

<,<=,>,>=,==,!=

前四种运算符优先级别相同，后两种也相同

前四种大于后两种

关系运算符优先级低于算术运算符

关系运算符的优先级高于赋值运算符

用关系运算符将两个表达式连接起来的式子

关系表达式的值是一个逻辑值

&&与

||或

！非

&&和||是双目运算符要有两个运算量

！是一目运算符，只要一个运算量

！优先于&&，&&优先于||

逻辑运算符中的&&和||低于关系运算符，！高于算术运算符

逻辑表达式的值是逻辑量，真或假

表达式自左向右扫描

逻辑表达是的求解中，并不是所有逻辑运算符都被执行，只是在必须执行下一个逻辑运算符才能求出表达式的解时，才执行该运算

if（表达式）语句

if(表达式）语句1else语句2

if(表达式1）语句1
else if(表达式2）语句2
...
else if (表达式n) 语句n
else 语句m

3种形式的if语句中在if后面都有表达式，一般为逻辑表达式或关系表达式

第二第三种形式的if语句，在每个else前面都有一分号，整个语句结束处都有一分号

在if和else后面可以只含一个内嵌操作语句，也可以有多个操作语句用

if()
  if()语句1
  else 语句2
else
 if() 语句3
else语句4

当if的表达式无论真假都执行赋值语句且向同一变量赋值时，可以用一个条件运算符来处理

if（a>b）max=a;
else max=b;

条件运算符要求有3个操作对象，称三元运算符 表达式1？表达式2：表达式3

条件运算符执行顺序，先求解表达式1，若非0则求解表达式2此时表达式2的值作为整个条件表达式的值。若为1求表达式3

条件运算符优先于赋值运算符，因此在上面的式子中先求条件表达式，再将它赋值给max

条件运算符的优先级低于关系运算符和算术运算符

条件运算符的结合方向自右向左

表达式2和2可以是数值表达式，也可以是赋值表达式或函数表达式

条件表达式中，表达式1的类型可以与表达式2,3类型不同

switch（表达式）
{
case 常量表达式1；语句1
case 常量表达式2；语句2
...
case 常量表达式n；语句n
default;
}

switch 后面括号内的表达式，其值可以是整型，字符型，枚举型数据

当表达式的值与摸一个case后面的常量表达式的值相等时，就执行case后面的语句。若case没有与表达式匹配的值，就执行default

每个case常量表达式的值必须不相同

执行完一个case后面的语句后，流程控制转移到下一个case继续执行，case 常量表达式只是起语句标号作用，并不是在该处进行条件判断。
如果要执行一个case分支后跳出switch，可以用一个break语句来终止。

case 的位置不影响执行结果

多个case可以共用一组执行语句

goto 语句标号；

goto, laber_1

goto 123 错误

与if语句一起构成循环结构

从循环体中跳转到循环体外，但在C语言中可以用break语句和continue语句跳出循环体因此goto使用机会少

当表达式非0时，执行语句中内嵌语句，先判断后执行

先执行循环体，再判断循环条件

如果循环条件为真，返回重新执行循环体语句

可用于循环次数不确定而只给出循环结束条件的情况。可以替代while

先求解循环赋初值

求解循环条件，若值为真，则执行for语句中指定的内嵌语句。再求解循环变量增值，转回执行循环条件

如果表循环条件为假结束for循环

for(;i<10;i++)

for（sum=0;i<=100,i++）

for（i=0;(c=getchar())!='\n';i+=c）

键盘输入enter键以后将一批数据一起送到内存缓冲区

不是敲一个字符马上输出一个字符

break语句可以跳出switch，也可用来跳出循环体，提前结束循环

一般形式，break;

一般形式 continue;

与break的区别是不终止循环过程，之终止循环中的一次

类型说明符 数组名【常量表达式】；

数组名的命名规则和变量名相同，遵循标识符命名规则

在定义数组是，需要制定数组中的元素个数，方括号中的常量表达式用来表示元素的个数

常量表达式可以是常量和符号常量，不能是变量，c语言不允许对数组大小做动态定义

数组必须先定义然后使用，C语言规定只能逐个引用数组元素，不能一次引用整个数组

数组元素表达形式

在定义数组时对数组元素赋初值

可以只给一部分元素赋值

如果想使一个数组中的全部元素值为0 

对全部元素赋值时，由于数据个数已确定，因此可以不指定数组长度

一般形式

在C语言中，二维数组的元素是按行存放的，内存中先放第一行元素，在放第二行元素

数组名[下标][下标]

数组元素可以出现在表达式中，也可以被赋值

注意下标值应该在定义数组的大小范围内

分行给二维数组赋值

所有有数据写到一个花括号，容易混淆

可以对部分元素赋初值

如果全部元素都赋初值，则定义数组时对第一位的长度可以不指定

用来存放字符数据的数组

由于字符型与整形是互相通用的，也可以定义一个整型数组存放字符数据

逐个字符赋值给数组中的各个元素

如果提供初值个数与预期的数组长度相同，可以省略数组长度，系统会自动确定长度

可以引用字符数组的一个元素，得到一个字符

C语言中字符串是作为字符数组来处理的

C语言规定以\0作为字符串结束标志位，字符串作为一维数组存放在内存中

程序依靠检测\0来判定字符串是否结束，、0在ASCII码中代表控操作符，什么都不做

用字符串常量来是字符数组初始化，省去花括号

如果想用一个新字符替代原有字符串，如果没有加\0那么新旧字符连成一片

逐个字符输入输出

用%s将整个字符串一次输出或输入，意思是string

输出字符不包括\0

用%s格式符输出字符串时，printf函数的输出项是字符数组名，不是数组元素名

如果数组长度大于字符串的实际长度，也只输出遇到\0结束

如果一个字符数组中包含一个以上\0，到第一个就结束

可以用scanf（"%s",c）输入一个字符串

如果利用scanf输入多个字符串，则在输入时以空格分隔

如果改为charstr[13] 

scanf的输入项是字符数组名，就不要用地址符&，因为C语言中数组名代表数组起始地址

C函数库提供

一个C程序有一个或多个源程序构成，分解为多个源程序可以分别编写，分别调试，提高效率

一个源程序是一个编译单元，不是以函数为单元编译的

C程序执行从main函数开始，在main调用其他函数，在执行完后返回到main函数，在main函数中结束整个程序运行

所有函数都是平行的，在定义函数时分别进行，相互独立。一个函数不属于另外一个函数。函数间可以互相调用，但不能调用main

从用户角度看

从函数形式分

类型标识符 函数名（）
{
声明部分
语句部分
}

类型标识符 函数名（形式参数列）
{
声明部分
语句部分
}

类型标识符 函数名（）
{     }

在主函数中的作用是标记一个函数，现在没有作用，等以后扩充

再定义函数括号中的变量位形参，在主调函数调用函数时给被调函数的参数为实参

说明

希望通过函数调用使主调函数得到一个确定的值

说明

函数名（实参表列）

如果调用无参函数，实参表列可以没有，但括号不能省略

如果实参表列包含多个实参，各个参数用逗号隔开

实参与形参个数相等，类型陪陪，且按照顺序一一对应

在程序出现的位置

一个函数调用另外一个函数需要的条件

1被调用的函数必须是已经存在的函数

2 如果使用库函数，在文件开头用#include命令将有关库函数包含到文件中

3如果使用用户自己定义的函数，而改函数的位置再调用它的函数的后面，应该在主调函数中对被调函数做声明

函数定义是对函数功能的确立，函数声明是把函数的信息通知编译系统，以便在调用函数时系统按此进行对照检查

函数原型的两种形式

只是使用函数，不是定义函数

执行main开头部分

遇到调用语句，调用函数a，执行a函数

a函数定义中，调用了b函数，执行b函数

执行完b函数，跳回到a，继续执行a

被调函数a执行完，退回到main执行

int f(int x)
{
int y,z;
z=f(y);
return(2*z);
}

用if语句在某一条件才继续执行递归调用

函数 int large(int x, int y);
large(a[i];b[i])数组元素做实参

用数组名作函数参数，此时形参应当用数组名或指针变量

说明

由于二维数组是由若干一维数组组成，在内存中按列存放。因此必须定义列数。

在第二维大小相同的情况下，形参数组的第一维可以与实参数组不同。

在一个函数内部定义的变量是内部变量，只在函数范围有效，称为局部变量

说明

系统编译的单元是源程序文件，一个源文件包含多个函数，在函数外定义的变量
称为全局变量，有效范围从定义变量开始到本源文件结束

全局变量可以被范围内的所有函数共用

说明

变量按作用域分

按存在时间分

内存中用户的存储空间分三部分

数据存放在静态存储区和动态存储区

全局变量全部存放在静态存储区

动态存储区中存放

在C语言中，每个变量或函数由两个属性

函数的局部变量，如不声明位static，则动态地分配存储空间。调用结束释放

auto 可省略，默认自动存储

有时希望函数中局部变量的值在函数调用结束后不消失而保留原值，其占用的存储单元不释放。下次调用函数式，改变量已有值。

在局部变量前加上关键词static 做声明

说明

一般情况变量的值存放在内存中，当程序用到哪个变量的值，由控制器发出指令将内存中概变量的值送到运算器中
经过运算器进行运算，如果需要存数，再从运算器将数据送到内存存放

如果有一些变量频繁使用，则存取变量的过程花费不少时间，为了提高执行效率，
C语言允许将局部变量的值放在CPU中的寄存器。需要用是直接从寄存器取出参加运算，
不必到内存中去存取。可以提高效率。这种变量称为寄存器变量，用关键字register 声明

说明

外部变量是在函数外部定义的全局变量，作用域从变量定义开始，到本程序文件末尾

有时需要用extern来声明外部变量，以扩展外部变量的作用域。

在一个文件内声明外部变量

在多个文件的程序中声明外部变量

用static 声明外部变量

需要建立存储空间的声明称为定义

不需要建立存储空间的声明称为声明

外部变量定义和外部变量声明的含义不同，外部变量定义只能有一次，而同一文件的声明可以有多次。

对外部变量的初始化只能在定义时进行，所谓的声明作用说明变量在后面定义了。作用拓展到前面

extern只用于声明，而不用与定义

static声明变量的作用

如果函数只能被本玩家中其他函数调用，称为内部函数。在定义内部函数时，在函数名和函数类型前加static

static 类型标识符 函数名（形参表）；

内部函数又称静态函数，因为它用static声明。

在定义函数时，如果在函数首部最左端加extern，表示此函数是外部函数，可供其他文件调用

这样函数fun就可以为其他文件调用，如果省略extern，默认为外部函数。

在需要调用此函数的文件中，extern对函数作声明，表示该函数时再其他文件中定义的外部函数

C语言允许声明函数时省写extern，直接用函数原型

进一步理解函数原型

用一个指定的标识符来代表字符串

作用是在本程序文件中用指定的标识符PI来代替3.14，在编译预处理后，程序出现的所有PI都用3.14代替

标识符也称 宏名，在预编译时将宏名替换成字符串的过程称为宏展开

说明

# define 宏名（参数表）字符串

#include“文件名”

#include<文件名>

一个#include命令只能指定一个被包含文件，如果要包含n个文件，要用n个#include命令

如果文件1包含文件2，而文件2用到文件3的内容，则应在文件1中先包含文件3再包含文件2

在一个被包含文件中可以包含另外一个文件，文件包含可以嵌套

用<>和“”的区别

被包含文件与其所在的文件编译后成为同一个文件，因此文件若有全局静态变量，在文件1中也有效，不必用extern 声明

#ifdef 标识符
程序段1
#else
程序段2
#endif

程序段可以是语句组也可以是命令行

条件编译的好处：如果一个源程序在不同计算机运行，而不同计算机又有一定差异，如有的是32位有的是64位，
这往往需要对源程序作修改，降低了程序的通用性。

#ifdef COMPUTER_A
  #define INTEGER_SIZE 16
#else
  #define INTERGER_SIZE 32
#endif

在调试程序时，常常希望输出一些所需的信息，
而在调试完成后不再输出这些信息

#ifndef 标识符
程序段1
#else
程序段2
#endif

# if 表达式
程序段1
#else
程序段2
#endif

找到变量i的地址2000然后有2000取出数据把它输出

这种按变量地址存取变量的方法称为直接访问

将变量i的地址存放到另一个变量中 

访问时，先找到存放变量i的地址变量i_add，从其中得到变量i 的地址。
再去找i的存储单元，然后对它进行存取访问

将3送到变量i所标志的单元中

将3送到变量i_point所指向的单元中

*i_add=3;

指针变量不同于其他数据类型变量，它是用来存放地址的，必须将它定义为指针类型

int *add1,*add2;

一般形式

如何让指针变量指向另一变量

注意

指针变量只能存放地址，不要将一个整数赋给指针变量

运算符

说明

函数参数可以是指针类型，作用是将一个变量的地址送到另外一个函数中

VOID swap(int *pi,int*p2)

如果想通过函数调用得到n个要改变的值

不能企图通过改变指针形参的值使指针实参的值改变

定义指向数组元素的指针，与指向变量指针定义相同

指针类型需要与数组类型相同

由于数组名代表数组中首元素的地址，因此p=&a[0]等价于p=a

int *p;
p=&a[0];
*p=1;表示将1赋值给p当前所指向的数组元素

C语言规定，如果指针变量p指向数组的一个元素，那么p+1指向同一个数组中的下一个元素，而不是将p的值简单加1
如果是int型，p的地址+2个字节，如果是float型数组p的地址+4个字节

如果p的初值是a[0]，那么p+i和a+i就是a[i]元素的地址。指向数组第i个元素

如果p的初值为a[0]

指向数组的指针变量也可以带下标，如p[i]与*（p+i）等价

引用一个数组元素

输出数组全部元素

int a[10];
f(a)

void swap（int x,int y）
swap(a[1],a[2])

f(int a[],int n);
编译时，系统将形参a[]按指针变量处理
f(int*a,int n)

以变量名和数组名作为函数参数的比较

实参数组名代表固定地址，或指针常量，但形参数组并不是一个固定的地址值，而是作为指针变量。
在函数调用开始时，它的值等于实参数组首元素的地址。在函数执行期间可以再被赋值

总结

多维数组元素的地址

指向多维数组元素的指针变量

用指向数组的指针作为函数参数

有两种方法可以访问字符串

将一个字符串从一个函数传递给另外一个函数，可以用地址传递的办法。用字符数组名做参数，也可以用指向字符的指针变量做参数。
在背调用的函数中可以改变字符串的内容。在主调函数中可以得到改变了的字符串

用函数调用实现字符串赋值

字符数组由若干个元素组成，每个元素放一个字符。字符指针变量存放的是地址。决不是将字符串放到字符指针变量中

赋值方式，对字符数组只能对各个元素赋值，不能用一下办法对字符数组赋值
char str[14];
str="i love china";

对字符指针变量赋初值

如果定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量
给指针变量分配内存单元，在其中可以放一个字符变量的地址。也就是说，该指针变量可以指向
一个字符型数据。但如果未赋予地址值，它并未指向一个确定的字符数据

指针变量的值是可以改变的

可以用带下标的字符指针变量引用字符串中的字符

用指针变量指向一个格式字符串，可以替代printf函数中的格式字符串

可以用指针变量指向整型变量，字符串，数组，指向一个函数。函数在编译时分配一个入口地址。
这个函数的入口地址就是函数指针。可以用一个指针变量指向函数。然后通过指针变量调用函数。

int max(int ,int);
int(*p)(int,int);
p=max
c=(*p)(a,b);

指向函数指针变量可以作为函数参数，相当于调用函数时传入两个子函数

为什么不直接用函数名作为实参，而用指针呢？

定义形式

一个数组，若其元素均为指针类型数据，称为指针数组。每个元素都是指针变量

为什么用指针数组，因为比较适合用于指向若干个字符串，使字符串处理更加方便。例如图书馆有若干本书
想把书名放在一个数组中，然后对这些书目进行排序查询。按一般的方法，字符串本身就是一维数组。做成集合需要用二维数组。
但定义二维数组是，需要制定雷叔，也就是每本书名（字符串的长度）。对于长度不一的书名来说会造成内存浪费

可以分别定义一些字符串，然后用指针数组中的元素指向各个字符串。如果想对字符串排序，不必改动字符串位置
，只需改动指针数组中个元素的指向。且移动指针比移动字符串所花的时间少的多。

char *name[]={"follow me","basic","great wall","fortran",computer"};这是一个指针数组，name代表指针数组的首元素地址
，name+1是name[1]的地址。地址的内容是指针。可以设置一个指针变量p，使它指向指针数组元素。

定义指向指针的指针变量

指针数组的一个重要应用是作为main的形参。实际上main（）是可以带参数的

命令行的一般形式

利用指针数组做main形参，可以向程序传送命令行参数。这些字符串长度事先不知道。而且个参数字符串长度一般并不相同。命令行参数书目也可以是任意的，指针数组能满足上述要求

int i；

int*p;

int a[n];

int *p[n]

int （*p）[n]

int f()

int *p（）

int （*p）()

int**p

指针变量加减

指针变量赋值

空指针

两个指针变量相减

定义一个指针变量，但不指定它是指向哪一种类型数据。它可以用来指向一个抽象类型数据，在将他的值赋给另一指针变量是要进行强制类型转换

char *p1
void*p2
p1=(char*)p2

struct student
{
int number；
char name【20】；
char sed;
int age;
float score;
};

struct student student1，student2；

结构体类型名 结构体变量名

定义了student1和student2为struct student 类型的变量。他们具有structstudent类型结构，
系统会为它们分配内存。

如果程序规模大，往往将对结构体类型的声明集中放到一个头文件.h中，哪个源文件需要就用#include包含

struct student{int number；char name【20】；char sed;int age;float score;}student1，student2；

把变量加到定义结构体后面

struct
{
成员表列
}变量名表列；

类型与变量是不同概念，类型不分配空间，也不能运算赋值。变量可以

结构体成员，可以单独使用，它的作用与地位相当于普通变量

成员可以是一个结构体变量

成员名可以与程序中的变量名相同，二者代表不同对象

不能将一个结构体变量作为一个整体进行输入输出
只能对结构体变量中的成员输入输出。

如果成员本身是一个结构体类型，可以用若干个成员运算符
一级一级查找最低成员

对结构体变量的成员可以像普通变量一样进行各种运算

可以引用结构体变量成员的地址，也可以引用结构体变量的地址

struct student{int number；char name【20】；char sed;int age;float score;};
struct student stu[3];

定义了一个数组stu,数组有3个元素，均为struct student 类型

struct student{int number；char name【20】；char sed;int age;float score;};
struct student stu[3]={{10101，“li lin”,"m",18,87}{"10102","zhang fun","m",19,99}{...}};

struct student
{long num;
char name[20];
char sex;
float score;}
struct student stu_1;
struct student*p;
p=&stu_1;
printf("NO:%ld\n",(*p).num)

结构体变量.成员名

（*p）.成员名

p->成员名

struct student{int number；char name【20】；char sed;int age;float score;};
struct student stu[3]={{10101，“li lin”,"m",18,87}{"10102","zhang fun","m",19,99}{...}};
struct student *p;
for(p=stu;p<stu+3;p++)
printf("%5d%-20s%2c%4d\n",p->num,p->name.p->sex,p->age);

将一个结构体变量的值传递给函数由3中方法

1 用结构体变量的成员作参数

2用结构体变量作实参

3 用指向结构体变量的指针作实参。将结构体变量的值传形参

链表是一种常见的重要数据结构，动态地进行存储分配的一种结构。用数组放数据是，必须事先定义数组长度。
如果A班有100人，B班有30人。如果要用同一个数组存放不同班级的学生数据，必须定义长度为100的数组。如果事先无法
确定班级认识，则数必须定的足够大。这显然会造成内存浪费。

链表是根据需要开辟内存单元
head-A-B-C-D

结构体变量作为链表中的结点是最合适的。一个结构体变量可以包含多种数据。
struct student
{
int num；
float score；
struct student*next；
}

定义链表结构体：struct student{long num; float score;struct student*next;}
定义结构体变量和指针： struct student a,b,c*head,*p;
把要保存的数据给链表元素 a.num=10101;a.score=89.5;b.num=10103;b.score=90;c.num=10107;c.score=85;
给链表指针赋值： head=&a;a.next=&b;b.next=&c;c.next=NULL;
p=head;
do
{ printf("%ld%5.1f\n",p->num,p->score);输出链表元素的成员。
p=p->next;}while（P!=NULL）使指针变量指向下一个，判断NULL停止

链表结构动态分配存储，在需要时才开辟下一个结点

malloc函数

calloc函数

free函数

在程序执行过程中从无到有地建立起一个链表。一个一个地开辟结点和输入各结点数据，并建立前后联系

定义链表结构体：struct student{long num; float score;struct student*next;}
定义一个带回链表头的指针的函数
struct student*creat（void）
{定义头部指针struct student*head;
定义结构体指针p1p2,struct student*p1,*p2;
p1p2都指向一个开辟单元，p1=p2=(struct student*)malloc(LEN);
输入数据scanf（“%ld,%f”,&p1->num,&p1->score）；
头指针赋值空 head=NULL；
只有输入数据不为空时,传入有效地址
while（p1->num！=0）
{n=n+1；if（n==1）head=p1;else p2->next=p1;}
p1赋值给p2，p1指向新开的存储区 p2=p1;p1=(struct student*)malloc(LEN);
检测下一个输入scanf("%d,%f",&p1->num.&p1->score);
}
如果检测到输入的学号为0，结束链表 p2->next=NULL;
返回头部指针
}
在main中调用create函数：
void main（）
{create（）}

首先要知道链表第一个结点地址，也就是head的值，然后设一个指针变量p，先指向第一个结点地址。输出p的内容后
使p后移一个结点，在输出，知道链表的尾结点

定义链表输出函数
void print（struct student*head）
{struct student*p
printf（“\nNOW,These %d records are:\n”,n）
p=head;
if(head!=NULL)
do
{printf("%d%5.1f\n",p->num,p->score);
p=p->next;}while(P!=NULL);
}

从动态链表中删除一个结点，并不是真正从内存中抹去，而是把它从链表中分离处理，只要撤销原来的链接关系即可

写一个函数用于删除动态链表中指定的结点

思路：加入以学号作为删除结点的标志。从p指向的第一个结点开始，检查该结点中num值是否等于输入的要求删除的那个学号
如果相等就删除结点，如果不相等p后移一个结点继续判断。设置两个指针变量p1p2,先使p1指向第一个结点。第一种情况
要删除head那个结点，那么把p1指向的结点赋值给head就可以了。如果不是第一个结点，则将p1->next=p2->next.把要删除的
结点的next传给前一个的next

将一个结点插入到一个已有的链表中

加入学生链表是按照学号大小顺序排列。必须解决两个问题

几个变量互相覆盖，使几个不同变量共占同一段内存的结构

一般形式

共用体与结构体定义相似，但含义不同

不能引用共用体变量，只能引用共用体变量中的成员。

同一个内存段，可以用来存放集中不同类型的成员。但一瞬间只能存放其中一种，也就是只有一个成员有效

共用体变量中起作用的成员是最后一次存放的成员，在存入一个新的成员后原有的成员就失去作用。

共用体变量的地址和它的各个成员地址都是同一地址

不能对共用体变量名赋值，也不能企图引用变量名来的到一个值

不能把共用体变量作为函数参数，也不能使用函数带回共用体变量，但可以使用指向共用体变量的指针。也可以作为结构体成员

enum weekday{sun,mon,tue,wed,thu,fri,sat};

enum weekday workday,weekend;

枚举元素按常理处理，不能赋值，sun=0不合法

枚举元素作为常量是有值得，系统按定义顺序从0,1,2.分配

枚举值可以做比较判断 workday=mon >sun

一个整数不能直接赋值给枚举变量，因为他们不是同种类型。可以用强制转换 workday=（enum weekday）2;

typedef int INTERGER;
定义变量
INTERGER i,j;等价于int i,j;

typedef struct
{
int month;
int day;
int year;
}DATE;

先按定义变量的方法写出定义体 如 int i;

将变量名换成新类型名

在最前面加typedef

然后用新的类型名去定义变量

typedef 声明各种类型，但不能用来定义变量

用typedef 只是对已经存在的类型指定一个新的类型名，而没有创造新的类型

typedef 和#define 有相识之处，但不同在于define只做预处理简单替换，typedef是声明类型

不同源文件中用同一类型数据，常用typedef声明一些数据类型，把他们单独放在一个文件中，然后再需要时用#include包含

使用typedef有利于程序通用与移植。因为有的电脑int 是2个字节，有的电脑是4个字节  需要将int改为long
那么如果有type int INTERGER ,只要在定义文件中改typedef long INTERGER ，一改全改

清零，想要将一个单元清零，找一个二进制数相与为0

取一个数中某些指定位，如果要低4位可以将高4位清零

使特定位翻转 ，假设有1010，需要翻转可以与1111进行异或运算
结果为0101

与0异或，保留原值

交换两个值，不用临时变量

a&=b 等价于a=a&b

其中a,b,c,d 分别占2位，6位，4位，4位，i为整型共占4个byte
也可以使各位段不恰好占满一个字节

data.a=2;data.b=7,data.c=9;注意位段允许的最大范围
如写成data.a=8，因为a只占2位，最大值为3，超出最大值
自动赋予它的数的低位。如8的二进制1000，取低2位为00.所有a=0

位段成员必须指定位unsigned或int类型

若某一位段要从另一个字开始存放可以如下定义
unsigned a:1;
unsigned b:2;
unsigned  :0;
unsigned c:3;

一个位段必须存储在同一个存储单元中，不能跨越两个单元

可以定义无名位段

位段长度不能大于存储单元长度，也不能定义位段数组

位段可以用整型格式输出printf（“%d,%d,%d”,data.a,data.b,data.c）也可以用八进制十六进制输出

位段可以在数值表达式中引用，它会被系统自动转换为整型数据

缓冲文件系统

非缓冲文件系统

FILE[5],定义了一个结构体数组f，它有5个元素。可以用来存放5个文件信息。

FILE *fp

ANSI C 规定了标准库，用fopen函数打开文件。调用方式
FILE *fp;
fp=fopen(文件名，使用文件方式）；

fp=fopen("a1","r");表示要打开文件名为a1的文件。使用文件的方式为“读取read”
函数返回指向a1文件的指针并赋值给fp，这样fp就和文件a1关联了。

使用文件方式

说明

关闭是使文件指针变量不再指向该文件，文件指针变量与文件脱钩。

fclose（文件指针）

把一个字符写到磁盘文件中去

从指定文件读入一个字符
文件必须是以读或读写方式打开

用于一次读写一组数据

从磁盘读写数据

使位置指针重新返回文件的开头，次函数没有返回值

流式文件可以顺序读写，也可以随机读写。关键在于控制文件的位置指针。将位置指针