专插本C语言简便总结复习

C语言笔记
注意：在C语言中，关键字都是小写的。

C语言简洁、紧凑，使用方便、灵活。

ANSI C一共只有32个关键字:auto break case default char const continue
do while double else enum extern float for goto if int long register return short
signed static sizof struct switch typedef union unsigned void volatile
9种控制语句，程序书写自由,主要用小写字母表示，压缩了一切不必要的成分。

Turbo C扩充了11个关键字：
asm _cs _ds _es _ss cdecl farhuge interrupt near pascal
#define
八进制以0开头，如0123，即(123）8
十六进制以0x开头，如0123，即(123）16
整型：一个正数的补码和其原码形式相同,如10得0000000000001010
一个负数的补码是取-10的绝对值10，对10的二进制形式取反加1，1111111111110101+1=1111111111110110
Signed int unsigned int short long char
float 单精度
double 双精度,long double
％d，％o，％x, ％c，％s，一个整常量后面加一个字母l或L,则认为是long int
main（）// main是主函数的函数名,表示这是一个主函数。

{
printf（”世界,您好！\n”）; //printf函数的功能是把要输出的内容送到显示器去显示}
#include〈math.h〉//include称为文件包含命令
#include〈stdio。

h〉
main（）{
double x，s；//定义两个实数变量,以被后面程序使用
printf（"input number：\n”）; //显示提示信息
scanf("％lf",&x); //从键盘获得一个实数x
s=sin（x）; //求x的正弦，并把它赋给变量s
printf(”sine of ％lf is %lf\n”，x，s）; //显示程序运算结果｝
在本例中，使用了三个库函数：输入函数scanf，正弦函数sin,输出函数printf。

sin函数是数学函数，其头文件为math.h文件
scanf和printf是标准输入输出函数,其头文件为stdio。

h
Ｃ语言规定,源程序中所有用到的变量都必须先说明，后使用
C语言规定对scanf和printf这两个函数可以省去对其头文件的包含命令
由于sin函数要求这两个量必须是双精度浮点型，故用类型说明符double来说明这两个变量
scanf和printf这两个函数都由以下两部分组成:“格式控制串”，参数表
格式控制串是一个字符串,必须用双引号括起来，它表示了输入输出量的数据类型
printf（”sine of ％lf is ％lf\n",x，s);其中％lf为格式字符，表示按双精度浮点数处理。

它在格式串中两次现，对应了x和s两个变量。

其余字符为非格式字符则照原样输出在屏幕上。

在程序的每行后用/＊和＊/括起来的内容为注释部分，程序不执行注释部分.
int max(int a,int b）； /*函数说明＊/
main(）/*主函数＊/
{
int x，y，z； /＊变量说明＊/
int max(int a，int b)； /＊函数说明*/
printf("input two numbers：\n”);
scanf（”%d%d",&x,＆y）；/＊输入x,y值＊/
z=max（x，y); /＊调用max函数*/
printf（”maxmum=%d”，z）； /＊输出＊/
｝
int max(int a，int b）/*定义max函数*/
｛
if（a〉b)return a;
else return b; /＊把结果返回主调函数＊/
｝
从书写清晰，便于阅读，理解，维护的角度出发,在书写程序时应遵循以下规则：
1.一个说明或一个语句占一行。

2。

用｛｝括起来的部分,通常表示了程序的某一层次结构。

｛｝一般与该结构语句的第一个字母对齐，并单独占一行. 3.低一层次的语句或说明可比高一层次的语句或说明缩进若干格后书写。

以便看起来更加清晰，增加程序的可读性。

空白符：
空格符、制表符、换行符等统称为空白符
在Ｃ语言中使用的词汇分为六类：标识符，关键字,运算符，分隔符,常量，注释符等.
1.标识符(在程序中使用的变量名、函数名、标号等统称为标识符)
C 规定，标识符只能是字母（A~Z，a~z)、数字(0~9）、下划线(_)组成的字符串，并且其第一个字符必须是字母或下划线.
(1）标准C不限制标识符的长度,但它受各种版本的C 语言编译系统限制，同时也受到具体机器的限制.
（2)在标识符中，大小写是有区别的。

（3）标识符虽然可由程序员随意定义，但标识符是用于标识某个量的符号。

因此，命名应尽量有相应的意义，以便于阅读理解,作到“顾名思义"。

2。

关键字（关键字是由Ｃ语言规定的具有特定意义的字符串，通常也称为保留字。

用户定义的标识符不应与关键字相同)
(1）类型说明符：如前面例题中用到的int，double等
（2）语句定义符：if else就是条件语句的语句定义符
（3)预处理命令字: include
3。

运算符:
4。

分隔符:在Ｃ语言中采用的分隔符有逗号和空格两种
5。

常量：C 语言中使用的常量可分为数字常量、字符常量、字符串常量、符号常量、转义字符等多种。

6。

注释符：C 语言的注释符是以“/*”开头并以“＊/”结尾的串
＃define PRICE 30 /*#define 定义PRICE代表常量30*/ PRICE是符号常量
习惯上符号常量用大写，变量用写小写
例如：整型变量a和b，可以进行求余运算：a%b （%是求余符号）若指定a和b 为实型变量，则不允许进行”求余”运算。

整型
八进制以0开头的数是八进制.如0123表示八进制123，即（123）8，其值为1X82+2X81+3X80十六进制以0x开头的数是十六进制。

如0x123表示十六进制123，即（123）16,其值为1X162+2X161+3X160
在C编译系统,每一个整型变量在内存中占2个字节。

实际上,数值是以补码表示的。

一个正数的补码和其原码的形式是相同。

而负数的补码是将该值的绝对值的二进制形式,按位取反再加1。

例如:求—10的补码，取—10的绝对值为10，然后10的二进制为1010，
对1010（00000000 00001010）取反，11111111 11110101,一共占16个字节,
再加1为11111111 11110110
整数的16位中，最左面的一位是表示符号，该位为0表示数值为正，该位为1则数值为负
Signed int 有符号—32768—32767
unsigned int 无符号0-65535
short int 短整型long int 长整型。

不一样的微机，位数是不一样的。

整型int
%d ,％0，％x
实型float double
％f
字符型char 一个字符变量在内存中占一个字节
％c
Printf（“％f，％d, %c\n"，a，b，c)；
\ddd : 1到3位8进制数所代表的字符
如：\101（八进制)为65(二进制）的字符"A”
注意:”\0”或”\000"是代表ASCII码为0的控制字符，即"空操作"字符。

它将用在字符串
中。

\xhh ：1到2位16进制数所代表的字符
\n :换行,将当前位置移到下一行开头, ASCII代码为10（十进制)
\t :水平制表（跳到下一个tab位置),制表区占8列,ASCII代码为9（十进制)
\b ：退格，将当前位置移到前一列,ASCII代码为8（十进制）
\r ：回车,将当前位置移到本行开头，ASCII代码为13(十进制）
\f ：换页,将当前位置移到下页开头，ASCII代码为12（十进制）
\\ ：反斜杠字符”\”，ASCII代码为92(十进制）
\’ :单引号（撇号）字符，ASCII代码为39(十进制)
\” :双引号字符，ASCII代码为34(十进制）
字符串常量
‘a’是字符常量（是用一对单引号括起来的)，”a”是字符串常量(是用一对双引号括起来的)
C规定在每一个字符串的结尾加一个"字符串结束标志”，是以字符'\0’作为字符结束标志,从ASCII代码表中可以看到ASCII码为0的字符是”空操作字符”
各类数值型数据间的混合运算
如字符数据必定先转换为整数,short型转换为int型,float型数据在运算时一律先转换成双精度型,即是二个全是float型也要先转换成double型.
Char shortl→int →unsigned→long→double←float
强制类型转换运算符
（double）a 将a转换成double类型
（int）（x+y）将x+y的值转换成整形，如果写成(int）x+y 则只将x转换成int型，然后与y 相加
（float）(5％3）将5％3的值转换成float型
说明：在强制转换时，得到一个所需的类型的中间变量，原来变量的类型未发生变化。

求余“％”运算符要求其两侧均为整型量,float x ，则x%3是不合法,必须(int）x%3
自增自减运算符（只能用于变量，不能用于常理和表达式）
++i是在使用之前先使i的值加(减)1 若j=++i； i=3； printf（“％d\n”，++j）为4
i++ 是在使用之后使i的值加（减)1 若j=i++； i=3；printf(“%d\n”，j++)为3 -i++中,其中—为负号运算和++为同优先级，而结合方向是自右至左,所以相当于—(i++)
(1）控制语句
C语言9种控制语句：
1、if（）～～~～～～else~~～～~~ （条件语句）
2、for（）～～～～~ （循环语句）
3、while(）～～~~～ (循环语句）
4、do~~～`～~while（)～~~～~~ （循环语句）
5、continue （结束本次循环语句）
6、break （中止执行switch或循环语句)
7、switch （多分支选择语句）
8、goto （转向语句）
9、return (从函数返回语句）
上述括号（)表示其中是一个条件,～～～～表示内嵌的语句
例:if(x>y) z=x; else z=y；
(2）函数调用语句： printf(“This is a C statement.\n”）;
（3)表达式语句： a=3；（一个赋值表达式）
（4)空语句：；（即只有一个分号语句）
（5)复合语句｛｝：｛z=x+y; t=z/100； printf（“%f\n"，t）；｝
输入输出函数
＃include 〈stdio。

h〉或“stdio。

h”/*头文件stdio。

h＊/
Scanf（)输入函数 printf()输出函数是系统提供的标准函数
＃include（预编译命令)
Putchar（输出字符）getchar（输入字符）
Printf（格式输出）scanf（格式输入）
Puts（输出字符串）gets(输入字符串)
c语言中include后用引号与尖括号的区别
使用尖括号的话,编译时会先在系统include目录里搜索，如果找不到才会在源代码所在目录搜索；使用双引号则相反，会先在源代码目录里搜索。

这就意味着，当系统里（如/usr/include/里）有一个叫做math。

h的头文件，而你的源代码目录里也有一个你自己写的math。

h头文件,那么使用尖括号时用的就是系统里的；而使用双引号的话则会使用你自己写的那个。

所以建议：使用系统里提供的头文件时使用尖括号使用自己编写的头文件时使用双引号
输出单个字符:
#include <stdio.h>
Main（）
｛ char a,b，c；
a=‘B'； b=‘O’c=‘Y'；
putchar（a）;putchar（b）； putchar（c)；
}
也可以输出转义字符如: putchar(‘\101’)；putchar(‘\’’）；
输入单个字符:
getchar()函数没有参数，其一般形式为getchar（）字符输入函数
＃include 〈stdio.h> main（）
｛ char c;
c=getchar();
putchar（c）；
}
格式输入输出函数
Printf(“%d\n”,x）;
％d么按整型数据的实际长度输出
%md么m为指定的输出字段的宽度,如果数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。

Printf（“%4d,％4d\n”，a，b);若a=123，b=12345
则a输出结果为：空格123 则b输出结果为：12345
%ld么输出长整型数据若long a=1356739;printf（“％9ld”，a)；则a输出结果为:空格空格1356739
％o是以八进制形式输出整数。

％x是以十六进制形式输出整数.
％u 用来输出unsigned型数据,即无符号数,以十进制形式输出.
％c用来输出一个字符。

char a=’w’；printf（“%c”,w)；
％s用来输出一个字符串。

printf（“％s”，”CHINA”);
％ms输出的字符占m列,如字符串本身长度大于m则突破m的限制,全部输出字符串,若串长小于m，则左补空格.
％-ms如果串长小于m则在m列范围内,字符串向左靠，右补空格。

％m。

ns输出占m列，但只取字符串左端n个字符。

这n个字符输出在m列的右端，左补空格.
％—m.ns输出占m列，但只取字符串左端n个字符。

这n个字符输出在m列的左端，右补空格。

n〉m，则m自动取n值，即保证n个字符正常输出。

％f用来输出实数(单精度和双精度），以小数形式输出。

％e以指数形式输出实数,输出数据所占的宽度和数字部分小数位数由系统自动指定给出6位小数，指数部分占5列(如e+002），其中e占一位，指数符号占一位,指数占3位%g用来输出实数，它根据数值大小自动选f格式或e格式.
Scanf输入函数scanf(“％d，%d，％d”，＆a，＆b，＆c)
#include 〈stdio。

h〉
main（)
{ int a，b,c;
scanf（”%d,%d，％d”，&a，＆b，＆c）；/＊输入这三个数的时候”，”逗号也要输的。

＊/
printf（”％d，%d，％d\n"，a，b,c）；
getch()；
}
若：scanf（”%d％d％d”，＆a，＆b，&c);输入a,b,c三个数时，12空格13空格88
Scanf(“％3d%3d”，&a,＆b）;
输入：123456，系统自动把123赋给a，456赋给b
Scanf(“%3c”,＆ch）;
输入:abc，由于ch只能容纳一个字符,系统就把第一个字符’a'赋给ch
如果%后面有一个”＊"附加说明符，表示跳过它指定的列数.
如：scanf（“%2d ％＊3d ％2d"，&a，＆b）；
输入：12空格345空格67回车,将12赋给a,％*3d表示读入3位整数但不赋给任何变量.然后再读入2位整数67赋给b。

第二组数据345被跳过。

在输入数据进，遇以下情况时数据认为结束：
1、遇空格，或按回车或跳格（Ｔab)键；
2、按指定的宽度结束,如“％３d"，只取３列；
3、遇非法输入；
例：输入三角形的三边长,求三角形面积 s=1/2（a+b+c） area=根号s（s-a）（s-b）(s-c）
Float a，b,c,area，s; scanf（“％f，％f，％f",＆a,＆b,&c)；s=1。

0/2*(a+b+c)；Area=sqrt（s*（s—a）*(s-b）*（s—c）)；
Printf(“a=％7。

2f, b=％7。

2f， c=％7。

2f， s=%7。

2f\n"，a,b，c,s）；printf（“area=%7.2f\n”，area)；
If语句
If与else的配对关系：else总是与它上面的最近的if配对.
If与else的数目一样时,采用
If（) main（）
If（）语句1 ｛ int x，y；
Else 语句2 scanf(“％d”，＆x）;
Else if(x<0） y=—1；
If(）语句3 else if（x==0） y=0； else y=1；
Else 语句4 printf（“x=％d，y=％d\n”,x，y)；
If与else的数目不一样时，采用加花括号来确定 getch()；/＊能显示输出＊/
If（) ｝
｛if(）语句1}
Else 语句2
判断某一年是否闰年其中一种方法
main（)
｛
int year,leap；
printf（”input year:”)；
scanf("%d",＆year)；
if(year％4==0)
if(year％100==0）
if（year％400==0） leap=1;
else leap=0；
else leap=1;
else leap=0；
if（leap）printf(”％d yes\n”,year）；
else printf（"%d no year\n”,year)；
getch(）；
}
/＊判断某一年是否闰年另一种方法*/
#include <stdio.h〉
void main（）
｛
int year；
printf（”input year:"）；
scanf（"%d”,&year）;
if((（year%4==0)＆＆（year%100！=0）)｜｜（year％400==0）)printf（”％d yes\n”，year）；
else printf（”%d no year\n”,year)；
getch（)；
｝
条件运算符(三目运算符,自右至左)
main(）
{ int x，y，max；
scanf(”％d，％d",＆x,&y）；
max=(x〉y）？ x:y; /＊如果（a〉b)条件为真，则条件表达式取值a，否则取值b＊/
printf（"％d\n”,max）;
getch(）；/*能显示输出＊/
}
/＊输入一个字符，判断大小写，如果是大写，转换成小写，并输出最后得到的字符＊/
Main(）
｛ char ch；
Scanf（“％c”，&ch)；
If（ch>=‘A’＆＆ ch〈=‘Z') ｛ch=ch+32； printf（“％c\n”，ch）;｝ /*去掉花括号将编译出错*/
/＊ ch=（ch〉=‘A’＆＆ ch〈=‘Z’）？（ch+32）：ch 也可以用条件运算符 */
Else printf（“％c\n”，ch)；
getch（）；/＊能显示输出＊/
｝
Switch 语句是多分支选择语句
Switch（表达式)表达式的值与某一个case后面的常量表达式的值相等时就执行case后面的语句{case 常量表达式1：语句1 ；break；每一个case常量表达式的值必须互不相同
case 常量表达式2：语句2 ;break；执行一个分支后可以用一个break语句来终止switch语句的执行
case 常量表达式3：语句3 ；break；
case 常量表达式n:语句n ；break；
default：语句n+1 ;最后一个分支default可以不加break语句。

}
Case后面包含一个以上执行语句,但可以不必用花括弧括起来，会自动顺序执行本case后面所有的执行语句
Switch(表达式) 表达式的值为A或B或C时都执行同一组语句
case ‘A’：
case ‘B’:
case ‘C’:
case ‘D’：printf（“〉60\n”）；break；
/*求方程的解＊/
#include 〈stdio。

h> /*输入输出函数要调用,也可以不写＊/
#include 〈math.h> /＊用到绝对值函数和开根号函数,所以要调用＊/
main（)
｛
float a，b,c，disc,x1,x2，realpart，imagpart; /*定义类型＊/
scanf(”％f，％f，％f”，＆a，＆b，&c）; /＊输入方程的三个数＊/
printf（”the equation”）； /＊显示the equation,意思是方程*/
if（fabs(a）〈=pow(10，-6)） printf（”is not a quadratic”）； /＊对a求绝对值,判断a=0(fabs （a）〈=le—6))就不是二次方程＊/
else disc=b＊b-4＊a＊c； /＊计算b＊b—4＊a＊c的值是等于还是小于还是大于0＊/
if(fabs（disc)〈=pow（10，—6）） printf(”has two equal roots:％8.4f\n"，—b/（2*a）)；/*has two equal roots是有两个相等的根的意思,这个判断是等于0后有两个相等实根＊/
else if（disc〉pow(10,—6)） /*大于0后有两个不等实根＊/
{x1=（-b+sqrt（disc））/（2＊a）;
x2=（—b—sqrt(disc））/(2＊a)；
printf（”has two equal roots:%8。

4f and ％8。

4f\n”，x1，x2）;
｝
else
｛realpart=—b/(2＊a）； /＊小于0后有两个共轭复根的实部＊/ imagpart=sqrt（—disc）/(2*a）；
printf（”has complex roots:\n")； /*has complex roots是有复杂的根源的意思＊/
printf（"％8。

4f+%8。

4fi\n"，realpart，imagpart);
printf（”%8。

4f-％8。

4fi\n”，realpart,imagpart）；
}
getch（）;
｝
说明：le—6 ：是科学计数法，表示10的—6次方，用函数是pow(10,—6）) 不用0来判断,用一个很小的数就认为disc是0，是为了产生误差，因为实数在计算和存储时会有一些微小的误差。

/＊算运费＊/
＃include 〈stdio.h〉
main（）
{
int c，s；
float f,d，p,w； /＊总运费f（freight货物），基本运费p（price价格），货物重w(weight 重量）,距离s，折扣d（discount)＊/
printf（”input number：\n”）；
scanf（”％f,％f,%d",＆p，＆w，＆s）；
if（s〉=3000） c=12；
else c=s/250;
switch（c）
｛
case 0：d=0；break；
case 1：d=2;break；
case 2:
case 3:d=5；break;
case 4：
case 5:
case 6:
case 7:d=8;break；
case 8：
case 9：
case 10：
case 11：d=10；break；
case 12:d=15;break；
｝
f=p＊w*s*（1—d/100.0）;
printf（”freight=％f\n”，f）；
getch（)；
｝
Goto语句为无条件转向语句，形式： goto 语句标号；语句标号用标识符表示，它的定名规则与变量名相同。

即字母，下划线,数字.
一般来说来两种用途：
1、与if语句一起构成循环结构；
2、从循环体中跳转到循环体外。

但在C语言中可以用break语句和continue语句跳出本层循环和
结束本次循环。

用if语句和goto语句构成循环,求1+2+3+………。

.+99+100
＃include <stdio。

h〉
main（）
｛
int sum=0,i=1;
loop: if（i〈=100）
｛ sum=sum+i；
i++；
goto loop；
}
printf（”sum=％d\n",sum）;
getch(）；
｝
While语句用来实现当型循环结构，一般形式：while（表达式) 语句当表达式非0值时执行while语句中的内嵌语句，先判断表达式后执行语句
/* 用while语句构成循环，求1+2+3+………。

+99+100 */
#include 〈stdio。

h>
main（)
{
int sum=0，i=1；
while（i〈=100)
｛ sum=sum+i；
i++;
｝ /＊如果不加花括弧则while语句的范围只到“sum=sum+i”＊/
printf（”sum=％d\n”，sum);
getch（)；
｝
Do 循环体
While（表达式）
Do—While是循环语句
特点是先执行循环体，然后判断循环条件是否成立
/* 用do—while语句构成循环,求1+2+3+………。

+99+100 ＊/
#include 〈stdio。

h〉
main()
{
int sum=0,i=1;
do
{
sum=sum+i；
i++;
}
while（i〈=100)；
printf(”sum=％d\n”，sum)；
getch();
}
按esc后一个一个显示输出
/* 用do—while语句构成循环，求1+2+3+………。

.+99+100 ＊/
#include <stdio。

h〉
main(）
{
int sum=0，i=1；
do
｛
sum=sum+i;
i++;
printf("sum=%d\n"，sum）；
getch(）；
}
while（i<=100)；
printf（”sum=％d\n”，sum）;
getch(）；
｝
For语句
格式: for(循环变量赋初值；循环条件；循环变量增值；）语句；
表达式1 表达式2 表达式3
先求解表达式1.
再求解表达式2，若值为真，则执行for语句中的内嵌语句，然后就求解表达式3，若为假则结束循环。

1、“表达式1”可以省略 for（；表达式2;表达式3) 语句; /*分号不能少＊/
2、“表达式2”省略即不判断循环条件,循环将无终止地进行下去。

3、“表达式3”也可以省略,如i++不放在“表达式3"，而作为循环体的一部分效果是一样的。

4、全部省略么不赋值，不判断，不增量,无终止地执行循环体。

5、for (i=0;（c=getchar()）!=‘\n'; i+=c;）终端接收一个字符给C，判断表达式的值是否不等于‘\n’（换行符)
for （；(c=getchar（））！=‘\n';）则输入Computer 输出则也是Computer break语句和continue语句
break 是终止整个循环的执行；continue 只是结束本次循环;
if （fabs(a)<=pow(10，—6））的意思是if （a=0）
头文件：＃include <math 。

h 〉 pow(x ，y ）函数是求X y
的值，几的几次方。

Pow(x ，y)函数是计算X y 的值 函数原型：double pow(double x,double y ）
Abs （x)函数是求整数x 的绝对值 函数原型:int abs(int x )
Fabs(x)函数是求双精度实数的绝对值 函数原型：double fabs(double x ）
Sqrt （x ） 函数是开根号子 函数原型:double sqrt(double x ）
摄氏温度C=5/9（F 华氏温度—32）
数组
一维数组 类型说明：数组名[常量表达式］ 如:int a ［10］; 表示数组名为a ，此数组有10个元素. 数组必须先定义后使用。

C 语言规定只能逐个引用数组元素而不能一次引用整个数组。

main （）
｛ int i,a[10］；
for(i=0;i<10;i++） a[i ］=i ；
for(i=9;i 〉=0;i —-) printf(“out number %d\n ”，a ［i ］）; /＊从9到0输出＊/
getch （）；
}
/＊输出数字101到110＊//*输入数字，从此数字后输出10个数＊/
#include 〈stdio.h 〉#include 〈stdio.h 〉
main(）main （）
｛ int i ，t=100，a[10］；｛ int i ，t ，a[10］;
for(i=0;i<=9;i++）printf （"intput number ：”）；
{scanf （"％d”,＆t ）；
t++ ；for(i=0；i 〈=9;i++）
a ［i]=t;{t++ ； a ［i]=t;
printf("out number %d\n”，a[i ］);printf （"out number ％d\n”，a[i]）;
} ｝
getch(）;getch(）；
｝ ｝
一维数组初始化
定义成: int a ［10］={0,1，2，3，4，5，6，7，8，9}；
定义成： int a ［10］=｛0，1，2，3，4，5｝；表示只给前面5个元素赋初值,后面的5个元素值为0
/*后一个数是前二个数之和,Fibonacci 数列＊/
＃include 〈stdio.h〉
main（)
{ int a［20］={1，1}；
int i;
for(i=2；i〈20；i++) a［i]=a［i—2］+a［i—1];
for（i=0；i〈20；i++）
｛ if(i％5==0） printf(“\n”）;
printf（“%12d”，a［i]);
｝
getch（）；
}
＃include 〈stdio.h>
main（）
｛ long int a[30］=｛1，1};
int i；
for（i=2；i〈30；i++) a[i］=a[i—2］+a[i—1]；
for（i=0;i<30；i++）
｛ if（i%5==0) printf（”\n"）；
printf(”%12ld”，a[i］）；
｝
getch（）;
｝
起泡法对10个数排序（由小到大）：将相邻的两个数比较，将小的调到前头。

main（）
｛ int a[11]；
int i，j，t;
printf（“inpuf 10 numers ：\n”）；
for（i=1；i〈11；i++) scanf（“%d”，&a[i］)；
printf（“\n”）；
for（j=1；j〈=9;j++） /*因为10个数，所以要要循环j=10—1次＊/
for（i=1；i〈=10—j；i++） /＊第j趟要进行n-j次两两比较＊/ if（a［i］〉a[i+1]）
{ t=a[i］； a［i］=a[i+1］； a［i+1]=t;}
printf（“the sorted numbers :\n”）;
for（i=1；i<=10;i++） printf（“%d\n”,a［i］）；
getch（）；
｝
二维数组类型说明：数组名［常量表达式]［常量表达式］如：float a［3］［4］;3行4列
C语言对二维数组采用这样的定义，可以把二维数组看作是一种特殊的一维数组：它的元素又是一个一维数组。

可以看作是一个一维数组它有3个元素a［0],a[1］，a［2］每个元素又包含有4个元素的一维数组.
二维数组初始化
int a[3］［4］=｛｛1，2,3,4}，｛5，6，7，8},｛9,10,11，12}｝;
int a[3]［4］=｛1,2,3，4,5，6,7，8，9,10，11,12｝；
a［3］［4]=｛{1｝，{5｝，｛9}｝;只对各行第1列赋值，其余元素值自动为0
/＊将二维数组行和列互换,存到另一个二维数组＊/
＃include "stdio.h”
main（）
｛
int a[2]［3］=｛{1，2,3}，｛4,5,6}};
int b［3］［2］,i,j；
printf（”array a:\n"）; /＊array 阵列＊/
for（i=0;i〈=1；i++) /＊行＊/
｛ for（j=0；j〈=2；j++） /*列＊/
{
printf（”％6d"，a［i］［j］);
b[j］［i］=a［i］［j］； /*赋值给b［j］[i］值＊/
｝
printf(”\n”）；
｝
printf（”array b:\n”）； /＊以下是数组b输出＊/
for(i=0；i〈=2；i++）for（j=0；j<=2；j++）
{ for（j=0；j〈=1;j++） { for（i=0；i〈=1;i++)
printf（”%6d”，b［i］［j］）；printf(”%6d"，b[j][i]);
printf（”\n")；printf（”\n”）;
｝} /*左右两部分输出结果一样的*/
getch（);
｝
/*一个3X4矩阵，求出其中最大值的那个元素的值及所在的行号和列号＊/ ＃include "stdio.h"
main（)
｛
int i，j，row=0,colum=0，max； /＊row 行\排 colum列 */
int a［3］[4］=｛{1,2,3，4},｛9,8，7，6},｛—10，10，-5，2}｝；
max=a[0］［0]；
for(i=0；i〈=2；i++)
for（j=0；j<=3；j++)
if（a[i］［j]>max）｛max=a[i］［j];row=i;colum=j；｝
pritntf（“max=％d，row=%d，colum=％d\n"，max，row,colum);
getch（）；
}
字符数组：用来存放字符数据的数组，一个元素存放一个字符。

初始化 char c［10］；
c［0］=‘I’；c［1]=‘'；c［2］=‘a'；c[3]=‘m’；c［4］=‘’；c［5］=‘h’;c［6]=‘a’；
c[7]=‘p’；c［8]=‘p’；c［9]=‘y’；
字符型与整型是互相通用,所以也可以定义int c［10］; 初始化:char c［10］={‘I’,‘’,‘a’,‘m’，‘’,‘h’，‘a’，‘p’，‘p’，‘y’}；
如果初值个数小于数组长度，将剩下的元素自动定为空字符“\0"
也可以定义二维字符数组
char a［5]［5］={｛‘’，‘',‘'，‘'，‘’}，｛‘’，‘’，‘’，‘'，‘’｝，{‘’,‘’，‘’，‘'，‘’｝,{‘',‘’,‘’,‘’，‘’｝，｛‘’，‘’，‘’，‘',‘'｝｝；单引号中间就是想赋的值
C语言中将字符串作为字符数组来处理。

C语言规定了一个“字符串结束标志”,以字符‘\0'代表。

系统对字符串常量也自动加一个‘\0’作为结束符。

说明：‘\0’代表ASCII码为0的字符，是一个不可以显示的字符，而是一个“空操作字符”
单个字符作初值用单引号，字符串是用双引号。

char c［10]={“China"｝；前面5个元素为‘C'，‘h’,‘i'，‘n’,‘a’，第6个为‘\0'，后4个元素为空字符，所以也是‘\0’
字符数组的输入输出
逐个字符输入输出，用格式符“％C”输入或输出一个字符.
将整个字符串一次输入或输出,用格式符“％s”输入或输出一串字符.
输出字符不包括结束符‘\0’
用“％s”格式符输出字符串时,printf函数中的输出项是字符数组名,而不是数组元素名。

如写成printf（“％s”,c［0］）；是不对的。

应为：printf（“％s"，c）；
定义：char a［13]; Scanf（“％s”，a）;若输入：How are you？回车而只将第一个空格前的“How”送到a中。

注意：scanf函数中输入项是字符数组名.输入项是字符数组名时，不要再加地址符＆，因为在C 语言中数组名代表该数组的起始地址，Scanf(“%s”，＆a);这样的写法是不对的。

printf(“％o”,c)；可以输出数组C的起始地址。

puts（字符数组，输出字符串）
char str[]={“China\nBeijing”｝；
puts(str）；
gets(字符数组，输入字符串)
定义：char str［］；
gets（str）；若输入:Computer回车，将所输入的字符串送给字符数组str，8个字母加一个自动加上去的‘\0’共9个字符送入str。

注意:puts和gets函数只能输入或输出一个字符串.不能写成：puts（str1，str2)或gets（str1,str2）
Strcat(字符数组1，字符数组2)是字符串连接，作用：连接两个字符数组中的字符串，把字符2接到字符1的后面，结果放在字符数组1中.
字符数组1必须足够大，以便容纳连接后的新字符串。

char str1［30］=｛“People’s Republic of”}；
char str2［]=｛“China”｝；
printf(“％s"，strcat(str1，str2）); 输出：People’s Republic of China
strcpy（字符数组1,字符串2) 是字符串复制.作用：将字符串2复制到字符数组1中去。

字符数组1必须足够大,以便容纳被复制的字符串。

字符数组1必须写成数组名形式（如str1）,字符串2可以是字符数组名也可以是一个字符串常量,如strcpy(str1，“China"）; 复制时连同字符串后面的‘\0’一起复制到字符数组1中。

不能用赋值语句将一个字符串常或字符数组直接给一个字符数组.如：str1={“China”}；和str1=str2;都是不合法的。

用赋值语句只能将一个字符赋给一个字符型变量或字符数组元素。

如:char a[5],cl1，cl2； cl1=‘A'；Cl2=‘B’； a［0]=‘C'；a［1］=‘h’；………………………以此类推。

可以用strncpy函数将字符串2中前面若干个字符复制到字符数组1中去。

如:strncpy（str1,str2，2）；
Strcmp（字符串1，字符串2）是字符串比较。

作用：比较字符串1和字符串2。

对两个字符串自左至右逐个字符相比（按ASCII码大小比较）直到出现不同的字符或遇到‘\0’为止
比较结果由函数值带回:
1、如果字符串1=字符串2，函数值为0
2、如果字符串1>字符串2，函数值为正整数
3、如果字符串1〈字符串2，函数值为负整数
注意：对两个字符串比较,不能用以下形式： if（str1= =str2) printf（“yes”);而只能用if（strcmp （str1，str2）==0） printf(“yes”);
/＊输入slzz22222200000正确后显示*/
＃include "stdio。

h"
main（）
{
char str1［］=｛”slzz22222200000"};
char str2［16]；
printf(”input mi ma:\n");
scanf(”%s”，str2)；
if(strcmp(str1，str2）==0) printf（”I LOVE YOU”）；
else printf（"NO NO NO NO NO NO NO NO NO”）；
getch()；
｝
strlen（字符数组)是测字符串长度。

作用：用来测试字符串长度的函数。

函数的值为字符串的实际长度，不包括‘\0'在内。

char str［10]=｛“China"}； printf(“％d"，strlen（str)）；
strlwr(字符串）是字符串小写。

作用:将字符串中大写字母换成小写字母.
/＊将字符串中大写字母换成小写字母＊/
#include ”stdio.h”
main（）
{
char str［16]=｛"China WO ai NI”};
printf(”%s\n”，str）;
printf（"％s"，strlwr(str）)；
getch（）;
strupr(字符串）是字符串大写.作用：将字符串中小写字母换成大写字母。

/*将字符串中小写字母换成大写字母*/
#include ”stdio。

h”
main（)
｛
char str[16]=｛"China W O ai NI”};
printf（”%s\n",str)；
printf("％s”，strupr（str）);
getch()；
｝
/＊输入一行字符，统计有多少个单词，单词之间用空格分隔开＊/
思路：单词数目可以由空格出现的次数决定（连续的若干空格作为出现一次空格;一行开头的空格不统计在内）.
#include "stdio.h"
main（)
｛
char str[81]；
int i，num=0，word=0； /*num为单词数，word=0则表示前一个字符是空格，word=1意味着前一个字符为非空格＊/
char c；
gets（str）； /＊输入字符串*/
for（i=0；(c=str[i])！=’\0’；i++) /*如果是空操作就结束循环，‘\0’是空操作＊/
if（c==’ ’) word=0； /＊空格键的ASCII码值是032（space键)。

如果C为空格，word为0,没有新单词＊/
else if（word==0） /＊C不是空格，条件满足前一个字符是空格，新单词开始，word为1前一个为非空格＊/
｛word=1;
num++； /*单词个数+1*/
}
printf(”There are ％d words in the line。

\n"，num）;
getch（);
｝
当前为空格,未出现单词,使word为0，num不累加；
当前不为空格，前一字符为空格(word=0)，新单词出现，num加1，word=1
当前不为空格，前一字符非空格（word=1），未出现新单词，num不加1
预处理
一》宏定义：
1、不带参数:
＃define 标识符常量表达式
/＊＃define是宏定义命令，宏名（标识符）好习惯用大写＊/
＃define NIL 0x80
可以用#undef NIL命令终止宏定义的作用域.
宏定义定义时可以引用已定义的宏名，可以层层置换
如：＃define R 3。

0
＃define PI 3.1415926
#define L 2＊PI＊R
＃define S PI*R＊R
2、带参数：/*相当于小函数＊/
＃define 宏名（参数表）字符串
/*不仅要时行字符串替换还要进行参数的替换,在宏定义时,宏名与带参数的括弧之间不应该加空格,否则将空格以后的字符串都作为替代字符串的一部分,这可是很容易出错的＊/ 如：＃define SQ（a，b）a＊b
使用：x=12；y=10;area=SQ（x，y);/*则area=12*10=120*/
define金山词霸2009牛津版翻译为确定
宏不存在类型问题,宏名无类型，它的参数也无类型，只是一个符号代表。

调用函数只可得到一个返回值，而宏可以设法得到几个结果。

如＃define PI 3。

1415926
＃define CIRCLE（R，L，S，V）L=2*PI*R;S=PI*R＊R;V=4。

0/3。

0＊PI*R＊R*R
main(）
｛float R,L，S，V；
printf("INPUT SU ZI：\n”);
scanf("％f"，＆R);
CIRCLE(R，L,S，V)；
printf（”R=％6。

2f,L=％6.2f，S=％6。

2f,V=%6.2f\n”，R，L,S，V)；
getch（)；
}
宏替换不占运行时间，只上编译时间。

二》文件包含：
＃include 〈文件名>或＃include ”文件名”
/*在C中用双引用形式更保险，在C51中常用物是尖括弧形式＊/
include金山词霸2009牛津版翻译为包括
用< >尖括号形式时系统到存放C库函数头文件所在的目录中找,这种称为标准方式
一个include 命令只能指定一个被包含文件.
如果文件1包含文件2，而文件2中要用到文件3的内容，则而文件1中要用到两个include命令。

即在文件1中定义：
#include “file3。

h”用双引号么先在用户当前目录中寻找，若找不到再按标准方式 #include “file2.h”
如果file2。

h中有全局静态变量,它也在file1。

c文件中有效，不必用extern声明.
条件编译
条件编译几种形式：
1、＃ifdef 标识符 #ifdef 标识符
程序段1 程序段1
#eles ＃endif
程序段2
#endif
作用：当所指定的标识符已经被＃define命令定义过，则在程序编译阶段只编译程序段1，否则编译程序段2。

其中＃else 部分可以没有。

2、#ifndef 标识符
程序段1
＃eles
程序段2
＃endif
作用：当所指定的标识符未被＃define命令定义过，则在程序编译阶段只编译程序段1，否则编译程序段2
情况和第一种相反。

3、#if 表达式
程序段1
＃eles
程序段2
＃endif
作用:当指定的表达式为真时就编译程序段1，否则编译程序段2.。