大家好，欢迎来到IT知识分享网。
写在开头：之前一直都没过计算机二级，现在用编程语言比较多，想九月份一起把二级三级过了。
第一章 程序设计基本概念
1.程序：为解决某一问题而设计的一系列指令，能被计算机识别和执行。
程序=语法+算法。
2.程序设计语言：人与计算机打交道时交流信息的一类媒介和工具，由语句组成。
程序包含以下几个步骤：
（1）确定数据结构：根据任务书提出的要求、指定的输入数据和输出结构，确定存放数据的数据结构。
（2）确定算法：针对存放数据的数据结构来确定解决问题、完成任务的步骤。
（3）编码：根据确定的数据结构和算法，使用选定的计算机语言编写代码，输入到计算机并保存在磁盘上，简称编程。
（4）在计算机上调试程序。
（5）整理并写出文档资料。
3.算法：解决问题的具体方法和步骤
算法的五个特性：
（1）有穷性——在合理范围内可完成（不能是死循环）
（2）确定性——无歧义性
（3）可行性——通过有限次基本运算可完成
（4）有零个或多个输入
（5）有一个或多个输出
4.算法的描述：伪代码和流程图（一般流程图和N-S流程图）
如上图所示，左侧为一般流程图，右侧为N-S流程图。·
5.结构化程序设计和模块化结构
结构化程序：使用顺序、选择、循环这三种结构所构成的程序
三种基本结构的共同特点：
（1）只有一个入口
（2）只有一个出口
（3）结构内的每一部分都有机会被执行到
（4）结构内不存在“死循环”
模块化：把一个复杂的问题划分为小问题逐个解决方式
C语言通过函数划分功能实现模块化。
第二章 C程序设计的初步知识
1.简单C语言程序的构成和格式
#include <stdio.h> //stdio.h中i表示input，o代表output，h代表head； int main() //int函数的返回值类型 main（）主函数，是程序执行的入口地址 {//函数的起始位置 int width=3, height=4; //定义变量 int area=width*height; printf("面积=%d\n",area); //%d是格式控制符，十进制整数 return 0; }//函数结束的位置
//行注释：解释说明，去掉暂时不想执行的语句
/* */段落注释
#include<stdio.h>是在程序编译之前要处理的内容，称为编译预处理命令。编译预处理命令还有很多，他们都是“#”号开头，并且不用分号结尾。
stdio.h也就是C语言的有关标准输入流输出流的头文件。
在使用标准函数库中的输入输出函数时，编译系统要求程序提供有关的信息（例如对这些输入输出函数的声明），#include<stdio.h>的作用就是用来提供这些信息的，stdio.h是C编译系统提供的一个文件名，stdio是“standard input&output”的缩写，即有关标准输入输出的信息。
预处理命令称为文件包含命令，其作用是在编译之前把程序需要使用的关于系统定义的函数printf（）的一些信息文件stdio.h包含进来。以“.h”作为后缀的文件称为头文件。
2.标识符、常量和变
（1）标识符：在编程中标记操作对象的名称和有特殊含义的字符
标识符包括：关键字（保留字）、预定义标识符、用户标识符
关键字：C语言已经预先规定了一批标识符，他们在程序中都代表着固定的含义，不能另作他用，这些标识符称为关键字。包括：
auto——声明自动变量，缺省时编译器一般默认为auto
int——声明整型变量
double——声明双精度变量
long——声明长整形变量
char——声明字符型变量
float——声明浮点型变量
short——声明短整型变量
signed——声明有符号类型变量
unsigned——声明无符号类型变量
struct——声明结构体变量
union——声明联合数据类型
enum——声明枚举类型
static——声明静态变量
switch——用于开关语句
case——开关语句分支
default——开关语句中的“其他”分支
break——跳出当前循环
register——声明寄存变量
const——声明只读变量
volatile——说明变量在程序执行中可被隐含的改变
typedef——用以给数据类型取别名（还有其他作用）
extern——引用变量
return——子程序返回语句（可以带参数，也可以不带参数）
void——声明函数无返回值或无参数，声明空类型指针
continue——结束当前循环，开始下一轮循环
do——循环语句的循环体
while——循环语句的循环条件
if——条件语句
else——条件语句否定分支（与if连用）
for——一种循环语句
goto——无条件跳转语句
sizeof——计算对象所占内存空间大小
预定义标识符：在C语言中预先定义并有特殊含义的标识符，如printf、scanf、sin、isalnum等等
预定义标识符可以作为用户标识符使用，只是这样会失去系统规定的原意，使用不当还会使程序出错。
用户标识符：又称自定义标识符，指用户根据自己需要定义的标识符。
规则：
A、只能包含字母数字下划线
B、只能以字母或者下划线开头
C、不能使用关键字
正确：area、PI、_int、a_array、s1234、p101
非法：456p、cade_y、W.W、a&b
3.变量和常量
变量：在程序运行过程中其值可以改变的量
int width;
int height;
在C语言中变量要先定义才能使用
变量有变量名、变量地址、变量值、数据类型四个属性
常量：在程序运行过程中其值不能被改变的量
如：“hello world！”、3、‘A’、3.14
符号常量：用一个符号代替一个常量的符号叫做常量符号。
int const num=5
#define N 5
4.数据类型
整型数据
（1）十进制表示：用一串连续的数字[0-9]表示十进制。例345 67899 0 -2467 只有十进制可以是负数
（2）八进制表示：以数字0开头的一个连续数字序列，序列中只能有0-7这八个数字。例：045 076 067456，而019、423是非法的八进制数。
（3）十六进制表示：以0X或0x开头的连续数字和字母序列，序列中只能有0-9、A-F和a-f这些数字和字母，字母a、b、c、d、e、f分别对应10、11、12、13、14、15，大小写均可。
整型变量
可以分为基本型、短整型、长整型和无符号型四种。
| 名称 | 全称类型说明符 | 字节 | 范围 |
| 整型 | [signed] int | 4 | -2147483648至2147483647 |
| 无符号整型 | unsigned [int] | 4 | 0至4294967295 |
| 短整型 | [signed] short [int] | 2 | -32768至32767 |
| 无符号短整型 | unsighed short [int] | 2 | 0至65535 |
| 长整型 | [signed] long [int] | 4 | -2147483648至2147483647 |
| 无符号长整型 | unsigned long [int] | 4 | 0至4294967295 |
5.实型数据
实型常量：又称实数或浮点数。
1.小数形式：由数字和小数点组成、必须有小数点。
例如：4.23、0.15、.56、78.、0.0、
2.指数型式：以幂的形式表示，以字母e或E后跟一个以10为底的幂数。
字母e或E之前必须要有数字，且字母e或E后面的指数必须为整数，字母e或E的前后及数字之间不得有空格（实型变量也遵守这个原则）。
例如：2.3e5、200e-2、0.5E3、4.5e0，而e4、.5e3.6、.e5、e都不合法。
实型变量
1.单精度：关键字为float
定义的一般形式 float a, b, c;
float a=4.5, b=5.6;
注：（1）占四个字节32位
（2）7位有效数字-1038~1038
2.双精度：关键字为 double
定义的一般形式 double a,b,c;
double a=5.9, b=45.36
注：（1）占八个字节 64位
（2）15~16位有效数字 -10308~10308
说明：
a.在内存中，实数一律以指数形式存放
b.在内存中，整数可以精确存放，实型数据存在误差
c.定义变量的同时可以赋初值。
总结：
1.C语言是区分大小写的
2.常量的分类：整型常量、实型常量、字符常量、字符串常量
3.变量的分类：1.整型变量：基本型、短整型、长整型和无符号型四种
2.实型变量分类：单精度、双精度
4.指数形式：字母e或E之前必须要有数字，且字母e和E后面的指数必须为整数，字母e或E的前后及数字之间不得有空格（实型变量也遵守这个规则）
6.算数表达式
算数运算符：+、-、*、/、%、（）
赋值表达式：=
复合复制表达式：+=、-=、*=、/=、%=
自增、自减：++、–符号预算符
逗号运算符和逗号表达式：表达式1，表达式2，表达式3，…..表达式n
第三章 顺序结构
1.数据输出
把数据从计算机内部送到计算机外部设备上的操作称为“输出”
ptintf函数：用来在终端设备上按指定格式进行输出。printf(“格式控制”，输出项1，输出项2，输出项3，……)
A、格式控制是字符串形式，作用是将要输出的数据按照指定的格式输出并提供需要原样输出的文字或字符串。
B、格式字符说明
%c输出字符、%s输出字符串、%d输出整数、%x%X输出十六进制
%o八进制输出、%p输出指针值、%f输出浮点数、%e%E科学计数法输出
%g%G由系统决定使用%f还是%e、%u无符号整数、%%输出一个%
C、输出项和输出控制类型要匹配
D、可以加入特殊字符如：\n、\r、\t、\a
\n：换行(LF) ，将当前位置移到下一行开头
\r：回车(CR) ，将当前位置移到本行开头
\t：水平制表(HT) （跳到下一个TAB位置）
\a：响铃
E、长度修饰符
在%和格式字符之间，可以加入长度修饰符，以保证数据输出格式的正确和对齐。长整型%ld短整型%hd
F、宽度说明
%和格式字符之间插入一个整数常数来指定输出的宽度n, 对于float和double的实数，可以用n1.n2的形式来输出，或者用.n2输出。在%d和宽度之间加“-”实现数据左对齐，加“+”在每个数字前面带正负号。
printf函数返回值为它输出的字符数，包括控制字符。
如果需要输出带前导0x 0X的十六进制在%x和%X中间加入#
如：int a=255; printf(“%x%X%#x%#X\n”,a,a,a,a);
输出ff FF 0xff 0XFF
输出带前导0的八进制在%o中间加入#
如：printf(“%#o,%o”,012,012);
2.数据输入
从计算机的输入设备上获得数据的操作称为输入
scanf函数，从键盘上获取数据
scanf（”格式控制”,输入项1，输入项2，……）
A、格式控制主要作用是指定输入时的数据转换格式，输入项之间用逗号隔开，对于int,float,double,char类型变量，在变量之前必须加&取址运算符作为输入项。
B、格式字符
%c字符、%d整数
%o八进制、%x十六进制、%u无符号整数、%f实数%lf双精度实数、%e %le按科学计数法输入 %s字符串
C、多输入项需用空格回车等间隔符隔开
D、在%和格式字符前加入一个整数指定输入数据所占宽度
E、在%和格式字符前加入*跳过某个数据输入项
F、必须和格式控制中的字符完全匹配
3.复合语句和空语句
（1）复合语句
定义：用一对花括号把若干语句括起来构成一个语句组
注意：
a.花括号内语句的数目不限
b.里面可以有定义语句
c.在花括号外面不能加分号
（2）空语句
main
{ ； }
第四章 选择结构
选择结构：根据判断的结果（逻辑值）决定程序的不同流程
逻辑值：关系运算和逻辑运算都会得到一个逻辑值，C语言中，0代表逻辑值“假”，非0（正数或者负数）代表“真”。
1.关系运算
关系运算：又叫比较运算，进行两个数的比较，判断比较的结果是否符合指定的条件。
关系运算符：（C语言中有6种，是双目运算符，从左向右结合）
<小于
<=小于等于
>大于
>=大于等于
==等于
!=不等于
注意：
1.两个符号之间不允许有空格，一个整体表示一个运算符
2.关系运算符是双目运算符，具有从左至右的结合性
3.<、<=、>、>=优先级相同，但高于==、！=优先级
如 int a=1，b=2, c=3; a==b<c结果是b<c 》》》1，a==1》》》1
4、算数运算符优先级>关系运算符的优先级>赋值运算符优先级
关系表达式：由关系运算符构成的表达式
关系表达式的值：整数0或1
关系运算符两边值的类型不一致，自动进行类型转换。
浮点数由于存放有误差，不可能精确相等可能导致x==y为0（所以最好不要判断浮点数是否相等）
2.逻辑运算
逻辑运算：又称布尔运算，逻辑值（0和1）之间的运算称为逻辑运算
逻辑运算符：（有三种&&、||、！）
| 运算符 | 名称 | 示例 | 含义 |
| && | 逻辑与 | a&&b | 若a、b同时为真，则a&& |
| || | 逻辑或 | a||b | 若a、b之一为真，则a||b为真 |
| ！ | 逻辑非 | !a | 若a为真，则！a为假；a为假，则！a为真 |
逻辑运算符的优先顺序
！（非），&&（与），||（或）
！>算数运算符>关系预算符>&&>||>赋值运算符
如int a, b=0, c=1, d=2, e=3；
a=!b+c&&d*c;//等同a=(((!b)+c)&&(d*e))
预算步骤是：！b=>1,1+c=>a, d*e=>6, 2&&6=>1,a=1
注意：
（1）数学上的关系式a<b<c，要写作a<b&&b<c,不然就是（a<b=>(0或1)）<c
（2）“短路”在使用&&和||时，左侧的表达结果已经可以确定真假值时，将不再判断右侧的表达式真假。如a<0||b=3 a<0为真时将不再执行b=3、a<0&&b=3 a<0为假时，则不再执行b=3。
因此在逻辑运算符中最好不要做其他必须的运算，如a++,a–等，因为可能不会执行。
3.if语句
if语句有三种形式：
格式一：if(表达式) 语句
if(a>b) ptintf(“%d”,a);
a>b为真时执行ptintf(“%d”,a)，否则什么也不做
格式二：
if（表达式）
语句1
else
语句2
if(a>b)
printf(“large=%d”, a);
else
printf(“small=%d”,b);
a>b为真则执行printf(“large=%d”,a);否则执行printf（“small=%d”,b）;
格式三：
if（表达式1） 语句1；
else if （表达式1） 语句2；
else if （表达式2） 语句3；
……
else if （表达式m） 语句m;
else 语句n // 不是必须要有的
if(0==x) y=1; else if(x>0) y=a*2; else y=a/2;
几点说明：
（1）if后面的表达式类型任意
if(a==b&&x==y) printf("a=b,x=y"); if(3) printf("OK"); if('a') printf("%d",a);
(2)if后面的语句可以是复合语句，必须加{}
int main() { int x, y; scanf("%d,%d",&x,&y); if(x>y) { x=y; y=x; } else { x++;y++; } printf("%d,%d\n",x,y); }
4.if语句的嵌套
if语句中又包含一个或多个if语句称为if语句的嵌套。
实际上只要将前述if语句的形式1、2、3中的内嵌语句用一个if语句代替，即称为if语句的嵌套。
嵌套的if语句还可以嵌套另一个if语句，形成多重嵌套。
如：
if(条件1) if(条件2) 语句1； else 语句2； else if(条件3) 语句3； else 语句4；
if~else配对原则：缺省{}时，else总是和他上面离它最近的未配对的if配对。
if（……） if（……） if（……） else…… else…… else……
{}对于区分逻辑很重要，所以不论是单条语句还是符合语句尽量使用{}
5.条件表达式
条件运算符：？： C语言中的唯一的三目运算符，要求有三个运算对象
条件表达式：由条件运算符构成的表达式
使用形式如下：
表达式1？表达式2：表达式3
运算过程：表达式1的值为非零（逻辑值为真）则整个表达式的值为表达式2的值否则为表达式3的值。
if(a>b) max=a; else max=b
max=(a>b)?a:b;
优先级别
低于关系运算符合算数运算符，但高于赋值预算符。
如：y=x>10?100:200;
y=x<0?(-1)*x：x;
6.switch语句和break语句构成的选择结构
一般方式：
switch(表达式) {case C1： 语句1；break； case C2: 语句2；break; …… case Cn: 语句n；break； default：语句n+1; break; }
注意：
表达式的值只能是整型或者字符型
C1、C2、……为常量表达式类型要与表达式类型相同
使用break语句跳出switch语句，不然会顺序向下执行
default在其他分支条件都不满足时执行。
switch执行过程：
（1）计算表达式的值
（2）根据表达式的值找到相应的case标号
（3）执行其对应标号之后的语句直到switch语句结束
（4）break语句可以跳出switch语句
switch（num） { default： printf("%d\n",num); case1: printf("hello"); case2: printf("world!\n";);break; case3: printf("您好！\n");break; case4: switch(ch) { case'A': case'C': printf("B\n");break; } }
注意点：
（1）C1、C2、C3……是常量表达式，且值必须互不相同
（2）常量表达式其语句标号的作用，必须用break跳出
（3）case后加可包含多个可执行语句，且不必加{}
（4）switch可嵌套多个case可共用一组执行语句
7.语句标识和goto语句
语句标识：标识符和“：”组成，如flag： stop： _start：都是合法标识
10：是不合法的标识符、标号可以和变量同名。
用于作为goto语句的跳转目标
goto语句又称无条件跳转语句，一般形式如下：
goto 语句标号：
标号必须和goto在同一函数内
一般不建议使用，因为他会导致程序毫无规律，可读性差。
int num=0; loop: if(num<10) { printf("loop:%d\n",num++) goto loop; }
第五章 循环结构
while语句实现“当型”循环结构，即当表达式为真就执行循环体。
一般形式：
功能：先判断表达式，若为真则执行循环体，再判断表达式，重复上述过程，直到表达式为假时退出循环。
\\用while语句构成循环，求0-100的值的和 #include<stdio.h> int main() { int i,sum=0; i=1;\\循环初值 while(i<=100)\\循环终止条件 { sum=sum+i; i++; } printf("%d",sum); }
关于while循环语句：
while循环先判断表达式，后执行循环体。循环体有可能一次也不执行。
循环体若包含有一个以上语句的复合语句，应该用{}括起来。
循环体应包含有使循环趋向结束的语句。
下列情况，退出while循环：
条件表达式不成立（为零，为假）
循环体内遇break goto
无线循环（也叫死循环）
while（l）
循环体
2.do……while语句
do-while语句实现“直到当型”循环结构，直到当型表达式为假终止循环。
一般形式：
功能：先执行循环体，然后判断表达式。若为真，则再次执行循环体，否则退出循环。
用do……while语句构成循环，求0到100的和
#include<stdio.h> int main() { int i,sum=0; scanf("%d",&i); do { sum+=i; i++; } while(i<100); printf("%d",sum); }
do-while循环，循环体至少执行一次。
while和do-while可以解决同一问题，两者可以互换。
while后的表达式一开始就为假时，两种循环结果不同。
3.for语句
for语句是C语言中最为灵活，使用最广泛的循环语句，可完全替代while，do-while语句。
一般形式
常用形式
for语句执行过程：
（1）执行表达式1
（2）判断表达式2的逻辑值，真、进入循环体，假、结束循环
（3）执行循环语句
（4）执行表达式3，转向步骤（2）
（5）结束循环
用for语句构成循环，求0到100 的和
#include<stdio.h> int main() { int i, sum=0; for(i=1;i<=100;i++;) { sum+=i; } printf("%d",sum); }
for循环几点说明：
for语句中表达式1、2、3类型任意，都可省略，但分号“；”不能省略。
无线循环：for(;;)不断执行循环体，循环不终止。类似于while（1）
表达式2为假则循环体一次都不执行
for语句可以转换成while结构。
4.循环的嵌套
定义：一个循环体内又包含了另一个完整的循环结构，称为循环的嵌套。
三种嵌套可以互相嵌套，层数不限。
嵌套循环的执行流程。
5.break 和continue语句
break语句
功能：在循环语句和switch语句中，终止并跳出循环体或switch选择结构体
说明：
break只能终止并跳出最近一层的结构。
break不能用于循环语句和switch语句之外的任何其他语句之中。
一般形式：break；
continue语句
功能：结束本次循环，跳出循环体中尚未执行的语句，进行下一次是否执行循环体的判断。
continue语句仅用于循环语句中。
一般形式：continue；
break和continue语句的区别
continue语句只结束本次循环，break语句则是结束整个循环。
continue语句只用于while，do-while,for循环语句中，break语句还可以用于switch语句中。
编程例题：
1.猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第十天早上想再吃时，只剩下一个桃子了。求第一天共摘了多少。
程序分析：采取逆向思维的方法，从后往前推。
int main() { //使用for循环 int total； int day=1;//初始值为倒数第一天 for(total=1;day<10;day++)//一共循环九次，得到第一天所摘的桃 { total=(total+1)*2;//第一天的是第二天加一的二倍 } printf("the total is %d\n",total); return 0; }
2.打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方等于该数本身。例如：153是一个“水仙花数”，因为153=1的三次方+5的三次方+3的三次方。
程序分析：利用for循环控制100-999个数，每个数分解出个位、十位、百位。
int main() { int i, j, k, n;//百位、十位、个位、循环变量。 printf("'water flower' number is:"); for(n=100;n<100;n++) { i=n/100;//分解出百位 j=n/10%10; //分解出十位 k=n%10 //分解出个位 if(n==i*i*i+j*j*j+k*k*k) { printf("%-5d",n); } } printf("\n"); }
第六章 字符型数据
1.字符常量与字符串常量
要用单引号括起来，’ ‘, ‘5’, ‘p’ ,’$’都是有效的字符型值
关于字符型常量说明：
（1）单引号中的大写字母和小写字母代表不同的字符常量，如‘B’和‘b’是不同的字符常量。
（2）单引号中的空格‘ ’也是一个字符常量，但是不能写成‘’。
（3）字符常量只能包含一个字符，因此‘abc’是非法的。
（4）字符常量只能用单引号括起来，不能用双引号括起来。如“a”不是字符常量，而是字符串常量。
（5）小写字母与大写字母的差值是32
（6）在内存占一个字节，可参加整型数据的任何运算。
字符串常量
定义：用一对双引号括起来的一串字符（系统在每个字符串的最后自动加入一个字符‘\0’，作为字符串的结束标志）
可对字符量进行的运算
（1）可以参与任何整数运算
‘B’-‘A’ 66-65=1
‘a’+1 97+1=98
‘9’+10 57+10=67
(2)字符常量可以进行关系运算
如‘a’&&’b’ ‘a'<‘b’
2.字符变量
char ch1=’*’, ch2=’A’, ch3;
从键盘中输入字符型数据：
getchar()
输出字符型数据：
putchar()
例1 getchar()和putchar()
#include<stdio.h> void main() { char a,b; printf("请输入两个字符：\n"); a=getchar(); b=getchar()' putchar(a);
putchar(b);
putchar('\n');
}
第七章 函数
1.函数的概念
函数：一段用于完成特定功能可以重复使用的程序片段
有0个或多个输入
有一个返回值或无返回值
可以多次重复调用
一个大的程序一般应分为若干个程序模块，每个程序模块实现一个特定的功能，这些模块成为子程序，在C语言中子程序用函数实现。
2.库函数
函数库：可重复使用的功能模块，存放函数的仓库
库函数：函数库中的特定函数
C语言标准库：指C语言自身提供的函数库
#include<stdio.h>包含标准输入输出库函数的说明
printf、scanf、getchar、putchar都是这个函数库中的函数，也叫库函数
系统函数库：由系统提供的函数库Windows API还是函数库
第三方函数库：由第三方提供的函数库
如：QT图像函数库、Direct X、自己的库等。
3.函数的定义和返回值
函数定义语法
函数类型 函数名（类型名 形式参数1，类型名 形式参数2，。。。。）
{
说明部分（声明和定义）
执行部分（运算操作）
}
说明：
函数名、形式参数都是用户标识符。函数名必须唯一，形参名在筒体函数内唯一。
不能在函数内部定义函数
函数首部省略了函数返回值类型，默认为int
函数先定义（或声明）后调用
函数可以没有参数
函数体可以为空，{}不能省略，成为空函数
函数类型和形参类型可以是任何类型
说明部分必须在执行部分之前
函数返回值：函数的值通过return语句返回，return表达式；或return（表达式）
使程序从被调函数返回到调用函数中，同时把返回值带给调用函数
int add(int num1, int num2)//求两个整数和 { return num1+num2 }
void say(char* str)//打印一句话 { printf(str); return;//无返回值，可以省略 } //明确指明没有返回值
double divide(int num1,int num2)//两个数相除 { if(num2==0) { printf("除数不能为零\n"); return 0； } return(double)num1/num2 }
4.函数的调用
主调函数：主动去调用其他函数
被调函数：被其他函数所调用
函数调用的一般形式
函数名（实参列表）
说明：实参列表：有确定值的数据或表达式
实参与形参个数相等，类型一致，按顺序一一对应，当有多个实参时，实参间用“，”分隔。
实参表求值顺序，因系统而定（所以不要在实参列表中做计算，如add（a++,b+a））
调用无参函数时，实参列表为空，但（）不能省
函数调用的方式：
指函数在程序中出现的位置，有三种调用方式：
函数语句：以独立的语句去调用函数。不要求有返回值，仅完成一定的操作。
例 printstar();
printf(“hello,world!\n”);
函数表达式：
函数返回一个确定值i，以参加表达式的运算。不可用于void
例 m=max(a,b)*2
函数参数：函数调用作为另一个函数的参数。
例 printf(“%d”,max(a,b)); /*输出大数*/
m=max(a,max(b,c)); /*三数比大小*/
对被调用函数的声明（也叫函数说明）和函数原型
告诉表一起存在这个函数知识在其他地方定义
对被调用函数要求：
必须是已存在的函数
库函数：#include(*.h)
用户自定义函数：如果备点函数定义在主调函数之后，那么在主调函数中（或之前）对被调函数做声明。
未声明调用函数，默认函数类型为int
函数声明：
一般形式：函数类型 函数名（形参类型 形参名，。。。）
或函数类型 函数名（）；
作用：告诉编译系统函数类型、参数个数及类型，以便检验
函数定义与函数声明不同，声明只与函数定义的函数首部相同。声明可以不写形参名，只写形参类型。
函数说明位置：函数的说明部分（函数内或外，函数声明只能在本函数内起作用）
#include<stdio.h> int main() { float add(float x, float y);//对被调用函数的声明 float a,b,c; scanf("%f,%f",&a,&b); c=add(a,b); printf("sum is %f",c); } float add(folat x, float y) { float z; z=x+y; return(z); }
//输入两个整数，求平方和 #include<stdio.h> int squaSum(int x, int y); int main(void) { int num1, num2; scanf("%d%d",&num1,&num2); printf("The result is: %d\n",squaSum(num1, num2)); } int squaSum(int x, int y) { int squa(int m); return(sequ(x)+sequ(y)); } int squa(int m) { return (m*m) }
5.函数间的数据传递
通过实参和形参传递数据（单向传递）
形参：函数定义时的形式参数，用于接收调用时的实参
实参：函数调用时传入函数的实际参数
说明：
形参和实参是两个不同的变量
函数调用只是把实参的值给形参
对形参修改不会影响实参
形参在函数调用时开辟内存，函数结束内存释放
//交换两个数 void swap ( int num1, int num2) { int temp = 0; temp = num1; num1=num2; num2=temp; printf("in swap function num1 =%d\n num2=%d\n",num1,num2); } main() { int num1=3，num2=5; swap(num1, num2); printf("in main function num1 = %d\n""num2=%d\n",num1,num2) ; }
通过return把函数值返回调用函数
说明：
定义函数时的函数类型决定最终函数返回值类型
函数为void类型时，无返回值，即使使用return也是无返回值不能参加运算
return无论返回什么类型的值都会转化为函数的值类型。因此确保return返回的类型和函数类型相同。
通过全局变量
全局变量：不在任何函数中定义的变量，可在整个程序中使用的变量
局部变量：在函数或复合语句定义的变量，只能在它的作用于中使用
int a = 5, d = 18; void say() { printf("say:%d%d\n",a++,d++) ; } void main() { int a = 10, b = 30; printf("%d%d%d\n",a,b,d); say(); { int a = 20 , c = 50; printf("%d%d%d%d\n",a,b,c,d); say(); } printf("%d%d%d\n",a,b,d); }
说明：
局部变量将覆盖全局变量
只能在作用域内使用
嵌套的作用域，小范围作用域的可以使用大范围作用域的变量，大范围作用域不能使用小范围作用域（作用域：变量起作用的范围）
6.函数递归调用
递归：在函数调用过程中，直接或间接的调用自身。
特点：
（1）问题简化后的新问题与原问题解法相同
（2）只是在处理问题的规模上有规律的递增或递减
（3）一个明确的终止条件
//求1到x的平方和 int fun(int x) { int z = 0; if(x>0) { z=x*x; z+=fun(--x); } return z; }
求Fibonacci数列第n个数
定义：第一个数和第二个数字都是1，而后续的每个数字是其前两个数字之和
循环法：
int fibonacci(int n) { int i, t1,t2,temp; t1=t2=1; if((n==1)||(n==2)) { return1; } for(i=3;i<=n;1++) { temp = t1 + t2; t1=t2; t2=temp; } return t2; }
递归法
int Fibonacci(int n) { if(n>2) return Fibonacci(n-1)+Fibonacci(n-2); else return 1; }
第八章 地址和指针
1.变量的地址和指针
变量在内存中的存放方式
如：执行以下说明语句后
int a=3,b=4;
float c=4.5,d=8.6;
char e=’x’,f=’y’;
其内存分配情况如图：
整型变量a,b占四个字节，若a的地址为1010，则b的地址为1010+4=1014；
实型变量c,d占四个字节，若c的地址为1018，则d的地址为1018+4=1022；
字符型变量e,f占一个字节，若e的地址为1026，则f的地址为1027；
注意：一个存储单元的“地址”指的是该存储区域中的第一字节的地址。即变量的地址值得变量存储单元第一个字节的地址。
指针和指针变量
指针：通常把常量的地址叫做指针
指针变量：存放指针的变量叫做指针变量
变量的属性：
(1)变量名
(2)变量值
(3)变量的地址
(4)变量的类型
2.指针变量的定义和指针变量的基类型
A定义指针变量一般形式
基类型 *指针变量名1，*指针变量名2，……；
比如： int *ptr1, int *ptr2; double *ptr3, *ptr4;
基类型、*指针变量说明符、变量名（用户标识符）
注意：int *ptr1, ptr2; //ptr2不是一个指针变量
B指针变量的基类型
指针变量里存放地址所指向的数据类型叫指针的基类型
ptr1、ptr2的基类型是int,ptr3和ptr4的基类型是double
什么样基类型的指针变量，他里面只能存放什么类型的变量地址
3.给指针变量赋值
A给指针变量赋地址
有三种方式给指针变量赋值
用变量的地址、用指针变量、使用malloc和calloc函数
变量的地址：
int *p, k=10; p=&k;
用指针变量：
int *p, k=10; int *q=p;或者（int *q; q=p）
使用mallco和calloc函数：
int *p=(*int)malloc(sizeof(int));
B给指针变量赋“空”值
int *p=NULL;
NULL在stdio.h中预定义为0
#include<stdio.h>或#include“stdio.h”
p=’\0′;或p=0；等价于p=NULL;
访问一个空指针，运行时将发生错误
&和*运算符含义
&取址运算符
含义：取变量的地址
单目运算符
结合性：自右向左
*指针运算符（“间接访问”运算符）
含义：引用指针所指向变量的内容
单目运算符
结合性：自右向左
4.指向指针的指针变量（二级指针）
所存地址为另外一个指针变量的地址
如：
int **pp, *p, k=20; //**pp相当于*（*pp） p=&k; pp=&p; printf("**pp=%d*p=%dk=%d\n",**pp,*P,k);
输出为**pp=20*p=20k=20
5.对指针变量的操作
A通过指针引用一个存储单元
通过（*）间接访问运算符引用一个存储单元，也就是去一个存储单元的值
例子：
int *p, **pp, i=10, j;
p=&i; pp=&p; //指针赋值
j=*p; j=**pp; //取值
j=*&i
*p=100; //i的值将变成100
scanf（“%d%d%d”,&j,p）//给i和j输入值，不是*p也不是&p
j=*p+1 // 与j=*(p+1)不同
*p=*p+1 // *p+=1, ++*p, (*p)++,前面几个等价
但不能是*p++, *&++这几个运算符优先等级是相同的并且从右向左结合。
B移动指针
移动指针：对指针加上或减去一个整数，使其指向相邻前后连续的同类型存储单元。
两个指向连续存储单元的指针相减，得到一个整数，表示他们前后之间相差几个存储单元。
C指针比较
比较结果表示两个指针在指向连续存储单元时相对的前后位置
if(p>q) printf("p高于q指向的位置\n"); else if (p==q) printf("p和q指向相同的位置\n"); else printf("p低于q指向的位置\n");
p=NULL; if (NULL==p) { printf("p是一个空指针\n"); }
6.函数之间地址值的传递
（1）形参为指针变量时实参和形参之间的数据传递
（2）通过传送地址值在被调用函数中直接改变调用函数中的变量的值
（3）函数返回地址值
第九章 数组
1.一维数组的定义和一维数组元素的引用
数组
一组具有相同数据类型且连续存放的变量集合
（1）一组变量
（2）类型相同
（3）连续存放
定义数组
类型名 数组名[整型常量表达式]；
数组名必须是合法标识符
整型常量表达式 表示元素的个数必须是常量
例如：
char str[20];
float num[5];
#define N 5
double n[N];
数组元素的引用
数组名[下标] 通过下标引用数组元素，从而得到数组中的一个变量下标是整型或字符型的常量、变量或表达式
#include<stdio.h> int main() { int num[5], i; num[0]=10; num[1]=num[0]; num[2]=num[1]+num[0]; num[3]=num[2]/3; num[4]=num[3]-num[0]+6; for(i=0; i<5; i++) { printf("num[%d]=%d\n",i , num[i]); } return 0; }
输出：
num[0]=10
num[1]=10
num[2]=20
num[3]=6
num[4]=2
说明：
定义数组的常量表达式必须是大于零的正整数
数组必须先定义，后使用
数组中的元素就是一个变量，代表一个存储单元，可以做普通变量所做的任何运算和操作
只能逐个引用数组元素不能整体引用
引用时不能越界，如num[5]是不存在的。但系统不会做检查，可能破坏其他数据，导致程序运行错误。
数组的初始化（在定义数组时，为数组元素赋初值（在编译阶段使之得到初值））
实现的方法：
在定义数组时对数组元素赋初值。
int a[5]={1,2,3,4,5};
等价于：a[0]=1; a[1]=2; a[2]=3; a[3]=4; a[4]=5;
只给一部分元素赋值。
如：int a[5]={6,2,3};
等价于： a[0]＝6；a[1]=2; a[2]=3; a[3]=0;a[4]=0;
数组元素值全部为0。
int a[5]={0,0,0,0,0}; 或 int a[5]={0};
对整个数组元素赋初值时，可以不指定长度。
int a[]={1,2,3,4,5,6}
编译系统根据初值个数确定数组大小
2.一维数组和指针
一个数组储存在一块连续内存单元中；数组名就是这块连续内存单元的首地址，其值不可变；
第(i+1)个元素的地址可表示为&data[i]或（data+i）
可以通过以下方式为指向数组的指针赋值：int a[10];
pa=&a[0]; //或者 pa=a;
一个指针变量可以指向一个数组元素
int *ptr, data[10];
ptr=data+3; 或者ptr=&data[3]
用带下标的指针变量引用一堆数组元素
（1）s[i]//s是数组名，就是普通数组的表示方法。
（2）*（s+i）//s是数组名，因为系统规定数组名代表的是一堆数组的首地址，所以通过s+i来移动指针，而*（s+i）来代表数组中的某个元素的值。
（3）*（p+i）//p是指针名，指针p已赋值为某个数组的首地址时，通过指针p+i来移动指针向某个元素，那么*（p+i）就是某个数组元素的值
（4）p[i]//指针p已赋值为某个数组的首地址，那么也可以以数组的表示行来代表某个数组的某个元素。
3.函数之间对一维数组和数组元素的引用
1、数组元素作实参
当调用函数时，数组元素可以作为实参传送给形参，每个数组元素实际上代表内存中的一个存储单元，故和普通变量一样，对应的形参必须是类型相同的变量。数组元素的值可以传送给该变量，在函数中只能对该变量进行操作，而不能直接应用对应的数组元素，更不可能在函数中改变对应数组元素中的值。（即形参的改变不会影响实参的值）
2、数组名作实参
数组名也可以作为实参传送，但数组名本身是一个地址值，因此，对应的形参应当是一个指针变量，此指针变量的基类型必须与数组的类型一致。在函数中，可以通过此指针变量来引用调用函数中对应的数组元素，从而达到对调函数中对应的数组元素进行操作而改变其中的值（即形参的改变也会影响实参的值）。
4.二维数组的定义和二维数组元素的引用
（1）二维数组由若干个一维数组组成：在C语言中定义的二维数组实际上是一个一维数组，这个一位数组的每个元素又是一个一维数组，
int *p, a[3][4];
如上定义的a数组，实际上可以看作长度为3的数组，可视a数组由a[0]、a[1]、a[2]三个元素组成，而a[0]、a[1]、a[2]中每个元素又是由四个整型元素组成的一维数组。可用a[0][0]、a[0][1]等来引用a[0]中的每个元素，其他以此类推。
二维数组的引用
形式：数组名[下标][下标]
下标是整型或字符型的常量，变量或表达式。（定义时不能使用变量）
数组元素如普通变量般可出现在表达式中
如：a[1][2]=a[2][2]/2
使用数组元素是，应注意不要超出其定义的范围；
不能引用整个数组或数组的一行
如 int a[2][3]; a=5, a[0]=3这都是错误的
二维数组的初始化
分行初始化
按元素排列顺序初始化
注意：
int a[][]={{1,2},{3,4},{5,6}}; 错误，列下标能省略
int a[2][3]={}; int a[2][3]={{},{}};、{{0}，{}}错误，不能是空列表
int a[2][3]={1};//不是把所有元素都初始为1，而是第一个元素为1 ，其他的默认为0.
int a[2][3]={0},才是把素有元素初始为零
5.二维数组和指针
二维数组和数组元素的首地址
a.二维数组a由若干个一维数组组成
b.二维数组名也是一个地址值常量
c.二维数组元素a[i][j]的地址
(1) &a[i][j]
(2) a[i]+j
(3) *（a+i）+j;
(4) &a[0][0]+4*i+j
(5) a[0]+4*i+j
2.通过建立一个指针数组来引用二维数组元素
int *p[3], a[3][4], i;
for (i=0; i<3; i++) p[i]=a[i];
3.通过建立一个行指针来引用二维数组元素
int a[3][4], (*prt)[4];
4.当二维数组名作实参时，形参是类型相同的行指针变量
第十章 字符串
字符串常量
字符串常量是双引号括起来的任意字符序列
“wang li”
“hello world”
“please enter your full name:”
“hello\”Accp””
字符串与字符数组
在C语言中没有专门的字符串变量，通常用一个字符数组来存放一个字符串
字符数组和字符串的区别是：字符串的末尾有一个空字符‘\0’
字符串可按如下方式生命并初始化：
char name[15]={‘W’,’a’,’n’,’g’,’L’,’i’,’\0′};
char name[15]=”WangLi”;
char password[]=”12345678″;
省略数组大小，系统自动计算，大小为后面的字符总数加1，最后一个元素存入一个空字符。
几种赋值方法
1：char str[10]={‘s’,’t’,’i’,’n’,’L’,’i’,’\0′};
2 : char str1[]={‘s’,’t’,’i’,’n’,’l’,’\0′};
3：char str2[10]={“string”};
4 : char str3[10]=”string”;
5 : char str4[]=”string”;
printf(“(1)%s\n”,str); 对与printf命令来说当输出一个字符串时
printf(“(2)%s\n”,str1); 正常输出内容，遇到结束符‘\0’时就停止
printf(“(3)%s\n”,str2); 输出
printf(“(4)%s\n”,str3);
printf(“(5)%s\n”,str4);
puts(str); puts(str1);
字符串的输入与输出
char name[10];
scanf(“%s”,name);
printf(“%s”,name);
格式描述串中使用转换字符串“%s”
或者利用puts()和gets()函数。
puts函数完全可以由printf函数取代。当需要按一定格式输出时，通常使用printf函数。
字符创示例
#include<stdio.h> void main() { char line[30]; int i, count=0; printf(“\n 请输入一行字符：\n”); gets(line); i=0; while(line[i]='\0') { if(line[i]==' ') count++; i++; } printf("\n 其中的空格总数为%d\n",count); }
字符串处理函数
与字符串有关的内置函数在头文件string.h中定义
要使用标准库字符串处理函数，程序应该包含:
#include<string.h>
string.h
strlen
strcpy
strcmp
strcat
#include<stdio.h> #include<string.h> void main() { char arr[]="Beijing"; int len1, len2; len1 = strlen(arr); len2 = strlen("Shanghai"); priintf("\n string= %s length = %d" ,arr, len1); priintf("\n string= %s length = %d" ,Shanghai, len2); }
#include<stdio.h> #include<string.h> void main() { char source[] = "We change lives"; char target[20]; strcpy(target, source); printf("\n 源字符串 = %s", source); printf("\n 目标字符串 = %s\n", target); }
#include<stdio.h> #include<string.h> void main() { char username[15], pwd[15]; printf("\n请输入用户名： ")； gets(username); printf("\n 请输入密码：”)； gets(pwd); if ((strump(username, "John")==0)&&(strcmp(pwd,"123456")==0)) printf("\n 您已成功登陆\n"); else printf("\n 用户名和/或密码无效\n"); }
#include<stdio.h> #include<string.h> void main() { char source_string[]="is very good"; char target_string[30]="ACCP 4.0"; strcat(target_string, source_string); printf("\n 源字符串 = %s", source_string ); printf（“\n 目标字符串 = %s\n”,target_string）; }
字符指针数组
字符指针数组：一个数组中的各个元素都是字符指针。
char *name[] = {“Apple”, “Pear”, “Peach”, “Banana”}
void main() { char *names[]={"Apple","Banana", "Pineapple", "Peach", "strawberry", "Grapes"}; char *temp; printf("\n %s%s",names[2],names[3]) temp = names[2]; names[2] = names[3]; names[3] = temp; printf("\n%s%s", names[2],names[3]); printf("\n"); }
总结：
字符串与字符数组的区别是字符串的末尾有一个空字符‘\0’以标识字符串结束
用scanf()语句读入字符串时不允许输入中存在空格
gets()和puts()函数分别用于字符串的输入和输出
在string.h中定义了很多字符串处理函数，比较常用的有：strcpy()、strcat()、strcmp()和strlen()
假如程序里需要一组字符串，一种常用的做法就是用一个字符指针数组表示它们
字符串可以作为参数，函数传递机制同数组作为参数，为引用方式。
第十一章 对函数的进一步讨论
11.1 传给main函数的参数
第一种写法：main(int argc, char **){…}
第二种写法：main(int argc, char *argv[]){…}
其中argc和argv是两个参数名，可由用户自己命名，但是它们的类型确实固定的。第一个参数argc必须是帧数
第十二章 标识符的作用域和存储类
11.1 变量的作用域
作用域是某些事物起作用或有效的区域
11.2 变量的作用域
程序中变量也有不同的使用范围，称为变量的作用域。变量的作用域决定变量的可访问性。
void displayDiscount() { float discount_amt; }
局部变量：不能在函数外使用
float discount_amt(); void main() { } void displayDiscount() { }
全局变量：可以在整个程序中使用
11.3局部变量的作用域
#include<stdio.h> void addNumbers() { int num1, num2, sum; printf("\n请输入两个数：")； scanf（“%d%d”,&num1，&num2）; sum=num1+num2; printf("子函数中sum的值是%d\n",sum); } void main() { int sum=0; addNumbers(); printf("\n 主函数中sum的值是%d\n", sum); }
11.4 全局变量的作用域
#include<stdio.h> int sum=0; void addNumbers() { int num1, num2; printf("\n 请输入两个数：")； scanf（“%d%d”, &num1, &num2）; sum=num1+num2; priintf("子函数中sum的值是%d\n",sum); } void main() { addNumbers(); printf("\n 主函数中的sum的值是%d\n",sum); }
若全局变量和某个函数中的局部变量同名，则在该函数中，此全局变量被屏蔽，在该函数内，访问的是局部变量，与同名的全局变量不发生任何关系。
不提倡使用全局变量的原因：
（1）不论是否需要，全局变量在整个程序运行期间都占用内存空间。
（2）全局变量必须在函数以外定义，降低了函数的通用性，影响了函数的独立性。
（3）使用全局变量容易因疏忽或使用不当而导致全局变量中的值意外改变，从而引起副作用，产生难以查找的错误。
11.5 存储类型
变量的存储方式可分为“静态存储”和”动态存储”两种。
静态存储变量是一直存在的，而动态存储变量则时而存在时而消失
这种由于变量存储方式不同而产生的特性称为变量的生存期
生存期表示了变量存在对的时间
11. 6 存储类型
auto 自动变量 局部变量在缺省存储类型的情况下归为自动变量
register 寄存器变量 存放在CPU的寄存器中。对于循环次数较多的循环控制变量及循环体内反复使用的变量均可定义为寄存器变量。
static 静态变量 在程序执行时存在，并且只要整个程序在运行，就可以继续访问该变量。
extern 外部变量 作用域是整个程序，包含该程序的各个文件。生存期非常长，它在该程序运行结束后，才释放内存。
11.7 静态局部变量
静态局部变量作用域与自动变量相同，即只能在定义该变量的函数内使用该变量。
对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。
函数被调用时，其中静态局部变量的值讲保留前次被调用的结果。
void format（） { static int m=0; m++; if(m%10==0) putchar('\n'); else putchar(' '); } void main() { int i; for(i=0;i<0;i++) { printf("%d",i); format(); } }
11.8静态全局变量
静态全局变量与普通全局变量在存储方式上完全相同
区别在于：非静态全局变量的作用域只是整个源程序；而静态全局变量的作用域只是定义它的文件。
第13章 编译预处理和动态存储分配
1.什么是编译预处理：就是在C编译程序对C源程序进行编译前，由编译预处理程序对这些编译预处理命令进行处理的过程
2.预处理命令有：#define #undef #include #if #else等等，本章将重点介绍#define和#include命令行的应用。
3.宏替换：
1.不带参数的宏定义格式如下：
#define 宏名 替换文本
如：#define SIZE 100以上标识符称为“宏名”，是用户定义的标识符，因此，不得与程序中的其它名字相同。在编译时，在此命令行之后，预处理程序对源程序中的其它名字相同。在编译时，此命令行之后，预处理程序对源程序中的所有名为SIZER的标识符用100三个字符来替换，这个替换过程为“宏替换”。但要注意：不能认为“SIZE”等于整数100。
2.替换文本中可以包含已定义过的宏名，例如：
#define PI 3.14
#define ADDPI （PI+1）
#define TWO_ADDPI (2*ADDPI)
main()
{
double x=TWO_ADDPI/2;
printf(“x=%f\n”,x);
}
则替换后，表达式将成为：x=(2*(3.14+1))/2。注意：如果第二行和第三行中的“替换文本”不加括号，直接写成PI+1, 2*ADDPI， 则以上表达式展开后将成为：x=2*3.14+1/2。由此可见，在使用宏定义时一定要考虑到替换后的实际情况，否则很容易出错。
（3）当宏定义在一行中写不下，需要在下一行继续时，只需在最后一个字符后紧接着加一个反斜线\。例如：
#define LEAP_YEAR year%4==0\
&&year%100!=0||year%400==0 如果在\前或在下一行的开头留有许多空格，则在宏替换时也将加入这些空格。
使用宏替换应注意以下几点：
1.宏名一般习惯用大写字母表示，以便与变量名区别，但这并非规定，也可用小写字母。
2.宏定义是用宏名代替一个字符串，也就是作简单的置换，不作正确性检查。如果写成：#define PI 3.i4i59 即把数字写成小写字母i，预处理时也照样代入，不管含义是否正确，也就是说预编译时不作任何语法检查。只有在编译已被展开后的源程序时才会发现错误并报错。
3.宏定义不是C语句，不必在行末加分号。如果加了分号，则会连分号一起进行置换。如：#define PI 3.1415926； area=PI*r*r经过宏展开后，该语句为area=3.1415926；*r*r;//显然出现语法错误。
4.#define命令出现在程序中函数的外面，宏名的有效范围为定义命令 之后在本源文件结束。通常#define命令卸载文件开头，函数之前，作为文件一部分，在此文件范围内有效。
5.可以用#undef命令终止宏定义的作用域。
6.对程序中用双括号括起来的字符串内的字符，即使与宏名相同也不进行置换。例如：printf（“PI=%f\n”）;中的PI就不会被替换是3.1415926
7.宏定义是专门用于预处理命令的一个专用名词，它与定义变量的含义不同，只做字符替换，不分配内存空间。
8.替换文本并不替换用户标识符中的成分。
9.同一个宏名不能重复定义，除非两个宏定义命令行完全一致。
二、带参数的宏定义
带参数的宏定义命令行形式如下：
#define宏名（带形参）替换文本
替换文本包含在括弧中所指定的参数。如下：
#define S（a,b）(a*b)
a=S（3,2）；
b=6/S(a+3,a);
在以上宏定义命令行中，S（a,b）简称为宏，其中S是一个用户标识符，称为宏名，宏名左括号（必须紧挨着，他们之间不得留有空格，其中一对圆括号中由若干称为形参的标识符组成，各形参之间用逗号隔开。）
三、终止宏定义
可以用#undef提前终止宏定义的作用域，例如：
#define PI 3.14
main()
#undef PI 以上PI的作用域从#define PI 3.14 命令行开始，到#undef PI命令行结束。从#undef以后PI变成无定义，不再代表3.14了。
五、动态存储分配
1.什么是动态存储分配：在程序执行期间需要空间来存储数据时，通过“申请”得到指定的内存空间；当有闲置不用的空间时，可以随时将其释放，由系统另做他用。
2.malloc函数和free函数
malloc函数的格式：void * malloc（unsigned size）；
作用：分配size个字节的存储空间。返回值：分配内存空间的地址；如不成功返回0。
free函数的格式：void free（void *p）;
3.calloc函数的格式：void *calloc(unsigned n, unsigned size);
作用：分配n个数据项的内存空间，每个数据项的大小为size个字节。返回值：分配内存单元的起始地址，如不成功则返回零。
第14章 结构体 共用体和用户自定义类型
基本类型
整型、字符型、实型、双精度型和空值型
派生型
指针和数组
用户构造类型
用户定义类型：对已有的类型，另外说明一个新的类型标识符。
结构体：把具有相互关系的不同类型的数据组成一个有机的整体。
共用体：又称联合体，使几种不同类型的变量共用一段存储空间。
typedef 类型 标识符
作用：用“标识符”来代表已存在的“类型名”，并未产生新的类型数据，原有的类型名依然有效；
例如：typrdef int INTEGER;
INTERGER m, n; 等价于 int m, n;
如：typedef char* CHARP;
CHARP p;
免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://yundeesoft.com/29598.html
