C语言简明教程

2024年2月8日发(作者：)

一、变量

(一)、变量类型和表示方法

1.什么是变量？一句话，变量是存储数据的值的空间。由于数值的类型有多种，有整数、小数（浮点数）、字符等等，那么对应的变量就有整型变量、浮点型变量、字符型变量。变量还有其他的具体分类。整型变量还可具体分为无符号型、长整型和短整型。浮点型也可分为单精度型、双精度型和长双精度型。此外还可以分为静态变量、外部变量、寄存器变量和自动存储变量。这些数据类型我们在本节和后面的章节中都会陆陆续续介绍。

那么变量我们总要给它取个名字吧，这个名字我们叫做标识符。

标识符的命名有一定的规则：

(1).标识符只能由字母、数字和下划线三类字符组成

(2).第一个字符必须是字母（第一个字符也可以是下划线，但被视作系统自定义的标识符）

(3).大写字母和小写字母被认为是两个不同的字符，如A和a是两个不同的标识符

(4).标识符可以任意长，但只有前32位有效。有些旧的C版本对外部标识符的限制为6位。这是由于链接程序的限制所总成的，而不是C语言本身的局限性

(5).标识符不能是C的关键字

2.从上面的规则中，有个关键字的概念。那么什么叫关键字呢？

从表面字意上也可以看出，关键字是C语言本身某些特性的一个表示，是唯一的代表某一个意思的。

下面列出ANSI标准定义的32个C语言的关键字，这些关键字在以后的学习中基本上都会用到，到时再说它们的各自用法。

auto break case char const continue default

do double else enum extern float for

goto if int long register return short

signed sizeof static struct switch typedef

union unsigned void volatile while

C语言还包括一些不能用做标识符的扩展关键字。

asm cdecl _cs _ds _es far

huge interrupt near pascal _ss

所以在以后的学习中，在给变量命名时要避开这些关键字。

3. Turbo C2.0规定所有变量在使用前都必须加以说明。一条变量说明语句由数据类型和其后的一个或多个变量名组成。变量说明的形式如下:

类型 <变量表>;

这里类型是指Turbo C2.0的有效数据类型。变量表是一个或多个标识符名,每个标识符之间用,分隔。

(二)、整型变量

整型变量是用来存储整数的。

整型变量又可具体分为好几种，最基本的整型变量是用类型说明符int声明的符号整型，形式如下：

int Counter;

这里int是类型说明符，Counter是变量的名字。

整型变量可以是有符号型、无符号型、长型、短型或象上面定义的普通符号整型。

整型是16位的，长整型是32位，短整型等价于整型。

以下是几种整型变量的声明示例：

long int Amount; /*长整型*/

long Amount; /*长整型，等价于上面*/

signed int Total; /*有符号整型*/

signed Total; /*有符号整型，等价于上面*/

unsigned int Offset; /*无符号整型*/

unsigned Offset; /*无符号整型，等价于上面*/

short int SmallAmt; /*短整型*/

short SmallAmt; /*短整型，等价于上面*/

unsigned short int Month; /*无符号短整型*/

unsigned short Month; /*无符号短整型，等价于上面*/

从上面的示例可以看出，当定义长整型、短整型、符号整型或无符号整型时，可以省略关键字int。

注明：

1.用signed对整型变量进行有符号指定是多余的，因为除非用unsigned指定为无符号型，否则整型都是有符号的。

2.当一个变量有几重特性时，声明关键字的顺序可以任意。以下几种声明是等价的：

unsigned long T1;

long unsigned T2;

unsigned long int T3;

unsigned int long T4;

long unsigned int T5;

long int unsigned T6;

int unsigned long T7;

int long unsigned T8;

(三)、浮点类型变量

顾名思义，浮点类型变量是用来存储带有小数的实数的。

C语言中有三种不同的浮点类型，以下是对这三种不同类型的声明示例：

float Amount; /*单精度型*/

double BigAmount; /*双精度型*/

long double ReallyBigAmount; /*长双精度型*/

这里Amount,BigAmount,ReallyBigAmount都是变量名。

浮点型都是有符号的。

(四)、字符型变量

字符型变量中所存放的字符是计算机字符集中的字符。对于PC机上运行的C系统，字符型数据用8位单字节的ASCII码表示。程序用类型说明符char来声明字符型变量：

char ch;

这条声明语句声明了一个字符型变量，标识符为ch。当以这种形式声明变量之后，

程序可以在表达式中引用这个变量，关于语句和表达式的知识在后面将会介绍。

字符数据类型事实上是8位的整型数据类型，可以用于数值表达式中，与其他的整型数据同样使用。在这种情况下，字符型变量可以是有符号的，也可以是无符号的。对于无符号的字符型变量可以声明为：

unsigned char ch;

除非声明为无符号型，否则在算术运算和比较运算中，字符型变量一般作为8位有符号整型变量处理。

还有其他的如指针型变量，void型变量，以后再介绍。

二、常量

常量的意思就是不可改变的量，是一个常数。同变量一样，常量也分为整型常量、浮点型常量、字符型常量，还有字符串常量、转义字符常量和地址常量。

(一)、整型常量

整型常量可以是长整型、短整型、有符号型、无符号型。在Tubbo C 2.0里有符号整型常量的范围从-32768到32767，无符号整型的为0到65535；有符号长整型的范围为-2147483648到2147483647。无符号长整型的范围为0到4294967295。短整型同字符型。

可以指定一个整型常量为二进制、八进制或十六进制，如以下语句：

-129, 0x12fe, 0177

常量的前面有符号0x，这个符号表示该常量是十六进制表示。如果前面的符号只有一个字母0，那么表示该常量是八进制。

有时我们在常量的后面加上符号L或者U，来表示该常量是长整型或者无符号整型：

22388L, 0x4efb2L, 40000U

后缀可以是大写，也可以是小写。

(二)、浮点型常量

一个浮点型常量由整数和小数两部分构成，中间用十进制的小数点隔开。有些浮点树非常大或者非常小，用普通方法不容易表示，可以用科学计数法或者指数方法表示。下面是一个实例：

3.1416, 1.234E-30, 2.47E201

注意在C语言中，数的大小也有一定的限制。对于float型浮点数，数的表示范围为-3.402823E38到3.402823E38，其中-1.401298E-45到1.401298E-45不可见。double型浮点型常数的表示范围为-1.79E308到1.79E308，其中-4.94E-324到4.94E-324不可见。

在浮点型常量里我们也可以加上后缀。

FloatNumber=1.6E10F; /*有符号浮点型*/

LongDoubleNumber=3.45L; /*长双精度型*/

后缀可大写也可小写。

说明:

1. 浮点常数只有一种进制(十进制)。

2. 所有浮点常数都被默认为double。

3. 绝对值小于1的浮点数, 其小数点前面的零可以省略。如:0.22可写为.22,

-0.0015E-3可写为-.0015E-3。

4. Turbo C默认格式输出浮点数时, 最多只保留小数点后六位

(三)、字符型常量

字符型常量所表示的值是字符型变量所能包含的值。我们可以用ASCII表达式来表示一个字符型常量，或者用单引号内加反斜杠表示转义字符。

'A', 'x2f', '013';

其中：x表示后面的字符是十六进制数，0表示后面的字符是八进制数。

注意：在Turbo C 2.0中，字符型常量表示数的范围是-128到127，除非你把它声明为unsigned，这样就是0到255。

(四)、字符串常量

字符串常量就是一串字符,用双引号括起来表示。

Hello,World!

nEnter selection:

aError!!!

(五)、转义字符

上面我们见到的x,n,a等等都是叫转义字符，它告诉编译器需要用特殊的方式进行处理。下面给出所有的转义字符和所对应的意义：

转义字符 描述

' 单引号

双引号

反斜杠

0 空字符

0nnn 八进制数

a 声音符

b 退格符

f 换页符

n 换行符

r 回车符

t 水平制表符

v 垂直制表符

x 十六进制符

它们的具体用法我们到讲输出语句时再介绍。

(六)、地址常量

我们前面说的变量是存储数据的空间，它们在内存里都有对应的地址。在C语言里可以用地址常量来引用这些地址，如下：

&Counter, ∑

&是取地址符，作用是取出变量(或者函数)的地址。在后面的输入语句和指针里还会说明。

这一节所讲到的变量和常量知识可以说是在一切程序中都要用到，特别是变量的声明和命名规则。

无论是加减乘除还是大于小于，都需要用到运算符，在C语言中的运算符和我们平时用的基本上都差不多。

运算符包括赋值运算符、算术运算符、逻辑运算符、位逻辑运算符、位移运算符、关系运算符、自增自减运算符。大多数运算符都是二目运算符，即运算符位于两个表达式之间。单目运算符的意思是运算符作用于单个表达式。(具体什么是表达式下一节再说)

