二级C语言计算机培训笔记

全国计算机等级等级简介

有两类:水平考试、资格考试

国家计算机考试针对非计算机专业的学生，分四个等级，跨级考试。

C语言属于国家二级。

形式：笔试和机试。100分，考试时间均为90分钟。

国家每年组织考试两次，4月的第一个双休日，9月的倒数第二个双休日。

笔试时间：全国统一，考试当天的早9点。

机试时间：由考点统一安排。

笔试：选择和填空。

选择：70分，填空15空，每空2分。C语言知识占70分，公共基础知识占30分。

机试：填空，3空，每空10分，改错，2处，每错15分，编程，40分。

第一章计算机基础知识

一、计算机的组成

1、一个完整的计算机由硬件和软件两部分组成。

硬件：主机、显示器、键盘、鼠标、音响等。存在的实体。

软件：由程序及其相关文档组成。

主机：

CPU：运算器和控制器，负责计算机整体协同工作；对数据的处理。

内存：ROM、

RAM：随机存储器，当计算机工作时，呈工作状态，当计算机断电后，所有信息清

零。

硬盘：外存。

主板：母板，承载以上各种硬件。

软件：系统软件和应用软件。

系统软件：操作系统(windowsXP)、程序设计语言、编译处理程序、数据库管理

系统等。

应用软件：为解决某一特定问题而开发的软件。

二、存储的相关知识

计算机中的存储器分为两类，外存、内存。

1、存储的单位

计算机能够表示的最小单位：位bitb

计算机表示存储容量的基本单位：字节byteB

1B=8b

1KB=1024B

1MB=1024KB

1GB=1024MB

2、计算机中数的表示方法

计算机内部处理任何数据均采用二进制数。

二进制数：由。和1组成。一个二进制数就是1b,八位二进制数组成一个字节。

十进制数：由。到9组成。

八进制数：由。到7组成。要加前导“0”，而不是字母“o”

十六进制数：由。到9,a——f组成。要加前导“Ox”，x和a——f可大写也可小写。

3、进制转换

十进制与二进制的相互转换

H------：求商取余

二—十：权值相加。

1286432168421

01001001

三、程序设计的相关概念

1、因为计算机只能够处理二进制数，由c语句编写的程序，要经过编译和连接生成

可执行文件，方可运行。

由C语言编写的程序,称为C源程序，后缀.c。经过编译后，生成目标文件，后缀.obj；

经过连接后，生成可执行文件，后缀.exe。

2、算法：为解决某一问题而设计的方法。算法要具备五个特性：

①有穷性：有使程序结束的条件。死循环。

②确定性：对于一个程序，相同的输入要有相同的输出。

③可行性：可行的。

④要。个或多个输入。

⑤必须要有1个或多个输出。

3、描述算法的方法

流程图：一般流程图和N-S流程图。

4、C语言是一种结构化的程序设计语言，有顺序、选择、循环结构来组成。

循环结构分为：当型循环和直到型循环。

当型循环的循环体至少执行。次，直到型循环循环体至少执行1次。

5、C语言是一种模块化的程序设计语言。把一个大的程序分成若干个小程序，再把

小程序再划分为更小的程序，直到每一个小程序只具备一个独立的功能为止。把每一

个小程序叫模块。在C语言中，把模块叫做函数，C语言是由若干个函数组成的。

各个函数之间相对独立，相互平等。

第二章程序设计的基本知识

一、C语言的构成

#include"stdio.h"命令行，必须以#开头，后面跟的双引

号之间的内容叫头文件，它包含程序中

所用到的相关函数。后面不跟分号，它

不是C语句。以#开头的行，叫编译预

处理程序。

main()主函数，一个程序由若干个函数组成，

但一个程序的执行总是从主函数开始，

从主函数结束。主函数后的一对花括号

不可少，其内容是空的。

{inti;由花括号括起来的定义说明部分

i=5;/*是赋值操作*/部分叫函数体，由若执行语句部分

printf("%d\n",i);干语句组成，每个语

)句后面必须跟分号，先定义说明，后

分号不是C语句的执行。

分隔符，它是C语句

的一部分，表示语句

的结束。

/*……*/：注释语句，C语言不执行，必须是成对出现，注释不能嵌套。/*/*……*/*/

二、标识符：给程序中的某些对象所起的名字。

1、命名规则：

①标识符由数字（0-9）、字母（a-z以及A-Z）、下划线（_）组成。

②不能以数字开头。

③严格区分大小写。

④长度一般小于等于8个字符。

例：以下哪些不是合法的标识符。

2：分类

A、关键字：由系统定义其功能，且不能更改的标识符。在C语言中呈蓝色。

B、预定义标识符：由系统预先定义其功能，能够更改的标识符。尽量不要另作它用。

C、用户自定义标识符：由用户根据自己的需要定义的标识符。不能与关键字重名，

可以与预定义标识符重名，但尽量不要重名；必须要符合命名规则。

二、常量：常数，在程序的执行过程中值不会发生改变的量。

三、符号常量：用一个符号代替一个常量。

定义方法：

#define符号代替内容

#definePI3.14

符号常量可以大写也可以小写，一般要求大写。后面不跟分号。

四、变量：在程序的执行过程中，其值可以改变的量，所有变量都必须有一个名字作

为它的标识。（变量名）

变量的实质：代表内存中的某个存储单元。

定义变量的实质：在内存中申请一段存储单元，并起一个名字（变量名）.