一、赋值运算符

赋值语句的作用是把某个常量或变量或表达式的值赋值给另一个变量。符号为„=‟。这里并不是等于的意思，只是赋值，等于用„==‟表示。

注意：赋值语句左边的变量在程序的其他地方必须要声明。

得已赋值的变量我们称为左值，因为它们出现在赋值语句的左边；产生值的表达式我们称为右值，因为她它们出现在赋值语句的右边。常数只能作为右值。

例如：

count=5;

total1=total2=0;

第一个赋值语句大家都能理解。

第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算。这样它先total2=0;然后total1=total2;那么我们这样行不行呢？

(total1=total2)=0;

这样是不可以的，因为先要算括号里面的，这时total1=total2是一个表达式，而赋值语句的左边是不允许表达式存在的。

二、算术运算符

在C语言中有两个单目和五个双目运算符。

符号 功能

+ 单目正

- 单目负

* 乘法

/ 除法

% 取模

+ 加法

- 减法

下面是一些赋值语句的例子， 在赋值运算符右侧的表达式中就使用了上面的算术运算符：

Area=Height*Width;

num=num1+num2/num3-num4;

运算符也有个运算顺序问题，先算乘除再算加减。单目正和单目负最先运算。

取模运算符(%)用于计算两个整数相除所得的余数。例如：

a=7%4;

最终a的结果是3，因为7%4的余数是3。

那么有人要问了，我要想求它们的商怎么办呢？

b=7/4;

这样b就是它们的商了，应该是1。

也许有人就不明白了，7/4应该是1.75，怎么会是1呢？这里需要说明的是，当两个整数相除时，所得到的结果仍然是整数，没有小数部分。要想也得到小数部分，可以这样写7.0/4或者7/4.0，也即把其中一个数变为非整数。

那么怎样由一个实数得到它的整数部分呢？这就需要用强制类型转换了。例如：

a=(int) (7.0/4);

因为7.0/4的值为1.75，如果在前面加上(int)就表示把结果强制转换成整型，这就得到了1。那么思考一下a=(float) (7/4);最终a的结果是多少？

单目减运算符相当于取相反值，若是正值就变为负值，若是负数就变为正值。

单目加运算符没有意义，纯粹是和单目减构成一对用的。

三、逻辑运算符

逻辑运算符是根据表达式的值来返回真值或是假值。其实在C语言中没有所谓的真值和假值，只是认为非0为真值，0为假值。

符号 功能

&& 逻辑与

|| 逻辑或

! 逻辑非

例如：

5!3;

0||-2&&5;

!4;

当表达式进行&&运算时，只要有一个为假，总的表达式就为假，只有当所有都为真时，总的式子才为真。当表达式进行||运算时，只要有一个为真，总的值就为真，只有当所有的都为假时，总的式子才为假。逻辑非(!)运算是把相应的变量数据转换为相应的真/假值。若原先为假，则逻辑非以后为真，若原先为真，则逻辑非以后为假。

还有一点很重要，当一个逻辑表达式的后一部分的取值不会影响整个表达式的值时，后一部分就不会进行运算了。例如：

a=2,b=1;

a||b-1;

因为a=2，为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。

四、关系运算符

关系运算符是对两个表达式进行比较，返回一个真/假值。

符号 功能

> 大于

< 小于

>= 大于等于

<= 小于等于

== 等于

!= 不等于

这些运算符大家都能明白，主要问题就是等于==和赋值=的区别了。

一些刚开始学习C语言的人总是对这两个运算符弄不明白，经常在一些简单问题上出错，自己检查时还找不出来。看下面的代码：

if(Amount=123) ……

很多新人都理解为如果Amount等于123，就怎么样。其实这行代码的意思是先赋值Amount=123，然后判断这个表达式是不是真值，因为结果为123，是真值，那么就做后面的。如果想让当Amount等于123才运行时，应该if(Amount==123) ……

五、自增自减运算符

这是一类特殊的运算符，自增运算符++和自减运算符--对变量的操作结果是增加1和减少1。例如：

--Couter;

Couter--;

++Amount;

Amount++;

看这些例子里，运算符在前面还是在后面对本身的影响都是一样的，都是加1或者减1，但是当把他们作为其他表达式的一部分，两者就有区别了。运算符放在变量前面，那么在运算之前，变量先完成自增或自减运算；如果运算符放在后面，那么自增自减运算是在变量参加表达式的运算后再运算。这样讲可能不太清楚，看下面的例子：

num1=4;

num2=8;

a=++num1;

b=num2++;

a=++num1;这总的来看是一个赋值，把++num1的值赋给a，因为自增运算符在变量的前面，所以num1先自增加1变为5，然后赋值给a，最终a也为5。b=num2++;这是把num2++的值赋给b，因为自增运算符在变量的后面，所以先把num2赋值给b，b应该为8，然后num2自增加1变为9。

那么如果出现这样的情况我们怎么处理呢？

c=num1+++num2;

到底是c=(num1++)+num2;还是c=num1+(++num2);这要根据编译器来决定，不同的编译器可能有不同的结果。所以我们在以后的编程当中，应该尽量避免出现上面复杂的情况。

六、复合赋值运算符

在赋值运算符当中，还有一类C/C++独有的复合赋值运算符。它们实际上是一种缩写形式，使得对变量的改变更为简洁。

Total=Total+3;

乍一看这行代码，似乎有问题，这是不可能成立的。其实还是老样子，'='是赋值不是等于。它的意思是本身的值加3，然后在赋值给本身。为了简化，上面的代码也可以写成：

Total+=3;

复合赋值运算符有下列这些：

符号 功能

+= 加法赋值

-= 减法赋值

*= 乘法赋值

/= 除法赋值

%= 模运算赋值

<<= 左移赋值

>>= 右移赋值

&= 位逻辑与赋值

|= 位逻辑或赋值

^= 位逻辑异或赋值

上面的十个复合赋值运算符中，后面五个我们到以后位运算时再说明。

那么看了上面的复合赋值运算符，有人就会问，到底Total=Total+3;与Total+=3;有没有区别？答案是有的，对于A=A+1，表达式A被计算了两次，对于复合运算符A+=1，表达式A仅计算了一次。一般的来说，这种区别对于程序的运行没有多大影响，但是当表达式作为函数的返回值时，函数就被调用了两次(以后再说明)，而且如果使用普通的赋值运算符，也会加大程序的开销，使效率降低。

七、条件运算符

条件运算符(?:)是C语言中唯一的一个三目运算符，它是对第一个表达式作真/假检测，然后根据结果返回两外两个表达式中的一个。

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

在运算中，首先对第一个表达式进行检验，如果为真，则返回表达式2的值；如果为假，则返回表达式3的值。

例如：

a=(b>0)?b:-b;

当b>0时，a=b；当b不大于0时，a=-b；这就是条件表达式。其实上面的意思就是把b的绝对值赋值给a。

八、逗号运算符

在C语言中，多个表达式可以用逗号分开，其中用逗号分开的表达式的值分别结算，但整个表达式的值是最后一个表达式的值。

假设b=2,c=7,d=5,

a1=(++b,c--,d+3);

a2=++b,c--,d+3;

对于第一行代码，有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式的值，也就是d+3，为8，所以a=8。对于第二行代码，那么也是有三个表达式，这时的三个表达式为a2=++b、c--、d+3,(这是因为赋值运算符比逗号运算符优先级高)所以最终表达式的值虽然也为8，但a2=3。

还有其他的如位逻辑运算符，位移运算符等等，我们等到讲位运算时再说明。

九、优先级和结合性

从上面的逗号运算符那个例子可以看出，这些运算符计算时都有一定的顺序，就好象先要算乘除后算加减一样。优先级和结合性是运算符两个重要的特性，结合性又称为计算顺序，它决定组成表达式的各个部分是否参与计算以及什么时候计算。

下面是C语言中所使用的运算符的优先级和结合性：

优先级 运算符 结合性

(最高) () [] -> . 自左向右

! ~ ++ -- + - * & sizeof 自右向左

* / % 自左向右

+ - 自左向右

<< >> 自左向右

< <= > >= 自左向右

== != 自左向右

& 自左向右

^ 自左向右

| 自左向右

&& 自左向右

|| 自左向右

?: 自右向左

= += -= *= /= %= &= ^= |= <<= >>= 自右向左

(最低) , 自左向右

在该表中，还有一些运算符我们没有介绍，如指针运算符、sizeof运算符、数组运算符[]等等，这些在以后的学习中会陆续说明的。

一、 表达式

前面已经提到过表达式，相信大家对表达式也有了一个初步的认识，它是由常量、变量、运算符组合(到以后讲函数时，函数也可以是组成表达式的元素)，计算以后返回一个结果值。表达式的结束标志是分号(;)，C语言中所有的语句和声明都是用分号结束，在分号出现之前，语句是不完整的。

例如：

1+2;

Counter/3+5;

Height*Width;

表达式本身什么事情都不做，只是返回结果值。在程序不对返回的结果值做任何操作的情况下，返回的结果值不起任何作用，表达式的作用有两点，一个是放在赋值语句的右边，另一个是作为函数的参数(以后再介绍)。

表达式返回的结果值是有类型的。表达式隐含的数据类型取决于组成表达式的变量和常量的类型。因此，表达式的返回值有可能是某种大小的整型，或者是某精度的浮点型，或者是某种指针类型。

这里面就有类型转化的问题了，在前面说整型运算的时候也提到过。类型转化的原则是从低级向高级自动转化(除非人为的加以控制)。计算的转换顺序基本是这样的：

字符型-->整型-->长整型-->浮点型-->单精度型-->双精度型

就是当字符型和整型在一起运算时，结果为整型，如果整型和浮点型在一起运算，所得的结果就是浮点型，如果有双精度型参与运算，那么答案就是双精度型了。

强制转换是这样的，在类型说明符的两边加上括号，就把后面的变量转换成所要的类型了。如：

(int) a;

(float) b;

第一个式子是把a转换成整型，如果原先有小数部分，则舍去。

第二个式子是把b转换成浮点型，如果原先是整数，则在后面补0。

每一个表达式的返回值都具有逻辑特性。如果返回值为非0，则该表达式返回值为真，否则为假。这种逻辑特性可以用在程序流程控制语句中。

有时表达式也不参加运算，如：

if(a||b) …………

5>3?a++:b++;

当a为真时，b就不参加运算了，因为不管b如何，条件总是真。

二、语句

(一)、赋值语句

其实这个问题，在讲赋值运算符的时候已经讲了一些了。

Amount=1+2;

Total=Counter/3+5;

Area=Height*Width;

也许你会发现，这些赋值语句很象代数方程，在某些情况下，我们的确可以这样理解，但有时它们是不一样的。看下面：

Num=Num+1;

这显然不是一个等式。

(二)、用逗号分隔开的声明语句

C语言可大多数语言一样，允许用逗号分隔声明语句中的标识符列表，说明这些运算符是同一变量类型。例如：

float Area,Height,Width;

但有些程序员喜欢把标识符写在不同的行上。如：

float Area,

Height,

Width;

这样写至少有一个好处，就是可以在每个标识符后边加上注释。

在声明变量的时候，也可以直接给变量赋值，这叫做变量的初始化。

如：int a;

a=3;

等价于:

int a=3;

我们也让某些变量初始化，某些不初始化，如：

int a=3,b,c=5;

在进行初始化时，初始化表达式可以是任意的(对全局变量和静态变量有区别)，由于逗号运算符是从左到右运算的，那么看看这样行不行？

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

(三)、标准输入输出语句

Turbo C 2.0标准库提供了两个控制台格式化输入、输出函数scanf();和printf();这两个函数可以在标准输入输出设备上以各种不同的格式读写数据。scanf() 函数用来从标准输入设备(键盘)上读数据，printf()函数用来向标准输出设备(屏幕)写数据。下面详细介绍这两个函数的用法。

1.标准输入语句

scanf()函数是格式化输入函数, 它从标准输入设备(键盘) 读取输入的信息。其调用格式为:

scanf(<格式化字符串>, <地址表>);

格式化字符串包括以下三类不同的字符;

(1).空白字符:空白字符会使scanf()函数在读操作中略去输入中的一个或多个空白字符。

(2).非空白字符:一个非空白字符会使scanf()函数在读入时剔除掉与这个非空白字符相同的字符。

(3).格式化说明符:以%开始,后跟一个或几个规定字符,用来确定输出内容格式。

Turbo C 2.0提供的输入格式化规定符如下:

━━━━━━━━━━━━━━━━━━━━━━━━━━

符号 作用

──────────────────────────

%d 十进制有符号整数

%u 十进制无符号整数

%f 浮点数

%s 字符串

%c 单个字符

%p 指针的值

%x,%X 无符号以十六进制表示的整数

%o 无符号以八进制表示的整数

━━━━━━━━━━━━━━━━━━━━━━━━━━

地址表是需要读入的所有变量的地址,而不是变量本身，取地址符为'&'。各个变量的地址之间同,分开。

例如：

scanf(%d,%d,&i,&j);

上例中的scanf()函数先读一个整型数,然后把接着输入的逗号剔除掉,最后读入另一个整型数。如果,这一特定字符没有找到,scanf()函数就终止。若参数之间的分隔符为空格,则参数之间必须输入一个或多个空格。

说明:

(a).对于各个变量，类型说明符是什么，输入格式化说明符就应该用对应的类型。否则会出现程序错误或输入数据和理想的不一样。

(b).对于字符串数组或字符串指针变量,由于数组名和指针变量名本身就是地址,因此使用scanf()函数时,不需要在它们前面加上&操作符。

char *p,str[20];

scanf(%s, p);

scanf(%s, str);

具体字符串，指针的知识以后再介绍。

(c).可以在格式化字符串中的%各格式化规定符之间加入一个整数,表示任何读操作中的最大位数。

如上例中若规定只能输入10字符给字符串指针p,则第一条scanf()函数语句变为:

scanf(%10s, p);

程序运行时一旦输入字符个数大于10, p就不再继续读入。

实际使用scanf()函数时存在一个问题, 下面举例进行说明:

当使用多个scanf()函数连续给多个字符变量输入时, 例如:

char c1, c2;

scanf(%c, &c1);

scanf(%c, &c2);

运行该程序,输入一个字符A后回车(要完成输入必须回车),在执行scanf(%c,&c1)时,给变量c1赋值A,但回车符仍然留在缓冲区内,执行输入语句scanf(%c,&c2)时,变量c2输出的是一空行,如果输入AB后回车,那么实际存入变量里的结果为c1为A，c2为B。

要解决以上问题, 可以在输入函数前加入清除函数fflush();(这个函数的使用方法将在本节最后讲述)。

(d).当在格式说明符之间加入'*'时，表示跳过输入，例如：

scanf(%3*d,&a);

当输入12345的时候，前面三个字符跳过去不考虑，最终变量a的值为45。

2.标准输出语句

printf()函数是格式化输出函数,一般用于向标准输出设备按规定格式输出信息。在编写程序时经常会用到此函数。printf()函数的调用格式为:

printf(<格式化字符串>, <参量表>);

其中格式化字符串包括两部分内容:一部分是正常字符,

这些字符将按原样输出;另一部分是格式化规定字符,以%开始,后跟一个或几个规定字符,用来确定输出内容格式。

参量表是需要输出的一系列参数,其个数必须与格式化字符串所说明的输出参数个数一样多,各参数之间用,分开,且顺序一一对应,否则将会出现意想不到的错误。

对于输出语句，还有两个格式化说明符

符号 作用

%e 指数形式的浮点数

%g 自动选择合适的表示法

说明:

(1).可以在%和字母之间插进数字表示最大场宽。

例如: %3d 表示输出3位整型数,不够3位右对齐。

%9.2f 表示输出场宽为9的浮点数,其中小数位为2,整数位为6,小数点占一位,不够9位右对齐。

%8s 表示输出8个字符的字符串,不够8个字符右对齐。

如果字符串的长度、或整型数位数超过说明的场宽,将按其实际长度输出。但对浮点数,若整数部分位数超过了说明的整数位宽度,将按实际整数位输出;若小数部分位数超过了说明的小数位宽度,则按说明的宽度以四舍五入输出。

另外,若想在输出值前加一些0, 就应在场宽项前加个0。

例如: %04d 表示在输出一个小于4位的数值时,将在前面补0使其总宽度为4位。

如果用浮点数表示字符或整型量的输出格式,小数点后的数字代表最大宽度,小数点前的数字代表最小宽度。

例如: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9,则第9个字符以后的内容将被删除。

(2). 可以在%和字母之间加小写字母l,表示输出的是长型数。

例如: %ld 表示输出long整数

%lf 表示输出double浮点数

(3). 可以控制输出左对齐或右对齐，即在%和字母之间加入一个- 号可说明输出为左对齐,否则为右对齐。

例如: %-7d 表示输出7位整数左对齐

%-10s 表示输出10个字符左对齐

一些特殊规定字符(可以参照前面说的转义字符)

━━━━━━━━━━━━━━━━━━━━━━━━━━

字符 作用

──────────────────────────

n 换行

f 清屏并换页

r 回车

t Tab符

xhh 表示一个ASCII码用16进表示

━━━━━━━━━━━━━━━━━━━━━━━━━━

由本节所学的printf()函数, 并结合上一节学习的数据类型, 看下面的语句,加深对Turbo C 2.0数据类型的了解。

char c;

int a=1234;

float f=3.9;