使用变量的实质：使用内存中变量名所代表的存储单元。

五、数据：整型数据和实型数据

六、整型数据分整型常量和整型变量

1、整型常量表示方法：8、10、16

2、整型变量的分类：

类型有符号无符号占用字节数

短整型signedshortintunsignedshortint2B(16b)

基本整型signedintunsignedint4B

长整型signedlongintunsignedlongint4B

3、整型数据在内存中的表示方法：

有符号数可以表示正数、负数、0,无符号数可以表示正数、0o

有符号数在计算机中存储时，最高位要用来存储符号位。用0表示正数，用1表示

负数。

short的最大数：01111,11111,11111,132767

+1

1000000000000000

short能够表示的最小数：

10000,00000,00000,0-32768

有符号数在内存中的存储方式：

正整数以原码的形式存储。负整数以补码的形式存放。

补码：将原码取反加1。

50000000000000101

-51111111111111011

如果要将内存中以补码形式存放的二进制数转换成十进制整数：除符号位，取反，转

换成十进制，减1。

1000000000000100-4-1=-5

-111111,11111,11111,1

无符号数：

unsignedshort可以表示的最大数：

11111,11111,11111,165535

有符号数-1和无符号数65535在内存的存储形式完全一样。

4、整型变量的定义方法：

类型名变量名；

inta;表示定义了一个有符号基本整型变量a。实质在内存中申请了四个字节的只能

够存储有符号基本整型的存储空间，并起名为a。

在定义时，同时可以定义多个变量。之间用逗号隔开。

inta,b,c;

七、实型数据分实型常量和实型变量

1、实型常量的表求方法：小数形式和指数形式。

小数形式表示时必须要有小数点。

指数形式表示时：1、用字母e/E后跟一个整数来表示以10为底的幕。

2、字母e之前必须要有数字

3、字母e的前后及数字之间不能有空格。

例：以下哪些是不合法的实型常量。

-23.41.20.00.8e-10.8e0.8e2.6

2、实型变量的分类:

名称类型名字节取值范围有效位数

单精度flaot4B-1038Mo387

双精度double8B-1O308-1O30815-16

八、算术表达式

表达式：用运算符号将运算对象连接起来的式子，在表达式后加一个分号，就构成了

语句。

算术表达式：用算术运算符号将运算对象连接起来的式子。

目数：运算对象所能够连接的运算对象的数目。

优先级：不同的运算符，先算与后算的关系。

结合性：相邻两个运算符，如果优先级相同，从左到右还是从右到左。

1、算术运算符：+-*/%（求余）

+-*/:运算对象可以是整型和实型。

%:运算对象只能是整型。

任何一个表达式都有一个值。表达式的值的类型跟运算对象的类型相同。如果运算符

两边的类型不一致时，必须要进行类型转换，转换规则见附录5.

x%y,如果结果为0,表示x能被y整除，否则，就不能整除。如果xvy,余数为x。

1234/101231234%104

1234/10012123%103

1234/1000112%102

例：如果x是一个四位的整数，分别求出它的个位、十位、百位、千位。

#include"stdio.h"

main()