double x=0.654321;

c='x41';

printf(a=%dn, a); /*结果输出十进制整数a=1234*/

printf(a=%6dn, a); /*结果输出6位十进制数a= 1234*/

printf(a=%06dn, a); /*结果输出6位十进制数a=001234*/

printf(a=%2dn, a); /*a超过2位, 按实际值输出a=1234*/

printf(f=%fn, f); /*输出浮点数f=3.141593*/

printf(f=6.4fn, f); /*输出6位其中小数点后4位的浮点数f=3.1416*/

printf(x=%lfn, x); /*输出长浮点数x=0.123457*/

printf(x=%18.16lfn,x); /*输出18位其中小数点后16位的长浮点数x=0.65432*/

printf(c=%cn, c); /*输出字符c=A*/

printf(c=%xn, c); /*输出字符的ASCII码值c=41*/

上面结果中的地址值在不同计算机上可能不同。

当然还有一些输入输出函数，这个以后用到时慢慢再介绍。

前面几节介绍了常量和变量、运算符、表达式和语句的概念，对它们的使用有了一个大概的了解。也许刚学程序的人会觉得有些枯燥，下面我们就来编写第一个C语言程序。

#define PI 3.1416

main()

{

float Radius,Area;

scanf(%f,&Radius); /*输入半径的值*/

Area=PI*Radius*Radius;

printf(%fn,Area); /*输出圆的面积*/

}

1.一个C语言程序，通常由带有#号的编译预处理语句开始。关于预处理我们在以后介绍，这里的#define PI 3.1415926相当于PI代表3.1416，下面在程序中遇到PI，我们就用3.1416替代一下。在以后的程序中，在学习预处理之前，我们都将不使用预处理语句。

() 任何一个完整的程序都需要main()，这是一个函数，具体什么是函数，以后再讲，这儿你就要记住就行。后面有一对{}把所有的语句都括在里面，表明那些语句都属于main()里面。程序运行时从这个左大括号开始。

3.{}里面的4行语句大家应该都能明白，先定义两个变量，一个代表半径，一个代表面积，然后输入半径的值，然后求面积，最后在屏幕上输出面积。程序到main()的那对{}的右大括号结束。求面积的语句Area=PI*Radius*Radius;相当于Area=3.1416*Radius*Radius;(完全用3.1416替代PI)。

具体程序从编写到运行得到结果的步骤为：

1.双击，进入Turbo C 2.0编译界面

+E 进入编辑模式

3.书写程序

4.F2 存储程序(也可进入File菜单，选择save),第一次存储需要写上程序名称(*.C)，回车

+F9 编译，如果有错误和警告，光标停留在错误行，回车进行修改，修改后，回到4;没有错，下一步

+F9 连接和运行程序

7.用ALT+F5查看程序运行结果，任意键返回程序

如何打开一个已有的C文件：

1.双击，进入Turbo C 2.0编译界面

2.F3 进入load状态，找到所要打开文件的目录，找到文件，回车;后面都一样。

具体的有哪些快捷键及其它们的作用，请查看第一节概述。

说明：

1.必须在程序的最开始部分定义所有用到的变量，例如这里的Area,Radius。

2.变量的命名要尽量有意义，如用代表该意思的英文单词、或者是汉语拼音，例如这里的Radius,Area，绝对禁止用毫无干系的字母，如a,b,c。例如下面的程序，虽然意思和上面的一样，但是看上去意思不明朗，时间长了，很可能忘记程序本身的意思。对于仅仅是控制程序运行，不代表实际意思时，可以用一些简单字母。

main()

{

float a,b;

scanf(%f,&a);

b=3.1416*a*a;

printf(%fn,b);

}

3.采用层次书写程序的格式，要有合理的缩进，必要的时候要有空行，一行只书写一个语句。所有语句尽量不分行，除非太长(分行时变量、运算符，格式字符等等不能拆开)，例如下面两个程序看起来就不好看了，虽然它们的功能和前面是一样的。

main()

{float Radius,Area;scanf(%f,&Radius);

Area=3.1416*Radius*Radius;printf(%fn,Area);}

main()

{

float Radius,Area;

scanf(%f,

%Radius);

Area=3.1416*Radius

*Radius;

printf(%fn,

Area);

}

4.程序在适当的地方要用/*……*/注释，它的意思表示在/* */里面的所有字符都不参加编译。因为一个较大的程序，经过一段时间，有些地方可能连编程者都忘记了，增加注释可以帮助恢复记忆，调试程序时，也容易找出错误。注释也可以分行写。

5.在书写{}时要对齐。虽然不对应也不影响程序运行，但对齐后方便以后检查程序，也是为了美观，特别是后面学到流程控制时，{}一定要对齐。

程序设计方法：

1.从问题的全局出发，写出一个概括性的抽象的描述。

2.定义变量，选取函数，确定算法。算法这个东西不好说，遇到的问题多了，自然就会形成自己一整套的算法。

3.按照解决问题的顺序把语句和函数在main()里面堆砌起来。

一个好的C程序员应该做到：

1.在运行程序之前存盘

2.所有在程序中用到的常量都用预处理语句在程序开头定义

3.所有在程序中用到的函数都在程序开头声明

4.头文件的#ifndef

5.变量名和函数名使用有意思的英文单词或汉语拼音

6.尽量少用全局变量或不用全局变量

7.采用层次的书写程序格式，对for,while,if_else,do_while,switch_case等控制语句或他们的多重嵌套，采用缩格结构

8.所有对应的{}都对齐

9.尽量用for，而不用while做记数循环

10.尽量不用goto语句

11.一个函数不宜处理太多的功能，保持函数的小型化，功能单一化

12.一个函数要保持自己的独立性，如同黑匣子一样，单进单出

13.函数的返回类型不要省略

14.用malloc()分配内存空间时，以后一定要用free()释放

15.打开文件后，记住在退出程序前要关闭

16.出错情况的处理

17.写上必要的注释

这里说的是一些基本的，经常遇到的情况，还有其他很多要注意的地方，在实际编程中都会遇到.

一个表达式的返回值都可以用来判断真假，除非没有任何返回值的void型和返回无法判断真假的结构。当表达式的值不等于0时，它就是“真”，否则就是假。一样个表达式可以包含其他表达式和运算符，并且基于整个表达式的运算结果可以得到一个真/假的条件值。因此，当一个表达式在程序中被用于检验其真/假的值时，就称为一个条件。

一、if语句

if(表达式) 语句1;

如果表达式的值为非0，则执行语句1，否则跳过语句继续执行下面的语句。

如果语句1有多于一条语句要执行时, 必须使用{和} 把这些语句包括在其中, 此时条件语句形式为:

if(表达式)

{

语句体1;

}

例如：

if(x>=0) y=x;

if(a||b&&c)

{

z=a+b;

c+=z;

}

二、if--else语句

除了可以指定在条件为真时执行某些语句外，还可以在条件为假时执行另外一段代码。在C语句中利用else语句来达到这个木的。

if(表达式) 语句1;

else 语句2;

同样，当语句1或语句2是多于一个语句时，需要用{}把语句括起来。

例如：

if(x>=0) y=x;

else y=-x;

三、if--else if--else结构。

if(表达式1)

语句1;

else if(表达式2)

语句2;

else if(表达式3)

语句3;

.

.

.

else

语句n;

这种结构是从上到下逐个对条件进行判断,一旦发现条件满点足就执行与它有关的语句, 并跳过其它剩余阶梯;若没有一个条件满足,则执行最后一个else 语句n。最后这个else常起着缺省条件的作用。同样,如果每一个条件中有多于一条语句要执行时,必须使用{和}把这些语句包括在其中。

条件语句可以嵌套,这种情况经常碰到,但条件嵌套语句容易出错,其原因主要是不知道哪个if对应哪个else。

例如:

if(x>20||x<-10)

if(y<=100&&y>x)

printf(Good);

else

printf(Bad);

对于上述情况, Turbo C2.0规定: else语句与最近的一个if语句匹配, 上例中的else与if(y<=100&&y>x)相匹配。为了使else与if(x>20||x<-10)相匹配, 必须用花括号。如下所示:

if(x>20||x<-10)

{

if(y<=100&&y>x)

printf(Good);

}

else

printf(Bad);

下面举几个例子：

1.输入一个数,如果大于0，输出plus;如果是负数，输出negative;如果正好是0，则输出zero。

main()

{

float num;

scanf(%f,&f);

if(num>0)

printf(plusn);

else if(num<0)

printf(negativen);

else

printf(zeron);

}

先定义两个变量，然后输入一个数，然后判断这个数的范围，输出对应的字符串。

2.输入一个数x,输出y。其中y是x的绝对值。

main()

{

float x,y;

scanf(%f,&x);

if(x>=0) y=x;

else y=-x;

printf(%fn,y);

}

程序比较简单，这儿就不分析了。

其实Trubo C 2.0把一些常用的功能都写好了，我们只需要使用就可。例如求绝对值的功能在C的库里面就有。看下面的：

#include math.h

main()

{

float x,y;

scanf(%f,&x);

y=fabs(x); /*求x的绝对值，然后赋值给y*/

printf(%fn,y);

}

这个程序和上面的程序完成的功能是一模一样的，都是求绝对值。可以看出，用下面这个方法比上面就要好一些。由于fabs()是一个函数，系统自带的，所以在使用它的时候，我们必须把它所在的库文件math.h包含都程序中，即程序最前面一行。类似的还有求开方sqrt()，求指数幂exp()等等，这些与数学方面有关的函数都在math.h里面。具体哪些有哪些没有，在什么库里面，可以查看一些手册。

3.输入x，输出y，x和y满足关系：

x<-5 y=x;

-5<=x<1 y=2*x+5;

1<=x<4 y=x+6;

x>=4 y=3*x-2;

程序如下：

main()

{

float x,y;

scanf(%f,&x);

if(x<-5)

y=x;

else if(-5<=x&&x<1)

y=2*x+5;

else if(1<=x&&x<4)

y=x+6;

else

y=3*x-2;

printf(%fn,y);

}

这里要说明两点：

(1).-5<=x&&x<1不能写成-5<=x<1;1<=x&&x<4也不能写成1<=x<4;在C语言中，不能认识连续不等式。

(2).y=2*x+5不能写成y=2x+5;y=3*x-2也不能写成y=3x-2;这与我们平时所写的方法不一样。

4.输入三个数x,y,z,然后按从大到小输出。

main()

{

float x,y,z;

scanf(%f%f%f,&x,&y,&z);

if(x>=y&&x>=z)

{

printf(%ft,x);

if(y>=z) printf(%ft%fn,y,z);

else printf(%ft%fn,z,y);

}

else if(y>=x&&y>=z)

{

printf(%ft,y);

if(x>=z) printf(%ft%fn,x,z);

else printf(%ft%fn,z,x);

}

else

{

printf(%ft,z);

if(x>=y) printf(%ft%fn,x,y);

else printf(%ft%fn,y,x);

}

}

说明：这是一个典型的if语句嵌套结构，如果不使用括号，那么if和else的对应关系就乱了。

四、switch--case语句

在编写程序时, 经常会碰到按不同情况分转的多路问题, 这时可用嵌套if -else-if语

句来实现, 但if-else-if语句使用不方便, 并且容易出错。对这种情况, Turbo C2.0提供了一个开关语句。开关语句格式为:

switch(变量)

{

case 常量1:

语句1或空;

case 常量2:

语句2或空;

.

.

.

case 常量n:

语句n或空;

default:

语句n+1或空;

}

执行switch开关语句时,将变量逐个与case后的常量进行比较,若与其中一个相等,则执行该常量下的语句,若不与任何一个常量相等,则执行default后面的语句。

注意:

中变量可以是数值，也可以是字符，但必须是整数。

2.可以省略一些case和default。

3.每个case或default后的语句可以是语句体,但不需要使用{和}括起来。

例如：

main()

{

int x,y;

scanf(%d,&x);

witch(x)

{

case 1:

y=x+1;

break; /*退出开关语句,遇到break才退出*/

case 4:

y=2*x+1;

break;

default:

y=x--;

break;

}

printf(%dn,y);

}

从上面的例子可以看出，用开关语句编的程序一定可以用if语句做。那么在什么情况下需要用switch语句呢？一般在出现比较整的情况下或者能转化成比较整数的情况下使用。看下面的例子：

例子：一个学生的成绩分成五等，超过90分的为'A'，80-89的为'B'，70-79为'C'，60-69为'D'，60分以下为'E'。现在输入一个学生的成绩，输出他的等级。

(1).用if语句

main()

{

float num;

char grade;

scanf(%d,&num);

if(num>=90) grade='A';

else if(num>=80&&num<89) grade='B';

else if(num>=70&&num<79) grade='C';

else if(num>=60&&num<69) grade='D';

else grade='E';

printf(%c,grade);

}

(2).用switch语句

main()

{

int num;

char grade;

scanf(%d,&num);

num/=10;

switch(num)

{

case 10:

case 9:

grade='A';

break;

case 8:

grade='B';

break;

case 7:

grade='C';

break;

case 6:

grade='D';

break;

default:

grade='E';

break;

}

printf(%c,grade);

}

说明一点，并不是每个case里面有都语句，有时侯里面是空的，就好象这一题。switch语句执行的顺序是从第一case判断，如果正确就往下执行，直到break；如果不正确，就执行下一个case。所以在这里，当成绩是100分时，执行case 10:然后往下执行，grade='A';break;退出。

想想看，这里为什么要用num/=10;？

假设当程序中有浮点数时怎么办呢？

Turbo C 2.0提供三种基本的循环语句: for语句、while语句和do-while语句。

一、循环语句

(一)、for循环 它的一般形式为:

for(<初始化>;<条件表过式>;<增量>)

语句;

初始化总是一个赋值语句，它用来给循环控制变量赋初值；条件表达式是一个关系表达式，它决定什么时候退出循环；增量定义循环控制变量每循环一次后按什么方式变化。这三个部分之间用;分开。

例如:

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

语句;

上例中先给i赋初值1，判断i是否小于等于10，若是则执行语句，之后值增加1。再重新判断，直到条件为假，即i>10时，结束循环。

注意:

(1).for循环中语句可以为语句体,但要用{和}将参加循环的语句括起来。

(2).for循环中的初始化、条件表达式和增量都是选择项，即可以缺省，但;不能缺省。省略了初始化，表示不对循环控制变量赋初值。省略了条件表达式，则不做其它处理时便成为死循环。省略了增量，则不对循环控制变量进行操作，这时可在语句体中加入修改循环控制变量的语句。

(3).for循环可以有多层嵌套。

例如：

for(;;) 语句;

for(i=1;;i+=2) 语句;

for(j=5;;) 语句;

这些for循环语句都是正确的。

main()

{

int i,j;

printf(i jn);

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

for(j=0;j<3;j++)

printf(%d %dn,i,j);

}

输出结果为:

i j

0 0

0 1

0 2

1 0

1 1

1 2

用for循环求1+2+……+100的和：

main()

{

int sn=0,i;

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

sn+=i; /*1+2+……+100*/

printf(%dn,sn);

}

从程序可以看出，使用循环语句可以大大简化代码。

(二)、while循环 它的一般形式为:

while(条件)

语句;

while循环表示当条件为真时，便执行语句。直到条件为假才结束循环。并继续执行循环程序外的后续语句。

例如：

#include stdio.h

main()

{

char c;

c='0'; /*初始化c*/

while(c!='n') /*回车结束循环*/

c=getche(); /*带回显的从键盘接收字符*/

}

上例中，while循环是以检查c是否为回车符开始，因其事先被初始化为空，所以条件为真，进入循环等待键盘输入字符；一旦输入回车，则c='n'，条件为假，循环便告结束。与for循环一样，while循环总是在循环的头部检验条件，这就意味着循环可能什么也不执行就退出。

注意:

(1).在while循环体内也允许空语句。

例如:

while((c=getche())!='n');

这个循环直到键入回车为止。

(2).可以有多层循环嵌套。

(3).语句可以是语句体, 此时必须用{和}括起来。

用while循环求1+2+……+100的和：

main()

{

int sn=0,i=0;

while(++i<=100)

sn+=i; /*求1+2+……+100*/

printf(%dn,sn);

}

(三)、do--while循环 它的一般格式为:

do

{

语句块;

}

while(条件);

这个循环与while循环的不同在于:它先执行循环中的语句,然后再判断条件是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while循环至少要执行一次循环语句。

同样当有许多语句参加循环时，要用{和}把它们括起来。

用do--while循环求1+2+……+100的和：

main()

{

int sn=0,i=1;

do

sn+=i; /*求1+2+……+100*/

while(++i<=100);

printf(%dn,sn);

}

从上面三个程序看出，使用for，while和do--while求解同样的问题，基本思路都差不多，只是在第一次计算时，注意初值。

二、循环控制

(一)、break语句

break语句通常用在循环语句和开关语句中。当break用于开关语句switch中时，可使程序跳出switch而执行switch以后的语句；如果没有break语句，则将成为一个死循环而无法退出。break在switch中的用法已在前面介绍开关语句时的例子中碰到，这里不再举例。

当break语句用于do-while、for、while循环语句中时，可使程序终止循环而执行循环后面的语句，通常break语句总是与if语句联在一起。即满足条件时便跳出循环。

例如：

main()

{

int sn=0,i;

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

{

if(i==51) break; /*如果i等于51，则跳出循环*/

sn+=i; /*1+2+……+50*/

}

printf(%dn,sn);

}