{inta,b,c,d,x;

scanf("％d”,&x);

a=x%10;

b=x/10%10;

c=x/100%10;

d=x/1000;

printf("a=%d\nb=%d\nc=%d\nd=%d\n",a,b,c,d);

}

2、强制类型转换

使用格式：

(类型名)(表达式)

类型名两边的括号不可少。

(int)3.69取整，不四舍五入。3

八、赋值表达式

赋值运算符：=不是等于(==),是赋予。

当要更改某一变量的值时，用赋值符号，如果要判断两个数的关系，用等于。

a=4将4赋给变量a,实质是将4存放到变量名为a所代表的存储单元中。

注意：1、赋值运算符的左侧只能是变量，右边可以是任意合法的常量、变量、表达

式等。

2、赋值号两边的类型要一致，如果不同，则将右边的类型转换为左边的类型。在实

型转换为整型时，只取整数部分。

3、赋值符号的优先级只高于逗号运算符，结合方向从右到左。

inta;

a=4;

例：如下哪些是不合法的表达式

a=7;a=7+2a=b=3a=b+2=5a-1=7

九、复合赋值运算符：+=号-=*=/=%=

a+=3a=a+3

a*=5+6a=a*(5+6)

例：如果a=7,求下列表达式的值

a-=a+=O

a=7

a-=aa=0

a+=a-=14

a=-7

a=-14

例：将123.456789保留两位小数并四舍五入。

#include"stdio.h"

main()

{floata;

scanf("％f”,&a);

a*=100;

a+=0.5;

a=(int)a;

a/=100;

printf("%g\n'',a);

}

十、自加、自减运算、逗号运算符

自加运算符：++自减运算符：“

自加和自减运算符都是单目运算符，结合方向从右到左。

++a3++--8a—

++a：先将a的值加1,将a的值做为表达式及变量a的值。

a++：先取a的值，做为表达式的值；然后a再加1,做为变量a的值。

逗号表达式：用，将表达式连接起来的式子。逗号表达式优先级最低，结合方向从

左到右，逗号表达式的值是逗号表达式中最后一个表达式的值。

i=2

i++,++i,i+5

y=(i++,i+3,i-)

第三章顺序结构

一、C语句的分类

1＞表达式语句：a+ba+b;

2、控制语句：关键字

①选择语句：if…elseswitch4

②循环语句：whiledo-whilefor5

③转向语句：gotobreakcontinue5

④返回语句：return；7

3、调用函数语句：在函数调用后加分号。

4、空语句：用一个分号来表示。不产生任何动作。

*

9

5、复合语句：用一对花括号将多个语句括起来，语法上形式一条语句。

{t=a;

a=b;

b=t;

}

二、输入输出函数

一个程序的语句在执行时，按顺序，逐条执行，叫顺序结构。

intx,y;

y=3;

x=y+7;

在内存中申请两个整型变量，起名x和y,因为y的值不确定，程序不会生成正确的

结果。

C语句本身没有提供输出输入语句,数据的输入输出是调用系统提供的标准输入输出

函数的实现的。存放在stdio.h头文件中。如果要在程序中使用输入输出函数，那么

必须在程序编译之前加：

#include“stdio.h”<stdio.h>

三、输出函数

调用格式：

printf（“格式控制”,输出项）；

输出项：要输出的对象，有多个输出项，用逗号隔开。

格式控制：是字符串，决定对应的输出项按照何种形式输出。由％和其后面的特定格

式控制符组成。除了以％开头，以特定格式控制符结束之外的字符，原样输出。

特定的格式控制符：

d或i：以十进制有符号基本整型的形式输出对应的输出项。

u：以十进制无符号基本整型的形式输出对应的输出项。

o：以八进制无符号基本整型的形式输出对应的输出项，非要加前导0,在％和。之

间加#。

\n：转义字符，回车换行。

x：以十六进制无符号基本整型的形式输出对应的输出项。非要加前导Ox,在％和乂

之间加#。

f/lf：以小数形式输出实型数。

e/E：以指数形式输出实型数。

g/G：按照最小宽度输出实型数。

P：输出变量在内存中的地址。

c：输出一个字符；‘a'

s：输出一个字符串；“a”

在％和特定格式控制符之间加控制符号：

加整数：表示对应的输出项输出时所占屏幕的宽度，输出项右对齐。如果指定的宽度

小于输出项本身的宽度，无效。

对于实型数，还可以以小数的形式指定输出数据的小数位数。

加+:表示输出项在输出时都带符号（正负号）。

加•：表示输出项左对齐。

加0：表示输出项右对齐，左边的空白位置补0。

加h：表示以短整型输出。

加I：以长整型输出。

四、输入函数

调用格式：

scanf（“格式控制”，输入项地址）；

输入项地址：输入数据在内存中存放的位置。

&：求地址运算符。

格式控制：决定输入数据按照何种形式输入；由％和其后的特定格式控制符组成。除

了以％开头，以特定格式控制符之外的字符，必须原样输入。一般不要求加其它字符。

格式控制：决定输入数据按照何种形式输入；由％和其后的特定格式控制符组成。除

了以％开头，以特定格式控制符之外的字符，必须原样输入。一般不要求加其它字符。

1、特定格式控制符：

d：读入十进制有符号整数

u：读入十进制无符号整数

i：读入整数。十、八、十六（加前导符）

o：读入八

x：读入十六

f/e：以小数/指数形式读入单精度数。

If/le：以小数/指数形式读入双精度数。

c：读入一个字符；

s：读入一个字符串；

2、在％和特定格式控制符之间加控制符号：

加整数：限制数入的数字的个数。

加*:跳过对应的输入的数字。

输入项和格式控制个数相同，类型匹配。当有多个输入项要输入时，可以使用空格、

回车、tab键作为分隔符。当输入的数据不够时，系统等待输入，直到满足为止。

第四章选择结构

根据某一条件的成立与否，决定执行哪一部分语句。

条件有两种表达方式：关系表达式和逻辑表达式。

条件表达式的结果有两个值。真和假，用。表示假，用非0（正数和负数）表示真。

一、关系表达式：的值只有两个，条件为真，结果为1；条件为假，结果为0。

关系运算符：>>=vv===!=

关系运算：比较运算。

关系表达式：

a=3,b=-9

如果a>b,表达式的值为1。

二、逻辑表达式：值只有两个，用。表示假，用1表示真。

逻辑运算符：&&（与，并且）||（或者）！（非，取反）

1、逻辑表达式：

a&&b：当a和b的值都为真时，表达式的结果为1。

a||b：当a和b中有一个为真时，表达式的结果为1。

!a：当a为真，结果为0。

2、逻辑表达式的值。

ab!aa&&ba||b

01101

00100

2-92-3011

90001

3、a=3,b=0求以下表达式的值

(3-2>b++)&&(b->3-3)

例：判断某一年是否为闰年的条件是下列二者之一：

1、年份能被4整除，而不能被100整除，是闰年；

2、年份能被400整除，也是闰年.

写出某一年x是否为闰年的表达式。

(x%4==0&&x%100!=0)||x%400==0

4、逻辑表达式的短路现象

例：当a=1,b=2,c=3,d=4,m=1,n=1时，求以下表达式的值。

0&&(n=c<-d)0

对于&&,当左边的结果为假时，右边不需计算。

1||(n->(c++)+(d-))1

对于II，当左边的结果为真时，右边不需计算。

三、条件运算符构成的条件表达式

条件表达式：

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

执行过程：首先判断表达式1的值，如果为真，将表达式2的值做为整个表达式的

值，如果为假，将表达式3的值做为整个表达式的值。

例：求两数a,b中较大的数。

a>b?a:b

执行过程：首先判断表达式1的值，如果为真，将表达式2的值做

为整个表达式的值，如果为假，将表达式3的值做为整个表达式的

值。

例：求两数a,b中较大的数。

a>b?a:b

a=-14

b=-9

w<x?w:z<y?z:x

四、由if构成的并列语句

使用格式：

if（条件表达式）语句；

注意：1、表达式两边括号不可少，后不跟分号；

2、表达式后只能跟一条语句，如果需要多条语句，使用复合语句

3、执行过程：首先判断表达式的值，如果为真，执行语句；如果

表达式的值为假，结束该语句。

例：输入三个数，按大到小的顺序输出。

#include"stdio.h"

main()

{inta,b,c,t;

scanf(,'%d%d%d",&a,&b,&c);

if(a<b)/*交换7{t=a;a=b;b=t;}

if(a<c)/*交换*/{t=a;a=c;c=t;}

if(b<c)/*交换7{t=b;b=c;c=t;}

printf("%d>%d>%d\n",a,b,c);

}

五、由ifelse构成的选择结构。

使用格式：

if(条件表达式)语句1;

else语句2;

注意：1、表达式两边的括号不可少，表达式后不跟分号；

2、表达式后及else的后面只能跟一条语句；

3、执行过程：首先判断表达式的值，如果为真，执行语句1,结束ifelse语句，如

果为假，执行语句2,结束ifelse语句。

4、一对完整的ifelse语句在语法上是一条语句。

例：有两个数a和b,求出其中的大数。

if(a>b)printf("%d",a);

elseprintf("％d”,b);

六、由ifelse构成的嵌套结构

例：输入一个数，判断它是正数、负数还是0?

#include"stdio.h"

main()

{inta;

scanfC'%d",&a);

if(a>0)printf("%d是正数\n”,a);

else/*表示a不是正数*/

if(a<0)printf("%d是负数\rT,a);

elseprintfC'%d是0\n",a);

}

在ifelse的嵌套语句中，需要注意if和else的搭配关系：就近原则(else总是离

它最近的且没有配对的if搭配)

例：求以下程序的运算结果。

main()

{inta=2,b=-1,c=2;

if(a<b)

if(b<c)c=0;

elseC++;

printf("％d”,c);

}2

main()

{inta=2,b=-1,c=2;

if(a<b);

if(b<c)c=0;

elseC++;

printf("%d",c);

}0

main()

{inta=2,b=-1,c=2;

if(a<b)

{if(b<c)c=0;}

elseC++;

printf("％d”,c);

}3

例：输入一个学生的成绩，根据成绩求出等级。90分以上(含90分)为优，80以

上为良，60分以上为及格，60分以下不及格。

#include"stdio.h"

main()

{intn;

scanf("%cT,&n);

if(n>=90)printf(“优”)；

elseif(n>=80)printf(“良”);

elseif(n>=60)printf(“及格”);

elseprintf("不及格。

七、switch语句构成的选择结构

使用格式：

switch（表达式）5

{case常量1:语句1;

case3:语句2;

case常量3:语句3;

default:语句n;

}

注意：1、表达式的值必须为整数；

2、所有的case子句必须用花括号括起来；

3、case和常量之间必须有空格；case后的常量值应该不同。

4、表达式后不跟分号；

5、执行过程：首先求表达式的值，拿表达式的值与下面的case子句的常量比较，

跟哪个相等，就从哪个常量后的语句开始执行，直到所有语句完成。如果找不到相等

的值，则执行default后的语句，直到所有语句完成。

例：输入一个学生的成绩，计算该生的奖学金。60分以下-50元，60分以上200元,

70分以上500元，80分以上1500元，90分以上3000元，100分5000元。

#include"stdio.h"

main()

{intn;

scanfC'%d",&n);

switch(n/10)

{case10:printf("5000\n");break;

case9:pnntf("3000\n");break;

case8:printf(,'1500\n");break;

case7:printf("500\rr);break;

case6:printf("200\n");break;

default:printfC'-SOXn");

}

)

break：结束当前的switch语句体，执行switch以后的内容。

例：求以下程序的输出结果。

main()

{intx=1,y=0,a=0,b=0;

switch(x)

{case1:switch(y)

{case0:a++;break;

case1:b++;break;

}

case2:a++;b++;break;

}

printf(u%d%d,,,a,b);

第五章循环结构

根据某一条件的成立与否，反复执行一条或多条语句。

一、由goto语句构成的循环

goto：无条件转向。

语句标号：任意合法的标识符，加冒号后可放在任意语句之前。

使用格式：

goto语句标号；表示将程序的执行无条件的转向语句标号所在的行。

例：求1+……+100的和。

main()

{ints=0,i=1;

veer:if(i<=100){s=s+i;i++;gotoveer;}

printf(<ts=%d\n,,,s);

)

二、由while构成的循环结构

使用格式：

while(表达式)循环体；

注意：1、表达式后不跟分号，括号不可少；

2、表达式后只能跟一条语句。

3、执行过程：

首先求表达式的值，如果为真，执行循环体，再次判断表达式，如果为真，继续执行

循环体，直到表达式的值为假时，结束whHe循环。

while循环循环体至少执行。次，属于当型循环。

例：求1+2+……+100的和。

main()

{ints=0,i=1;

while(i<=100){s=s+i;i++;}

printf(us=%d\n,,,s);

}

例：求1*2*3*……*10的值。(求10!)

main()

{ints=1,i=1,n;

scanf("％d”,&n);

while(i<=n){s*=i;i++;}

printf(t<s=%d\n,\s);

}

例：求『+22+……+的的值。

main()

{ints=0,i=1;

while(i<=5){s+=i*i;i++;}

printf(tts=%d\n,,,s);

}

例：求100之间内有偶数的和及平均值。

main()

{inti=2,j=0;

floats=0,avg;

while(i<=100){s+=i;i+=2;j++;}

avg=s/j；

printf(tt%f\n%f\n,,,s,avg);

}

三、由dowhile构成的循环结构

使用格式：

do

循环体；

while(表达式);

注意：1、do后只跟一条语句；

2、表达式后跟分号；

3、执行过程：do

do-while循环体至少执行1次。直到型循环。

例：输入两个整数，求a和b之间所有偶数之和.

#include"stdio.h"

main()

{inta,b,s=0,i;

scanf(,,%d%d,',&a,&b);

do

{if(a%2==0)s+=a;

a++;

}

while(a<=b);

',,

printf(%d\n'Js);

}

四、由for语句构成的循环结构

使用格式：

for（①表达式1;②⑤⑧表达式2;④⑦表达式3）

③⑥循环体；

注意：1、表达式1、2后跟分号,表达式3后不跟分号;

2、循环体只能是一条语句;

3、执行过程：

首先，执行表达式1,然后判断表达式2的

值，如果为真，执行循环体，执行表达式3,

再次判断表达式2的值，直到其值为假，跳

出for循环。

在for循环中，表达式1只执行1次，通常

用来给循环变量赋初值。表达式2是循环条

件，决定是否继续执行循环体，一般使用关

系、逻辑表达式。表达式3通常用来改变循

环变量的值。

在for循环中，表达式1,表达式2,表达式

3均可省略，但分号不能少。

例：求1+……+100的值。

main()

{inti,s=0;

for(i=1;i<=100;i++)

s=s+i;

printf(tts=%d\n,,,s);

}

例：求100-1000之内的所有水仙花数。

水仙花数：某数的个位、十位、百位的立方各等于该数本身。

153

1*1*15*5*53*3*3

1+125+27=153

main()

{inti,a,b,c;

for(i=100;i<1000;i++)

{a=i%10;

b=i/10%10;

c=i/100;

if(a*a*a+b*b*b+c*c*c==i)printf(<t%d,,,i);

}

}

例：输出5000以内的斐波那切数列。每输出5个数，换行。

011235813213455……

#include"stdio.h"

main()

{inta=0,b=1,c,i=0;

while(a+b<1000)

{c=a+b;

printf(“％-5d”,c);

i++；

if(i%5==0)printf(t^\n^^);

a=b;

b=c;

)

}

例：输出斐波那切数列的前20项。

main()

{inta=0,b=1,i;

u,,

printf(%-5d%-5dJa,b);

for(i=1;i<10;i++)

{a=a+b;

b=a+b;

printf(<t%-5d%-5d5,,a,b);

}

}

例：判断某数是否为素数。

素数：只能被1和它本身整除的数。

main()

{intn,i;

scanf("％d”,&n);

for(i=2;i<n;i++)

if(n%i==0)break;

if(i==n)printf(£6%d是素数”,n);

elseprintf(u%d不是素数”,n);

}

例：根据如下公式，求PI的值。

Pl/4=1-1/3+1/5-1/7+1/9...........直到某一项的绝对值小于1为止。

#include"stdio.h"

#include"math.h"

main()

{floati,k=1,t=1,PI=0;

for(i=3;fabs(t)>=1e-8;i+=2)

{PI=PI+t;

k=-k;

t=k/i;

}

PI=PI*4;

printf("PI=%f\n",PI);

}

五、循环的嵌套

whiledo-whilefor

在一个循环体内又包含另一个完整的循环结构。

例：输出2-300以内的所有素数。

#include"stdio.h"

main()

{inti,j;

printf(4<2");

for(j=3;j<300；j+=2)

{for(i=2;i<j;i++)

if(j%i==O)break;

if(i==j)printfC'%-4d",j);

}

}

例：

inti,j,k=O;

for(i=1;i<=4;i++)1234

for(j=1；j<=5；j++)12345

k++;

printf(<<%d,,,k);k=20

例：输出以下图形。

i

6

*

1

21*2*

31*2*3*

for(i=1;i<=6;i++)

{for(j=1；j<=i；j++)

printf("*")；*

printf("\n")；**

)

例：输出以下图形。

6ijj=i*2-1

*

11

***

23

**T****T****T****T****T**35

st*sl^*sl^Stst*

47

st***%L****X**st***«X»*sL****X****X**

**T****T****T****T*"""T"**"Ts*"T""*"T"***T****T****T**

59

#include"stdio.h"

main()

{inti,j,k,n;

scanfC'%d",&n);

for(i=1;i<=n;i++)

{for(k=1;k<=n-i;k++)printf("");

for(j=1;j<=i*2-1;j++)printfC'*");

printf("\n");

}

)

例：输出以下图形。

6

"*X****X****X**"*X**st****X****X****>1****X**

**T****T****T****T****T****T****T****7****T****T****T**1116*2+1-i*2

29

<^r*»

37

***45

*

53

or(i=1;i<=6;i++)

{for(k=1;k<=i-1;k++)print*".");

for(j=1；j<=6*2+1-i*2；j++)printf("*");

printf(u\n5,);

}

例：输出以下图形。

*■>!(**>"T****>!«***S*Tt****»!<■"

*»f-»"«X«*

•*?>**T**

**X"*sl^

***

*

第六章字符型数据

数据：整型、实型、字符型。

字符型数据：字符常量和字符变量。

一、字符常量：用一对单引号将一个字符括起来。

在内存中存储时只占一个字节的存储空间，即8b,存储时只占用后7位，最高位为

0,也就是说，字符型常量只有：27个，即128个。在内存中存储的二进制编码就是

该字符的ASCH码。0-127o

存储时也是以二进制数形式存储。

常用字符的ASCH码：

NULL0

O48

P65

宣97

，，32

\n10

因为每个字符都可以写成整数的形式，只有整数能参加的运算，字符同样可以参加。

对于字符运算时，真正参与运算的是该字符的ASCII码值。

'a'+1=98七'

宣」A=32大写和小写之间相差32。如果要把大写字母转换为小写字母：+32.

5-5='0'

‘5':0'=5如果要将字符型数据转换为整型，需要「0'

二、转义字符常量：用一个\后跟一特定的字符来表示特定的含义。

'\n，：换行。

s\f：相当于tab键，跳至下一个第8位。

，丁：相当于home键，回到行首。

'\b'：向左移动一格。

t\ddd,：在'后跟1-3位八进制数，表示一个字符。

s\xhh5：在\x后跟1-2位十六进制数，表示一个字符。

'\0'：表示空值。ASCH码为0.

V：表示一个单引号

表示一个双引号

'\\'：表示一个\。

例：写出以下程序的执行结果。

printf(“123456781234567812345678\n")；

printf(c<abc\tde\rf\tg\n>,);

printf((th\ti\b\bjk\n")；

例：计算以下字符串中字符的个数。

t(aTs\nO\129O\x41O\\V,

三、字符变量：用来存储字符常量的存储单元。

定义方法：

类型名变量名；

charch;

曲=宣；把字符a赋予字符变量ch.

四、字符串常量

字符串常量用一对双引号将一个或多个字符括起来。

宣：表示一个字符a,占一个字节的存储空间。

“a”：表示一个字符串，占两个字节的存储空间。字符串的结束标志：\0

五、字符的输入输出

1、使用标准输入输出函数

scanf(tt%c",&ch);

字符前一定不能有空格、回车、TABo

printf(u%c,5,ch);

#include"stdio.h"

include"string.h"

main()

{charch;

scanf("%c",&ch);

printf("%c\n%d\n,',ch,ch);

}

2、字符专用输入输出函数

输入函数：

ch=getchar()读入一个字符赋予变量ch.a

输出函数：

putchar(ch)表示输出变量ch中的字符。a

putchar(76);L

putchar('\n');

例：输出ASCII值为32-127及其对应的字符。

main()

{intch;

for(ch=32;ch<=127;ch++)

printf(u%-4d%-4c,5,ch,ch);

)

例：输入一行字符，以@结束。将大小写字母互相转换。

amAL2(*87@

AMal2(*87

#include"stdio.h"

main()

{charch;

while((ch=getchar())!='@')

{if(ch>=,a,&&ch<=,z,)ch=ch-32;/*转换成大写7

elseif(ch>=,A'&&ch<=,Z')ch=ch+32;

putchar(ch);

}

}

例：输入一行字符，以@结束。统计其中小写、大写字母及数字的个数。

askdjALKJSDF39849384kjdfhKJDSAFHQ32894

#include"stdio.h"

main()

{charch;

int

i=j=k=O;acBD1$A&a2@

while((ch=getchar())!='@')

{if(ch>='a,&&ch<='z,)i++;

elseif(ch>=,A'&&ch<=,Z,)j++;

elseif(ch>=,0,&&ch<=,9,)k++;

)

printf(“小写的个数为：％d\n大写的个数为：%d\n数字的个数为：%d\n,,,i,j,k);

)

例：输入一行小写字母，以@结束。把每个字母转换为它后面的第二个字母，把y

转换为a,把z转换为bo

abcdefghijklmnopqrstuvwxyz

cdefghijklmnopqrstuvwxyzab

#include"stdio.h"

main()

{charch;

while((ch=getchar())!=,@')

{if(ch>=,a,&&ch<='x,)ch=ch+2;/*转换成大写7

elseif(ch=='y')ch='a';

elsech='bf;

putchar(ch);

第七章函数

C语言是一种模块化的程序设计语言，一个大的程序可以分成若干个小程序，把小的

程序可以分成更小的程序，直到每一个程序只具备一个独立的功能为止。把每一个小

程序叫模块。在C语言中，把模块叫函数。

也就是说，一个C程序由若干个函数组成。

函数的注意：

1、一个程序由若干个函数组成，但各函数间相互独立，一个函数在定义时和其它函

数没有任何关系。

2、函数中定义的变量只在当前函数中起作用，可以在不同的函数中定义同名变量。

3、不管程序中有多少个函数，主函数有且只有一个。程序的执行从主函数开始，从

主函数结束。

一、函数的分类：

1、库函数：由系统提供，会用即可。

A、在使用系统提供的库函数时，要在程序编译之前指明函数的来源。

输入输出函数：stdio.h#include"stdio.h"

数学函数：math.h

字符函数：ctype.h

字符串函数：string.h

随机数函数：stdlib.h

B、函数的功能

C、函数中参数的类型及个数

D、函数返回值的类型

例：

i=fabs（x）

功能：求实型数的绝对值

二、自定义函数：根据用户自己的需要定义的函数。

定义格式：

函数返回值的类型函数名（形参类型形参名）

（定义部分；

执行部分；

}

注意：

1、函数返回值的类型：函数运算以后结果的类型。一个运行后可以没有返回值，类

型名为void.如果省略函数返回值的类型，则系统默认为into

2、函数名：给所要定义的函数起的一个名字。必须是合法的用户自定义标识符。在

同一个程序中，函数名必须唯一。

3、形参类型和形参名：形参名其实就是一个变量名，形参类型其实就是定义形参名

的类型。

4、返回值：

return;表示结束当前的函数，返回到调用该函数的地方。

return（表达式）；表示结束当前的函数，将表达式的值做为函数的结果返回到调用

函数的地方。在一个函数体内，不管有多少return语名，它只能一次。

5、不能在函数中再定义函数。

三、编写一函数，功能：求x的y次方.

#include"stdio.h"编译预处理命令行

intfun(inta,intb)该函数名称叫fun,返回值的类型为整型，该函数有两个

形参，且都是整型。对于形参名要求要单独定义。

{inti,s=1;

for(i=1;i<=b;i++)

s*=a;

returns;表示将变量s的值做为函数运行的结果，返回到调用该函

数的地方.

)

main()主函数

{intx,y,s;定义三个整型变量

输入两个整型数，分别赋予变量x,y

scanf(,<%d%d,,,&x,&y);

s=fun(x,y);调用名称为fun的函数，在该函数中有两个参数，且都为

整型，调用函数时的参数叫实参。将实参的值赋予对应的

形参，实参和形参的关系：一一对应、个数相同、类型匹

配。形参=实参，形参只能是变量，实参可以任何合法的常

量、变量、表达式等。将实参的值赋予对应的形参，形参

的改变不会影响对应实参的值。只能是单向传递。因为s

是整型，所以函数的返回值也是整型。

printf(<ts=%d\n,,,s);

)

例：编写一函数，功能：交换a,b变量中的数。

#include“stdio.h"

voidfun(inta,intb)

{intt;

t=a;

a=b;

b=t;

u,,

printf(a=%d,b=%dJa,b);

}

main()

{inta,b;

scanf("％d%d”,&a,&b);

printf(tta=%d,b=%d,,,a,b);

fun(a,b);

printf(<ta=%d,b=%d,,,a,b);

)

1、在不同函数中可以定义同名变量，互相独立。

2、函数必须要先定义说明，后使用。

说明格式：

函数返回值的类型函数名(形参类型)；

例：编写一函数，判断某数是否为素数。

intfun(intn)

{inti;

for(i=2;i<n;i++)if(n%i==O)return0;

return1;

}

main()

{intn,i;

scanf("％d”,&n);

if(fun(n))printf(“是素数”)；

elseprintf("不是素数)

)

例：编写一函数，验证某偶数为两素数之和。

#include<stdio.h>

intfun1(intn)

{inti;

for(i=2;i<n;i++)if(n%i==0)return0;

return1;

}

voidfun(intn)

{inti;

for(i=2;i<=n/2;i++)if(fun1(i)&&fun1(n-i))printf(,,%d+%d=%d",i,n-i,n);

main()

{intn;

scanf("%d,',&n);

if(n%2==0)fun(n);

elseprintf("不是偶数”);

}

第八章指针(C语言中的精华)

一、地址和指针的概念

inti;表示定义了一个整型变量i,实质是在内存中申请了一段存放空间，并起名为

io

i=5;表示把5存放到了变量名为i所代表的存储单元中。

在计算机中，表示存储容量的基本单位叫字节。

256MB=268435456B

因为计算机要管理众多的内存资源，它所管理的对象是字节，为为便于管理众多的字

节，给每一个字节编了一个号。所编的号就是该字节在内存中的地址。

地址的实质就是内存中字节的编号。

inti;表示定义了一个整型变量i,实质是在内存中申请了4个字节的存储空间，并

起名为i。其地址为所占存储单元第一个字节的地址。

在访问内存单元时，可以使用变量名来访问，还可以使用该变量在内存中的地址来访

问。把使用变量名访问的方式叫直接访问，使用地址访问的方式叫间接访问。

因为是地址是数据，所以它也要占用存储单元。把用来存放地址的变量叫指针变量,

简称指针。

指针变量中只能存放地址。

二、指针变量的定义方式

inti；表示定义了一个整型变量i,实质是在内存中申请了4个字节的存储空间，

并起名为io并且所申请的存储单元中只能存放整型数。

charch;

类型名*变量名；

int*p;表示定义了一个整型的指针变量p,它的里面只能存放整型变量的地址。

有一个*号，这儿的星号，它只表示后面的变量是指针变量。

char*ch;表示字义了一个字符型的指针变量ch,它的里面只能存放字符型变量

的地址。

三、给指针变量赋值

int*p,i=10;

&：取地址运算符。

&i：取变量i在内存中的地址。

p=&i；表示将变量i的地址存放到指针变量p中。当指针指向某一变量时，它们实际

代表同一个存储单元。

*：间接访问运算符。

*p：取指针变量p中的地址所代表的存储单元的内容。

*(&i)==i完全等价

&和*是互逆的。

int*p,*q,i=10;

P=&i；

q=p；指针变量p,q和变量i代表同一个存储单元。

int**q,*p,i=10;

**q：指向指针的指针变量。

P=&i；

q=&p;表示它们都代表同一个存储单元。

四、指针的移动

指针变量也有类型叫基类型，基本类型。不同的类型所占的字节数不同，指针每移动

一位，所经过的字节数不同。

自加运算符(++)和间接访问运算符(*),它们优先级相同，按从右向左的方向结合。

*p++：首先让指针向右移动一个存储单元，再取其地址所代表的内容。

*++p：先让指针向右移动一个存储单元，再取其地址所代表的内容。

++*p：先取地址所代表的内容，然后加1。

例：

#include"stdio.h"

main()

{inti=10,*p;

P=&i；

printfC'%d%d%d\n,',i,*p,p);/*1010i的地址7

++*P；

printfC'%d%d%d\n",i,*p,p);/*1111i的地址*/

*p++;

printfC,%d%d%d\n,\i,*p,p);/*11不定值i的下一个存储单元的地

址*/}

五、函数间地址值的传递

实参和形参的关系：

形参=实参：形参只能是变量，单向传递，一一对应、个数相同、类型匹配。

当实参为地址时，对应的形参必须是指针。

编写函数，计算a和b的和。

#include"stdio.h"

intfun(int*x,int*y)

return*x+*y;

main()

{inta=9,b=5;

printf(t(%d,5,fun(&a,&b));

}

例：编写一函数，交换两数。

#include"stdio.h"

voidfun(int*a,int*b)

{intt;

t=*a;

*a=*b;

*b=t;

main()

{inta,b;

scanf(,'%d%d",&a,&b);

printf("a=%d,b=%d\n",a,b);

fun(&a,&b);

printf("a=%d,b=%d\n",a,b);

}

六、当指针变量做为函数的返回值类型，函数返回地址值。

例：编写一函数，求出a,b两数中较大的数(函数返回值的类型为指针)

#include"stdio.h"

int*fun(int*p,int*q)

{if(*p>*q)returnp;

returnq;

}

main()

{inta=10,b=96,*p;

p=fun(&a,&b);

printf("％d\n”,*p);

}

第九章数组

第一节一维数组

一、数组的概念

1、位置上是连续的存储单元

2、类型相同

二、一维数组的定义

1、一维数组：只有一个下标的数组。

2、定义方法：

类型名数组名[元素个数];

inta[6];表示定义了一个具有6个元素的一维数组，数组名a。

注意：

1、数组名定义时规则同变量名。

2、在定义数组时，必须要指明该数组中元素的个数。且元素个数必须是整型常量或

整型符号常量。绝不可以是变量。

#defineN10

intn=10,a[n];非法

3、数组中的元素个数为N时，在表示数组元素时，其下标从0开始，到N-1结束。

三、数组中元素的使用

格式：

数组名[下标]

1、下标总是从0开始，到元素个数-1结束。

2、下标可以使用整型常及整型表达式来表示。

inti=6,a[10];

a[i-1]

四、一维数组的赋值

1、在定义时赋初值

inta[5]={5,4,8,2,0}a[0]=5

inta[5]={2,3}赋值时，系统自动按顺序给每个元素赋值，其余的元素系统自动赋

Oo

在赋值，当所赋初值个数少于元素个数时，后面的元素系统自动赋0。

inta[5]={0}

inta[]={4,8,9,6,4}在定义时，如果没有元素个数，系统会根据所赋初值的个数自动

决定元素个数。

2、在程序中赋值

A、使用标准输入函数来赋值。

#include"stdio.h"

main()

{inti,a[10];

for(i=0;i<10;i++)

scanfC'%d",&a[i]);

}

B、使用随机数函数赋值

如果要在程序中使用随机数函数，必须要在程序编译之前加：

#include“stdlib.h"

随机数函数使用格式：

变量名(数组元素)=rand()%取数的范围

#include"stdio.h"

main()

{inti,a[10];

for(i=0;i<10;i++)a[i]=rand()%100;

for(i=0;i<10;i++)printf("%"4d",a[i]);

}

例：定义一50个元素的数组，使用随机数函数赋值，赋值以后输出，求出和值、平

均值、每输出10个元素换行，最后逆序输出(使用两种方法)。

五、一维数组中的地址

一维数组的每一个元素都是一个变量，都有一个地址。数组a中第0个元素的地址

是：&a[0].

int*p,a[5];

P=&a[0];

P+2

因为数组中的每个元素是连续的，所以可以通过移动指针的方法来指向数组中的每一

个元素。

在C语言中，规定数组名代表当前数组在内存中的起始地址，所以说可以用数组名

代表数组的首地址。

int*p,a[5];

P=a；

a代表数组的首地址，数组名永远代表数组的首地址，所以它是一个地址常量，所以

不能对数组名重新赋值。但指针p可以重新赋值。

六、引用数组中元素的方法

int*p,a[5];

p=a;p和a是等价的。

a[i]p[i]*(a+i)*(p+i)

七、一维数组和函数的关系

当地址做为实参时，对应的形参是指针。

当数组名做为实参时，对应的形参是指针。其指针的表示形式有三种：

*PP[]p[N]N：表示指针p所指向的数组的元素个数。

例：编写四个函数，给数组输入50以内的随机数、输出数组中的元素、求出最大数、

求出最小数。

#include"stdio.h"

#include"stdlib.h"

#defineN20

voidinput(int*p)

{inti;

for(i=0;i<N;i++)p[i]=rand()%100