可以看出，最终的结果是1+2+……+50。因为在i等于51的时候，就跳出循环了。自己写写怎样在while和do--while循环中增加break语句。

注意:

1. break语句对if-else的条件语句不起作用。

2. 在多层循环中，一个break语句只向外跳一层。

例如：

main()

{

int i,j;

printf(i jn);

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

for(j=0;j<3;j++)

{

if(j==2) break;

printf(%d %dn,i,j);

}

}

输出结果为:

i j

0 0

0 1

1 0

1 1

当i==0,j==2时，执行break语句，跳出到外层的循环，i变为1。

(二)、continue语句

continue语句的作用是跳过循环本中剩余的语句而强行执行下一次循环。

continue语句只用在for、while、do-while等循环体中, 常与if条件语句一起使用，用来加速循环。

例如：

main()

{

int sn=0,i;

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

{

if(i==51) continue; /*如果i等于51，则结束本次循环*/

sn+=i; /*1+2+……+50+52+……+100*/

}

printf(%dn,sn);

}

从程序中可以看出，continue语句只是当前的值没有执行，也就是说当前的值跳过去了，接着执行下次循环。

main()

{

int i,j;

printf(i jn);

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

for(j=0;j<3;j++)

{

if(j==1) continue;

printf(%d %dn,i,j);

}

}

输出结果为:

i j

0 0

0 2

1 0

1 2

(三)、goto语句

goto语句是一种无条件转移语句，与BASIC中的goto语句相似。goto语句的使用格式为:

goto 标号;

其中标号是Turbo C 2.0中一个有效的标识符，这个标识符加上一个:一起出现在函数内某处，执行goto语句后，程序将跳转到该标号处并执行其后的语句。标号既然是一个标识符，也就要满足标识符的命名规则。另外标号必须与goto语句同处于一个函数中，但可以不在一个循环层中。通常goto语句与if条件语句连用，当满足某一条件时，程序跳到标号处运行。goto语句通常不用，主要因为它将使程序层次不清，且不易读，但在多层嵌套退出时，用goto语句则比较合理。

main()

{

int sn=0,i;

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

{

if(i==51) goto loop; /*如果i等于51，则跳出循环*/

sn+=i; /*1+2+……+50*/

}

loop: ;

printf(%dn,sn);

}

可以看出，这儿的goto语句和break作用很类似。

这儿的loop: ;

printf(%dn,sn);

也可以写成loop: printf(%dn,sn);

main()

{

int sn=0,i;

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

{

if(i==51) goto loop; /*如果i等于51，则跳出本次循环*/

sn+=i; /*1+2+……+50+52+……+100*/

loop: ;

}

printf(%dn,sn);

}

可以看出这儿的loop语句和continue的作用类似。

但是某些情况下又必须使用goto语句，否则会让程序大大臃肿。如：

main()

{

int i,j,k;

printf(i j kn);

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

for(j=0;j<3;j++)

for(k=0;k<3;k++)

{

if(k==2) goto loop;

printf(%d %d %dn,i,j,k);

}

loop: ;

}

输出结果为:

i j k

0 0 0

0 0 1

如果不使用goto语句，而使用break,continue语句，应该这样

main()

{

int i,j,k;

printf(i jn);

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

{

for(j=0;j<3;j++)

{

for(k=0;k<3;k++)

{

if(k==2) break;

printf(%d %d %dn,i,j,k);

}

if(k==2) break;

}

if(k==2) break;

}

}

输出结果为:

i j k

0 0 0

0 0 1

所以在同时跳出多层循环时，应该使用goto语句。记住，所有的goto语句其实都是可以用break,continue代替的。

下面举几个例子：

1.求两个整数的最大公约数。例如10和15的最大公约数是5。

分析：最大公约数一定小于等于最小的那个数一半，同时能被两数整除。

main()

{

int num1,num2,i,min;

scanf(%d%d,&num1,&num2);

min=num1

for(i=min/2;i>0;i--)

if(num1%i==0&&num2%i==0) break;

printf(最大公约数为%dn,i);

}

2.求1!+2!+……+n!(n<10)

main()

{

int n,i;

long temp=1,sn=0; /*从9!以后,所得的值就超过了int范围*/

scanf(%d,&n);

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

{

temp*=i;

sn+=temp; /*如果没有这一步，求的就是n!*/

}

printf(%ldn,sn);

}

那么想想，如果求1!+3!+5!+……+n!应该怎么办？

3.判断一个整数是不是素数(素数就是只能被本身和1整除的数)。

#include math.h

main()

{

int num,i,flag=0;

scanf(%d,&num);

for(i=2;i

{

flag=0; /*标志变量复位*/

if(num%i==0)

{

flag=1;

break;

}

}

if(flag==0) printf(是素数n);

else printf(不是素数n);

}

可以说，在所有的C语言书上，都有判断素数的例题。它的编程思想是：把一个变量作为标志变量，用来标志是不是素数；循环体是从2到sqrt(num)，因为如果一个数不是素数的话，一定能分解成num=num1*num2，它们中的最小值一定小于sqrt(num)，所以循环的时候只要到sqrt(num)就可以了。同时要注意变量复位的问题。

数组，顾名思义就是一组同类型的数。

一、数组的声明

声明数组的语法为在数组名后加上用方括号括起来的维数说明。本接仅介绍一维数组。下面是一个整型数组的例子：

int array[10];

这条语句定义了一个具有10个整型元素的名为array的数组。这些整数在内存中是连续存储的。数组的大小等于每个元素的大小乘上数组元素的个数。方括号中的维数表达式可以包含运算符，但其计算结果必须是一个长整型值。这个数组是一维的。

下面这些声明是合法的：

int offset[5+3];

float count[5*2+3];

下面是不合法的：

int n=10;

int offset[n]; /*在声明时，变量不能作为数组的维数*/

二、用下标访问数组元素

int offset[10];

表明该数组是一维数组，里面有10个数，它们分别为offset[0],offset[1],……offset[9]；千万注意，数组的第一个元素下标从0开始。一些刚学编程的人员经常在这儿犯一些错误。

offset[3]=25;

上面的例子是把25赋值给整型数组offset的第四个元素。

在赋值的时候，可以使用变量作为数组下标。

main()

{

int i,offset[10];

for(i=0;i<10;i++) scanf(%d,&offset[i]);

for(i=9;i>=0;i--) printf(%d ,offset[i]);

printf(n);

}

题目的意思是先输入10个整数，存入到数组中，然后反序输出。

三、数组的初始化

前面说了，变量可以在定义的时候初始化，数组也可以。

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

在定义数组时，可以用放在一对大括号中的初始化表对其进行初始化。初始化值的个数可以和数组元素个数一样多。

如果初始化的个数多于元素个数，将产生编译错误；如果少于元素个数，其余的元素被初始化为0。

如果维数表达式为空时，那么将用初始化值的个数来隐式地指定数组元素的个数，

如下所式：

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

这也表明数组array元素个数为5。

main()

{

int i,array[]={1,3,5,7,9,11};

for(i=0;i<5;i++) printf(%d ,array[i]);

printf(n);

}

最终结果为1 3 5 7 9

四、字符数组

整数和浮点数数组很好理解，在一维数组中，还有一类字符型数组。

char array[5]={'H','E','L','L','O'};

对于单个字符，必须要用单引号括起来。又由于字符和整型是等价的，所以上面的字符型数组也可以这样表示：

char array[5]={72,69,76,76,79}; /*用对应的ASCII码*/

举一个例子：

main()

{

int i;

char array[5]={'H','E','L','L','O'};

for(i=0;i<5;i++) printf(%d ,array[i]);

printf(n);

}

最终的输出结果为72 69 76 76 79

但是字符型数组和整型数组也有不同的地方，看下面的：

char array[]=HELLO;

如果我们能看到内部的话，实际上编译器是这样处理的：

char array[]={'H','E','L','L','O','0'};

看上面最后一个字符'0'，它是一个字符常量，Turbo C编译器总是给字符型数组的最后自动加上一个0，这是字符的结束标志。所以虽然HELLO只有5个字符，但存入到数组的个数却是6个。但是，数组的长度仍然是5。

int i;

i=strlen(array); /*求字符串的长度，在string.h里面*/

可以看出i仍然是5，表明最后的'0'没有算。

#include string.h

main()

{

int i,j;

char array[]=094387fdhgkdladhladaskdh;

j=strlen(array);

for(i=0;i

printf(n);

}

其实我们可以根据判断'0'来输出字符串，看下面的：

main()

{

int i;

char array[]=094387fdhgkdladhladaskdh;

for(i=0;array[i]!='0';i++) printf(%c,array[i]);

printf(n);

}

举几个例子：

1.输入10个整数存入数组中，然后把它们从小到大排列并放在同一数组中。(思路：先找出最小的，放在第一个位置，为了防止把原先的数覆盖掉，可以把原先的第一个数和最小数的位置互换)。

main()

{

int array[10];

int i,j,min,stmp;

for(i=0;i<10;i++) scanf(%d,&array[i]);

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

{

min=array[i];

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

if(min>array[j]) /*里面的4行语句很重要*/

{

min=array[j];

stmp=array[i];

array[i]=array[j];

array[j]=stmp;

}

}

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

printf(n);

}

分析：先让第一个值作为基准，如果后面有比它小的，那么就把这两个数互换一下，同时把基准换成小的值。两个数互换应该这样(stmp=a;a=b;b=stmp;)，而不是(a=b;b=a;)，想想这是为什么？必须要用一个变量作为桥梁。这种一个一个的把最小的放在前面的排序方法，我们形象的叫做冒泡法。

2.输入一行字符存入数组，然后把他们反序存入到同一数组中。

#include stdio.h

main()

{

char c,stmp,array[80];

int i=0,j;

while((c=getchar())!='n') /*注意这儿的用法*/

array[i++]=c;

array[i]='0'; /*为什么要加'0'？是否可以不加？*/

for(j=i-1;j>=i/2;j--)

{

stmp=array[j];

array[j]=array[i-1-j];

array[i-1-j]=stmp;

}

for(i=0;array[i]!='0';i++) printf(%c,array[i]);

printf(n);

}

3.一个已经排好序的数组，输入一个数，利用二分法把这个数从原数组中删除，数组顺序保持不变。如原数组为1,3,5,7,9,11,13,15,17,19，待删除的数为13，则输出为1,3,5,7,9,11,15,17,19。

二分法：每次都是判断中间的数是否满足要求，若满足则删除，若不满足，则把该数当作边界，然后再找中点。例如这一题，第一次的是10个数的中点，为11，发现11<13，则找11-19的中点15，发现15>13，再找11-15的中点13，正好，则删除。

main()

{

int array[10]={1,2,3,5,8,15,20,30,100,200};

int first=0,end=9,middle=(first+end)/2,num,i;

scanf(%d,&num);

while(array[middle]!=num) /*注意这里面的三行代码*/

{

if(array[middle]>num) end=middle;

else first=middle;

middle=(first+end)/2;

}

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

{

if(i>=middle) array[i]=array[i+1];

printf(%d ,array[i]);

}

printf(n);

}

程序没有考虑当输入的数在原先数组中没有时怎么处理。如果要考虑这个问题，程序该怎么改动呢？

一、高维数组

有时，数组的维数并不止一维，例如一个记录消费中心在第一季度里各个月的收入数据就可以用二维数组来表示。定义二维数组的方法是在一维数组定义的后面再加上一个用方括号括起来的维数说明。例如：

float array[3][8];

实际上，这个数组可以看成3个连续的一维数组，每个一维数组具有8个元素。该数组在内存中的存储格式为最左边的维数相同的元素连续存储，也即按行存储的。首先存储第一行8个元素，其次是第二行，最后是第三行。

main()

{

int array[3][3]={1,2,3,4,5,6,7,8,9};

int i,j;

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

{

for(j=0;j<3;j++) printf(%3d);

printf(n);

}

}

它的输出结果为：

1 2 3

4 5 6

7 8 9

可以看出，二维数组元素是按行存储的。

我们也可以对数组进行赋值，而不是初始化。

main()

{

int array[3][3];

int i,j;

for(j=0;j<3;j++)

for(i=0;i<3;i++) scanf(%d,&array[i][j]);

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

{

for(j=0;j<3;j++) printf(%3d);

printf(n);

}

}

当输入1 2 3 4 5 6 7 8 9<回车>

输出为：

1 4 7

2 5 8

3 6 9

数组可以是二维、三维甚至是更高维数的，虽然C语言对维数的处理没有上限，但是处理高维数组是很头疼的事。一般尽量避免处理四维和四维以上的数组。下面看一个三维数组的例子：

main()

{

int array[2][3][4];

int i,j,k;

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

for(j=0;j<3;j++)

for(k=0;k<4;k++) array[i][j][k]=i*12+j*4+k;

}

这个三维数组可以看成2个二维数组，每个二维数组又可以看成3个一维数组。可以在头脑里想象成两个平行平面，每个平面内有3*4个点。所以共有24个元素。

二、字符串数组

上面讲的都是存放数值的，有一类数组，用来处理字符串的，我们叫字符串数组。其实字符串数组也是二维数组，只是它的特殊性，才单独拿出来说的。

main()

{

char s[10][10];

int i;

for(i=0;i<10;i++) scanf(%s,s[i]);

}

先看它的输入特性，前面在说输入语句的时候说过，遇到字符串输入，可以不加'&'，现在只要记住这个特性就可以，以后说指针的时候再讲为什么。但是这儿为什么用s[i]，可能很多人不太明白。我们定义的是二维数组，而输入的时候，却使用一维数组的形式。这是因为字符串在内存里地址可以用它的名字表示，就好象这种形式：

main()

{

char s[10];

scanf(%s,s);

}

定义的是一维数组，输入语句用变量形式表示一样。通过前面的'%s'形式可以看出，s[i]是一个数组，所以s就是二维数组了。

这里要注意一点，scanf()函数在输入字符串时候不能支持空格，看下面的例子：

main()

{

char s[3][10];

int i;

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

scanf(%s,s[i]);

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

printf(%sn,s[i]);

}

我们输入：1111

2222 3333

4444

我们是想把1111赋值给s[0],2222 3333赋值给s[1],4444赋值给s[2]。可实际上编译器是这样做的，把1111赋值给s[0]，把2222赋值给[1]，把3333赋值给s[2]。

实际输出：1111

2222

3333

在输入字符串的时候，如果使用scanf()，就把空格当作下一个输入了。那么我们怎么解决这个问题呢？毕竟很多情况下，一行字符串肯定有空格出现的。我们使用新的函数gets()。这个函数是专门接受字符串输入的，它跳过了空格的影响。把上面的输入语言修改为gets(s[i])即可。

我们定义了char s[3][10]，超过10个字符肯定不行，如果少于10个字符，电脑怎么处理呢？电脑是在每个字符串的后面自动补上'0'，作为字符串的结束标志。

我们经常在填写一些可选择的内容时经常发现，待选的字符串都是按字母排列好的，我们怎么用C语言实现这个功能？在C语言里，字符串的排序是按照字符的ASCII码来的，如果第一个字符一样，则比较第二个，依次类推。

main()

{

char s1[6]=addfgh,s2[5]=asdlg;

int i;

for(i=0;s1[i]!='0'&&s2[i]!='0';i++)

{

if(s1[i]

{

printf(s1

exit(1);

}

else if(s1[i]>s2[i])

{

printf(s1>s2n);

exit(1);

}

else ;

}

if(s1[i]=='0' && s2[i]!='0') printf(s1

else if(s2[i]=='0' && s1[i]!='0') printf(s1>s2n);

else printf(s1==s2n);

}

上面的例子就是比较两个字符串大小的，先比较第一个，如果相同，接着比较第二个，如果不相同，则分出大小。一直往后比较，直到其中某一个到'0'，你也可以先用strlen()函数找出最小的长度。

exit()函数的作用是退出程序，具体它的用法可以看看相关资料。

其实C语言把我们经常需要的字符串处理函数都做好了，我们只需要调用它即可。如strcmp()用来比较、strcpy()用来拷贝等等。看看它们的用法：

#include string.h

main()

{

char s1[10],s2[10],s2[10];

int k;

gets(s1);

gets(s2);

k=strcmp(s1,s2); /*比较s1和s2大小*/

if(k==0) printf(s1==s2n);

else if(k>0) printf(s1>s2n);

else printf(s1

strcpy(s3,s1); /*把s1拷贝到s3*/

printf(%sn,s3);

}

可以看出，比较大小时，如果k<0，则s10，则s1>s2;如果k=0，则s1=s2。实际上这是一个函数，具体什么是函数，以及为什么写成那种形式，我们下节再说。这些函数都包含在string.h头文件中，所以在程序的开头，都要写上#include string.h。

字符串处理有很多函数，你们可以看看相关的书，也可以看看Turbo C的帮助。

本节介绍C程序的基本单元--函数。函数中包含了程序的可执行代码。每个C程序的入口和出口都位于函数main()之中。main()函数可以调用其他函数，这些函数执行完毕后程序的控制又返回到main()函数中，main()函数不能被别的函数所调用。通常我们把这些被调用的函数称为下层(lower-level)函数。函数调用发生时，立即执行被调用的函数，而调用者则进入等待状态，直到被调用函数执行完毕。函数可以有参数和返回值。

程序员一般把函数当作“黑箱”处理，并不关心它内部的实现细节。当然程序员也可以自己开发函数库。

说明一点，函数这一节很重要，可以说一个程序的优劣集中体现在函数上。如果函数使用的恰当，可以让程序看起来有条理，容易看懂。如果函数使用的乱七八糟，或者是没有使用函数，程序就会显得很乱，不仅让别人无法查看，就连自己也容易晕头转向。可以这样说，如果超过100行的程序中没有使用函数，那么这个程序一定很罗嗦(有些绝对，但也是事实)。

一、函数的定义

一个函数包括函数头和语句体两部分。

函数头由下列三不分组成：

函数返回值类型

函数名

参数表

一个完整的函数应该是这样的：

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

{

语句体；

}

函数返回值类型可以是前面说到的某个数据类型、或者是某个数据类型的指针、指向结构的指针、指向数组的指针。指针概念到以后再介绍。

函数名在程序中必须是唯一的，它也遵循标识符命名规则。

参数表可以没有也可以有多个，在函数调用的时候，实际参数将被拷贝到这些变量中。语句体包括局部变量的声明和可执行代码。

我们在前面其实已经接触过函数了，如abs(),sqrt()，我们并不知道它的内部是什么，我们只要会使用它即可。

这一节主要讲解无参数无返回值的函数调用。

二、函数的声明和调用

为了调用一个函数，必须事先声明该函数的返回值类型和参数类型，这和使用变量的道理是一样的(有一种可以例外，就是函数的定义在调用之前，下面再讲述)。

看一个简单的例子：

void a(); /*函数声明*/

main()

{

a(); /*函数调用*/

}

void a() /*函数定义*/

{

int num;

scanf(%d,&num);

printf(%dn,num);

}

在main()的前面声明了一个函数，函数类型是void型，函数名为a，无参数。然后在main()函数里面调用这个函数，该函数的作用很简单，就是输入一个整数然后再显示它。在调用函数之前声明了该函数其实它和下面这个程序的功能是一样的：

main()

{

int num;

scanf(%d,&num);

printf(%dn,num);

}

可以看出，实际上就是把a()函数里面的所有内容直接搬到main()函数里面(注意，这句话不是绝对的。)

我们前面已经说了，当定义在调用之前时，可以不声明函数。所以上面的程序和下面这个也是等价的：

void a()

{

int num;

scanf(%d,&num);

printf(%dn,num);

}

main()

{

a();

}

因为定义在调用之前，所以可以不声明函数，这是因为编译器在编译的时候，已经发现a是一个函数名，是无返回值类型无参数的函数了。

那么很多人也许就会想，那我们何必还要声明这一步呢？我们只要把所有的函数的定义都放在前面不就可以了吗？这种想法是不可取的，一个好的程序员总是在程序

的开头声明所有用到的函数和变量，这是为了以后好检查。

前面说了，在调用之前，必须先声明函数，所以下面的做法也是正确的(但在这里我个人并不提倡)。

main()

{

void a();

a();

}

void a()

{

int num;

scanf(%d,&num);

printf(%dn,num);

}

一般来说，比较好的程序书写顺序是，先声明函数，然后写主函数，然后再写那些自定义的函数。

既然main()函数可以调用别的函数，那么我们自己定义的函数能不能再调用其他函数呢？答案是可以的。看下面的例子：

void a();

void b();

main()

{

a();

}

void a()

{

b();

}

void b()

{

int num;

scanf(%d,&num);

printf(%dn,num);

}

main()函数先调用a()函数，而a()函数又调用b()函数。在C语言里，对调用函数的

层数没有严格的限制，我们可以往下调用100层、1000层，但是在这里我们并不提倡调用的层数太多(除非是递归)，因为层数太多，对以后的检查有一些干扰，函数调过来调过去，容易让自己都晕头转向。

某些人可能就不明白了，看上面的例子，好象使用函数后，程序变的更长了，更不让人理解。当然，我举的这个例子的确没有必要用函数来实现，但是对于某些实际问题，如果不使用函数，会让程序变的很乱，这涉及到参数问题，我们下一节再说。

前面我们说的都是无参数无返回值的函数，实际程序中，我们经常使用到带参数有返回值的函数。

一、函数参数传递

1.形式参数和实际参数

函数的调用值把一些表达式作为参数传递给函数。函数定义中的参数是形式参数，函数的调用者提供给函数的参数叫实际参数。在函数调用之前，实际参数的值将被拷贝到这些形式参数中。

2.参数传递

先看一个例子：

void a(int); /*注意函数声明的形式*/

main()

{

int num;

scanf(%d,&num);

a(num); /*注意调用形式*/

}

void a(int num_back) /*注意定义形式*/

{

printf(%dn,num_back);

}

在主函数中，先定义一个变量，然后输入一个值，在a()这个函数中输出。当程序运行a(num);这一步时，把num的值赋值给num_back，在运行程序过程中，把实际参数的值传给形式参数，这就是函数参数的传递。

形参和实参可能不只一个，如果多于一个时，函数声明、调用、定义的形式都要一一对应，不仅个数要对应，参数的数据类型也要对应。

void a(int,float);

main()

{

int num1;

float num2;

scanf(%d,&num1);

scanf(%f,&num2);

a(num1,num2);

}

void a(int num1_back,float num2_back)

{

printf(%d,%fn,num1_back,num2_back);

}

上面的例子中，函数有两个参数，一个是整型，一个是浮点型，那么在声明、调用、定义的时候，不仅个数要一样，类型也要对应。如果不对应，有可能使的编译错误，即使没错误，也有可能让数据传递过程中出现错误。

再看一个例子：

void a(int);

main()

{

int num;

scanf(%d,&num);

a(num);

}

void a(int num)

{

printf(%dn,num);

}

看上面的例子，形式参数和实际参数的标识符都是num，程序把实际参数num的值传递给形式参数num。有些人可能就不明白了，既然两个都是num，为什么还要传递呢？干脆这样不就行了吗：

void a();

main()

{

int num;

scanf(%d,&num);

a();

}

void a()

{

printf(%dn,num);

}

其实不然，这就要涉及到标识符作用域的问题。作用域的意思就是说，哪些变量在哪些范围内有效。一个标识符在一个语句块中声明，那么这个标识符仅在当前和更低的语句块中可见，在函数外部的其实地方不可见，其他地方同名的标识符不受影响，后面我们会系统讲解作用域的问题。在这儿你就要知道两个同名的变量在不同的函数中是互不干扰的。

前面将的都是变量与变量之间的值传递，其实函数也可以传递数组之间的值。看下面的例子：

void a(int []);

main()

{

int array[5],i;

for(i=0;i<5;i++) scanf(%d,&array[i]);

a(array);

}

void a(int array[])

{

int i;

for(i=0;i<5;i++) printf(%dt,array[i]);

printf(n);

}

这就是数组之间的值传递。注意他们的声明和定义形式，和变量参数传递有什么区别？有了后面的[]就表明传递的是一个数组。其中在定义的时候，也可以写成void

a(int array[5]);想想，如果我们写成了int array[4]会有什么情况发生？

目前我们只学了数组和变量，以后还会知道指针、结构，到那是，函数也可以传递它们之间的值。

二、函数值的返回

其实我们也可以把函数当作一个变量来看，既然是变量，那一定也可以有类型。还举最前面的例子，现在要求在main()函数里输入一个整数作为正方形的边长，在子函数里求正方形的面积，然后再在主函数里输出这个面积。

我们前面的程序都是在子函数里输出的，现在要求在主函数里输出，这就需要把算好的值返回回来。先看例子：

int a(int); /*声明函数*/

main()

{

int num,area;

scanf(%d,&num);

area=a(num); /*调用时的形式*/

printf(%d,area);

}

int a(int num)

{

int area_back;

area_back=num*num;

return area_back; /*返回一个值*/

}

和前面的程序有几点不同：

(1).声明函数类型时，不是void，而是int。这是由于最后要求的面积是整型的，所以声明函数的返回值类型是整型。

(2).return语句 它的意思就是返回一个值。在C语言中，return一定是在函数的最后一行。

(3).调用函数的时候,由于函数有一个返回值，所以必须要用变量接受这个返回值(不是绝对的)，如果我们不用一个变量接受这个值，函数还照样返回，但是返回的这个值没有使用。

上面的例子运行过程是这样的，先把实参的值传递给形参，然后在子函数里计算面积得到area_back，然后返回这个面积到主函数，也就是把area_back赋值给area，最后输出。

前面说了，返回值有时不一定非要用一个变量来接受，我们可以把上面的程序简化为：

int a(int);

main()

{

int num;

scanf(%d,&num);

printf(%d,a(num)); /*函数调用放在这儿*/

}

int a(int num)

{

int area_back;

area_back=num*num;

return area_back;

}

这样函数返回的值就可以直接放到输出缓冲区直接输出了。