第3章 简单的C程序设计——顺序程序设计

3.1 顺序程序设计举例

例：有人用温度计测量出用华氏法表示的温度（如64f），今要求把它转换为一摄氏法表示的温度（如17.8c）

解题思路：问题的关键在于找到两者的转换公式。根据物理学知识,公式为c=5/9(f-32)。

其中f代表华氏温度，c代表摄氏温度。

编写程序：

#include <stdio.h>

int main()

{

    float f;           //华氏温度

    float c;           // 摄氏温度

    printf ("请输入华氏温度：\n");

    scanf ("%f", &f);

    b = ( 5.0 / 9 ) * ( a - 32 );  //计算公式

    printf("转换成摄氏度是:%f\n",c);

    return 0;

}

3.2 数据的表现形式及其运算

3.2.1 常量和变量

在计算机高级语言中，数据由两种表现形式：常量和变量。

1.常量

在程序运行过程中，其值不能被改变的量称为常量。数值常量就是数学中的常数。

常用的常量有以下几类：

（1）     整型常量：如1000,123，-123等都是整型常量。说的简单一点就是数学中的整数。

（2）     实型常量：有两种表现形式

①  十进制小数形式，有数字和小数点组成。如123.456，0.234，-56.79,0.0等

②  指数形式，如12.34e3(代表12.34*10^3),-357.87e-25(代表-357.87*10^-25)。由于在计算机输入和输出时，无法表示上角或下角，故规定以字母e或e代表以10为底的指数。但应注意：e或e之前必须有数字，且e或e后面必须为整数。如不能写成e4,12e4.6等形式。

（3）     字符常量。有两种形式的字符常量

①  普通字符，用单撇号括起来的一个字符，如：’a’，’b’，’c’，’3’，’#’等。不能写成’ab’或‘12’。

at(attention)：单撇号只是界限符，字符常量只能是一个字符，不包括单撇号。字符常量存储在计算机的存储单元中时，并不是存储字符（如a,z,#等）本身，而是以其代码（一般采用ascii码）存储的。如字符’a’的ascii化代码是97.因此，在存储单元中存放的是97（以二进制形式存放）。

②  转义字符，除了以上形式的字符常量外，c还允许用一种特殊形式的字符常量。是以字符\开头的字符序列。如printf函数中\n代表一个“换行”符。下列表中列出的字符称为“转移字符”，意思就是讲“\”后面的字符转换成另外的意义。

（4）     字符串常量。如“abc”，“123”等。用双撇号把若干个字符括起来，字符串常量是双撇号中的全部字符（但不包括双撇号本身）。注意，不能写错成’abc’。

单撇号内只能包含一个字符，双撇号可以包含至少一个字符串。如“a”是字符串常量，不是字符常量。

（5）     符号常量。用#define指令，指定用一个符号名称代表一个常量。

#define pi 3.1416      //注意行末尾是没有分号;的，它必须放在函数开头

在预编译后，符号常量已全部编程字面常量(3.1416)。

使用符号常量有以下好处：

①  含义清楚。在定义符号常量名时应考虑“见名知意”。

②  在需要修改程序中多处用到的同一常量时，能做到“一改全改”。

at:要区分符号常量和变量，不要把符号常量误认为变量。符号常量不占内存，只是一个临时符号，在预编译后这个符号就不存在了，故不能对符号常量赋以新值。

习惯上符号常量用大写表示，如pi,price等。

2.变量

变量代表一个有名字、具有特定属性的一个存储单元。

变量必须先定义，后使用。一个变量应该有一个名字，以便被引用。在定义是指定该变量的名字和类型。

at:区分变量名和变量值的概念。

变量名实际上是一个名字代表的一个存储地址。换个说法就是说，存储地址（如0x778989）被用名字代替，而不用输入0x778989来进行变量的访问。只需通过名字就可访问变量。

在对程序编译连接时由编译系统给每一个变量名分配对应的内存地址。

实际上是通过变量名找到相应的内存地址，从该存储单元中读取数据。和上述的说法类似。

3．常变量

c99以后允许使用常变量，如：const int a = 3;

上述a表示a被定义成一个整型变量，指定其值为3。其值不能改变，在该变量生存周期期间。

   常变量与常量的异同是：常变量具有变量的基本属性：有类型，占存储单元，只是不允许改变其值。换个说法来说，就是常变量是由名字的不变量，而常量是没有名字的不变量。有名字就便于在程序中被引用。

常变量和符号变量有什么不同？如：

#define pi 3.1415                                      //定义符号常量

const float pi = 3.1415;                            //定义常变量

符号常量的名字是不分配存储单元的。常变量需要占用存储单元，有变量值，只是该值不改变而已。推荐在可以选择符号常量和常变量时，选择常变量，而不多用符号常量。

4.标识符

用来对变量、符号常量名、函数、数组、类型等命名的有效字符序列统称为标识符（identifier）。

简单说，标识符就是名字。

c语言规定标识符只能由字母（a-z、a-z）、数字（0-9）、下划线（_）组成，且第1个字符必须为字符或下划线。

at:编译系统将大写字母和小写字母认为是两个不同的字符。如sum和sum是两个不同的变量名。习惯上（不是硬性要求），变量名用小写字母表示。

3.2.2 数据类型

at:用计算机进行的计算不是抽象的理论值的计算，而是用工程的方法实现的计算机，所以在许多情况下只能得到近似的结果。

  类型，就是对数据分配存储单元，包括存储单元的长度（占有多少个字节）以及数据的存储形式。不同的类型分配不同的长度和存储形式。

         c语言允许使用的类型见下图，其中图中带有*的是c99才增加的。

其中基本类型（包括整型和浮点型）和枚举类型变量的值都是数值，统称为算术类型（arithmetic type）。算术类型和指针类型统称为纯量类型（scalar type），因为其变量的值是以数字来表示的。枚举类型是程序中用户定义的整型类型。数据类型和结构体类型统称为组合类型（aggregate type），共用体类型不属于组合类型，因为在同一时间内只有一个成员具有值。函数类型用来定义函数，描述一个函数的接口，敖阔函数返回值的数据类型和参数的类型。

3.2.3 整型数据

1. 整型数据的分类

a)       基本整型（int型）

编译系统分配给int类型数据2个bytes或4个bytes（由具体的c编译系统自行决定）。

存储单元中存储方式是：用整数的补码（complement）形式存放。

在存放整数的存储单元中，最左面的一位是用来表示符号的。0—数值为正；1—数值为负。

b)       短整型（short int）

类型名为short int或short。范围为：-32768~32767

c)        长整型（long int）

类型名为long int或long。

d)       双长整型（long long int）

类型名为long long int 或long long，一般分配8个bytes。这是c99新增的类型，许多c编译系统尚未实现，使用时需要看编译系统支不支持该类型。

说明：c标准没有具体规定各种类型数据所占用存储单元的长度，这是由各编译系统自行决定的。c标准只要求long型数据长度不短于int型，short型不长于int型。即

         sizeof(short)≤sizeof(int)≤sizeof(long)≤sizeof(long long)

sizeof是测量类型或变量长度的运算法。关于它的使用方法，将在后面阐述。

2.整型变量的符号属性

   存储值在存储单元中都是以补码形式存储的，存储单元中的第1个二进位制代表符号。

整型变量的值的范围包括负数到整数。见下

有符号整形数据存储单元中最高位代表符号（0为正，1为负）。如果指定unsigned（为无符号类型），存储单元中全部进制位都用来存放数值本身，故数值的范围扩大一倍（从0开始）。无符号型变量只能存放不带符号的整数，如123，456，789等；不能存放负数，如-123，-3等。

说明：

（1）     只有整型（包括字符型）数据可以加signed或unsigned修饰符，实行数据不能加。

（2）     对无符号整型数据用“%u”格式输出。%u表示用无符号十进制数的格式输出。

3.2.4 字符型数据

1.字符与字符代码

   字符与字符代码并不是任意写一个字符，程序都能识别的。目前大多数系统采用ascii字符集。如下图

2.字符变量

  字符变量是用类型符char定义字符变量。char是英文character（字符）的缩写。

在输出字符变量的值时，可以选择以十进制整数形式输出，或以字符形式输出。如：

         char a = ‘a’;

printf(“%d   %c\n”,c,c);

输出的结果是： 65    a

用“%d”格式输出十进制整数63，用“%c”格式输出字符’a’。

说明：在用有符号字符型变量时，允许存储的值为-128~127，但字符的代码不可能为负值，故在存储字符时实际上只用到0~127这一部分，其第1位都是0。

3.2.5 浮点型数据

浮点型数据是用来表示具有小数点的实数的，换句话说就是数学中的带小数格式的数字。

为什么在c语言中把实数称为浮点数呢？

因为在c语言中，实数是以指数形式存放在存储单元中的。由于小数点的位置可以浮动，所以实数的指数形式称为浮点数。

规范化的指数形式——把小数部分中小数点前的数字为0，小数点后第1位数部位0的表示形式。如0.314159*10^1就是3.14159的规范化的指数形式。一个实数只有一个规范化的指数形式，在程序若以指数形式输出一个实数时，必然以规范化的指数形式输出，如0.1314159e001.

  浮点数类型包括float（单精度浮点型）、double（双精度浮点型）、long double（长双精度浮点型）。

（1）     float（单精度浮点型）.编译系统为每一个float型变量分配4个字节，数值以规范化的二进制数指数形式存放在存储单元中。在存储时，系统将实型数据分为小数部分和指数部分，分别存放。小数部分的小数点前面的数为0.

at：小数部分占的位（bit）数愈多，数的有效数字愈多，精度也就愈高。指数部分占的位数愈多，则能表示的数值范围愈大。float型数据能得到6位有效数字，数值范围为：           -3.4*10^-38~3.4*10^38。

（2）     double（双精度浮点型）.为了扩大能表示的数值范围，用8个字节存储一个double型数据，可以得到15位有效数字，数值范围为-1.7*10^-308~1.7*10^-308。

（3）     long double（长双精度浮点型）.不同编译系统对long double的处理方法不同。vc6.0对long double型和double型是一样的处理，分配8个字节。

3.2.6 怎样确定常量的类型

   怎么确定常量的类型呢？

   整型常量。不带小数点的数值就是整型常量，但应注意其有效范围。

   浮点型常量。凡以小数形式或指数形式出现的实数，是浮点型常量，在内存中都以指数形式存储。

at:在一个整数的末尾加大写字母l（或小写l），表示它是长整型（long int）。在一个实数的末尾加大写字母f（或小写f），表示它是单精度浮点型（float）。这是好的习惯，有些编译器在不加的时候会发出警告，故我们应该加上末尾对应的字符。

注意：要区分类型与变量

1)       每一个变量都属于一个确定的类型，类型是变量的一个重要的属性

2)       变量是占用存储单元的，是具体存在的实体，再起占用的存储单元中可以存放数据。

3)       类型是变量的共性，是抽象的，不占用存储单元，不能用来存放数据。

可以对一个变量赋值，但不能向一个类型赋值。如：

int a = 3;        //正确。对整型变量a赋值

int = 3;          /错误。不能对类型赋值

3.2.7运算符和表达式

1.基本的算术运算符

常用的算术运算符：

说明：

·由于键盘无×号，运算符×以*代替。

·由于键盘无÷号，运算符÷以/代替。

·%运算符要求参加运算的运算对象（即操作数）为整数，结果也是整数。如8%3结果为2。

·除%以外的运算符的操作数都可以是任何算术类型。

2.自增、自减运算符

作用是使变量的值加1或减1，例如：

++i，--i（使用i之前，先使i的值加（减）1）

i++，i--（使用i之后，使i的值加（减）1）

例：

 1 #include <stdio.h>
 2  
 3 int main() {
 4 
 5     int a=100;
 6 
 7     int b=50;
 8 
 9 //    b++;
10 
11     printf("%d,%d\n",a++,++a);
12 
13     printf("%d,%d",b++,++b);
14 
15     return 0;
16 
17 }

运行后输出的结果

1 101,102
2 51,52

若不注释 b++：

1 #include <stdio.h>
2 int main() {
3     int a=100;
4     int b=50;
5     b++;
6     printf("%d,%d\n",a++,++a);
7     printf("%d,%d",b++,++b);
8     return 0;
9 }

则结果为：

1 101,102
2 52,53

at:自增运算符（++）和自减运算符（--）只能用于变量，而不能用于常量或表达式，如5++或（a+b）++都是不合法的。

自增（减）运算符常用语循环语句中。

3.算术表达式和运算符的优先级与结核性

用算术运算符和括号将运算对象（也称为操作数）连接起来的、符号c语法规则的式子，称为c算术表达式。

  c语言除了规定运算符的优先级外，还规定了运算符的结合性。

  c语言规定了各种运算符的结合方向（结合性），算术运算符的结合方向都是“自左至右”，即先左后右。“自左至右的结合方向”又称“左结合性”，即运算对象先与左面的运算符结合。“自右至左的结合方向”又称“右结合性”，即运算对象先与右面的运算符结合。

4.不同类型数据间的混合运算

1)       + - * / 运算的两个数中有一个为float或double型，结果是double型。因为系统会将所有float型数据都先转换为double型，然后进行运算。总的来说，就是向高精度的方向自动转换。

2)       如果int型与float或double型数据进行运算，先把int型和float型数据转换为double型，然后进行运算，结果是double型。

3)       字符（char）型数据与整形数据进行运算，就是把字符的ascii码值与整形数据进行换算。如12+‘a’，由于字符a的ascii码值为65，相当于12+65，等于77。

例：将给定的大写字母，要求转换成小写字母后输出。

 1 #include <stdio.h>
 2 
 3 int main()
 4 
 5 {
 6 
 7     char c;
 8 
 9     c=getchar();//输入。
10 
11     if(c>='a' && c<='z')
12 
13 　{//是大写字母
14 
15         printf(“%c”,c);//输出小写。
16 
17         printf(“%d”,c);
18 
19 　}
20 
21     return 0;
22 
23 }

1 运行结果 a   a  97

规律：同一个字母，用小写表示的字符的ascii码值比用大写表示的字符的ascii码值大32.

5.强制类型转换运算符

可以利用强制类型转换运算符将一个表达式转换成所需类型。

其一般形式为

（类型名）（表达式）

注意，表达式应该用括号括起来，若写成（int）x+y，则只将x转换成整型，然后与y相加。

at:有两种类型转换；

第1种是在运算时不必用户干预，系统自动进行的类型转换。简单理解就是，低精度—>高精度 是自动转换的，不需要强制。

第2种是强制类型转换。当自动类型转换不能实现目的时，可以用强制类型转换简单理解就是，高精度—>低精度，是需要手动转换的。因为可能会损失精度，故需手动转换。

6.c运算符

1)       算术运算符                 （+ - * / % ++ --）

2)       关系运算符                 （> < == >= <= !=）

3)       逻辑运算符                 （! && ||）

4)       位运算符                     （<< >> ~ | ^ &）

5)       赋值运算符                 （=及其扩展赋值运算符，如*= /= += -= ）

6)       条件运算符                 （?:）

7)       逗号运算符                 （,）

8)       指针运算符                 （* &）

9)       求字节数运算符          （sizeof）

10)   强制类型转换运算符   （(类型)）

11)   成员运算符                 （.->）

12)   下标运算符                 （[ ]）

13)   其他                         （如函数调用运算符()）

 3.3语句

3.3.1 c语言的作用和分类

一个函数包含声明部分和执行部分.

执行部分是由语句组成的，语句的作用是想计算机系统发出操作指令，要求执行相应的操作。声明部分不是语句，它不产生机器指令，只是对有关数据的声明。

一个函数有数据声明部分和执行语句组成

c语言分为以下5类

(1)    控制语句。控制语句用于完成一定的控制功能。c语言有9种控制语句，它们的形式是：

①  if()…else…                (条件语句)

②  for()…                         (循环语句)

③  while()…                     (循环语句)

④  do…while()                (循环语句)

⑤  continue                      (结束本次循环语句)

⑥  break                           (中止执行switch或循环语句)

⑦  switch                          (多分支选择语句)

⑧  return                                   (函数返回语句)

⑨  goto                             (转向语句，在结构化程序中基本不用goto语句)

(2)   函数调用语句。函数调用语句由一个函数调用加一个分构成，如：

printf(“hello world.”);

   其中printf(“hello world.”)是一个函数调用，加一个分号称为一个语句。

(3)   表达式语句。表达式语句有一个表达式加一个分号构成；较为典型的是，有赋值表达式构成一个赋值语句。如a = 3 是一个赋值表达式，而 a = 3;是一个赋值语句。

可以看到，一个表达式的最后加一个分号就成了一个语句。一个语句必须在最后有一个分号，分号是语句中不可缺少的组成部分。

(4)   空语句。下面是一个空语句：

;

(5)   复合语句。用{}把一些语句和声明括起来称为复合语句(又称语句块)。如

{

        printf(“a”);

printf(“b”);

printf(“c”);

printf(“d”);

}

3.3.2 最基本的语句——赋值语句

在c程序中，最常用的语句是：赋值语句和输入输出语句。

1. 1.     赋值运算符

赋值符号=就是赋值运算符，它的作用是将一个数据赋给一个变量

1. 2.     复合的赋值运算符

在赋值符=之前加上其他运算符，可以构成复合的运算符。如：

a + = 3   等价于  a = a+3

a * = y +8   等价于  a =a *(y +8)

a % = 3      等价于  a = a %3

注意：如果b是包含若干项的表达式，则相当于它有括号。以下3种写法是等价的：

①      a % = b+3

②      a % =( b+3)

③      a  = a% ( b+3) (注意，不能写成a=a%b+3)

1. 3.     赋值表达式

赋值语句是在复制表达式的末尾加一个分号构成的。

赋值表达式——由赋值运算符将一个变量和一个表达式连接起来的式子

它的一般形式为

变量赋值运算符表达式

赋值表达式的作用是将一个表达式的值赋给一个变量，因此赋值表达式具有计算和赋值的双重功能。

赋值运算符左侧应该是一个可修改的“左值”（left value,简写为lvalue）。常量不能作为lvalue。出现在复制运算符右侧的表达式称为“右值”（right value,简写为rvalue）。

1. 4.     赋值过程中的类型转换

(1)   将浮点型数据（包括单、双精度）赋给整型变量时，先对浮点数取整，即舍弃小数部分，然后赋予整型变量。

(2)   将整型数据赋给单、双精度变量时，数值不变，但以浮点数形式存储到变量中。

(3)   将一个double型数据赋给float变量时，先将双精度数转换为单精度。即只取6-7bit有效数字，存储到float变量的4个字节中。

(4)   字符型数据赋给整型变量时，将字符的ascii码值赋给整型变量

(5)   将一个占字节多的整型数据赋给一个占字节少的整型变量或字符变量；将其低字节原封不动地送到被赋值的变量（即发生“截断”）。

1. 5.     赋值表达式和赋值语句

c语言的赋值语句术语表达式语句，有一个赋值表达式加一个分号组成。

注意：要区分赋值表达式和赋值语句

赋值表达式的末尾没有分号，而赋值语句的末尾必须有分号。

在一个表达式中可以包含一个或多个赋值表达式，但绝不能包含赋值语句。

1. 6.     变量赋初值

可以用赋值语句对比变量赋值，也可以在定义变量时对变量赋以初值。

如，int a=3,b=3,c=3;但是不能连续赋值，如:int a = b = c = 3;这是错误的。

如，int a = 3;等价于int a; a = 3;

3.4 数据的输入输出

3.4.1 输入输出举例

例：输出两个数中的最大值

编写程序：

 1 #include <stdio.h>
 2 
 3 int main()
 4 
 5 {
 6 
 7          float a,b;
 8 
 9          printf(“please input two number a and b:\n”);
10 
11          scanf(“%lf%lf”,&a,&b);
12 
13          printf(“max=%7.2lf”,a>b?a:b);
14 
15          return 0;
16 
17 }

程序分析：

(1)    用scanf函数输入a,b的值，注意在scanf函数中括号内变量a,b的前面，要用地址符&，即&a,&b。&a表示变量a在内存中的地址。双撇号内用%lf格式声明，表示输入的是双精度实数。

(2)    在printf函数中，不是简单用%f格式声明，而是在f前面加了“7.2”.表示在输出x1和x2时，指定数据占7列，其中小数占2列。

3.4.2 有关数据输入输出的概念

在讨论输入输出时首先要注意以下几点：

（1）     所谓输入输出是以计算机主机为主体而言的，从计算机向输入设备（如显示器、打印机等）输出数据称为输出。从输入设备（如键盘、磁盘、光盘、扫描仪等）向计算机输入数据称为输入。更准确来说，是以内存为主体而言的。

（2）     c语言本身不提供输入输出语句，输入和输出操作是由c标准函数库中的函数来实现的。

不把输入输出作为c语言的目的是使c语言编译系统简单精练，因为将语句翻译成二进制的指令是在编译阶段完成的，没有输入输出语句就可以避免在编译阶段处理与硬件有关的问题，可以使编译系统简单化，而且通用性强，可移植性好，在各种型号的计算机和不同的编译环境下都能适用，便于在各种计算机上实现。

   c语言函数库中有一批“标准输入输出函数”，它是以标准的输入输出设备（一般为终端设备）为输入输出对象的。其中有：putchar(输出字符)、getchar(输入字符)、printf(格式输出)、scanf(格式输入)、puts(输出字符串)和gets(输入字符串)。

（3）     在使用系统库函数时，要在程序文件的开头用预处理指令#include把有关头文件放在本程序中，如：#include <stdio.h> 或 #include “stdio.h”

以上两种#include指令形式的区别是：用尖括号<>（如<stdio.h>）时，编译系统从存放c编译系统的子目录中去找所要包含的文件(如stdio.h)，这称为标准方式。如果用双撇号形式（如”stdio.h”），在编译时，编译系统先在用户的当前目录(一般是用户存放源程序文件的子目录)中寻找要包含的文件，若找不到，再按标准方式查找。

   如果用#include指令是为了使用系统库函数，因而要包含系统提供的相应头文件，以用标准方式为宜，以提高效率。

如果用户想包含的文文件不是系统提供的相应头文件，而是用户自己编写的文件(这种文件一般都存放在用户当前目录中)，这是应当用双撇号形式，否则会找不到所需的文件。如果该头文件不在当前目录中，可以在双撇号中写出文件路径（如#include “c:\temp\file.h”），以便系统能从中找到所需的文件。

注意：应该养成该习惯：只要在本程序文件中使用标准输出输出库函数时，一律加上#include <stdio.h>指令。

3.4.3 用printf函数输出数据

printf函数（格式输出函数）用来向终端（或系统隐含指定的输出设备）输出若干个任意类型的数据。

1.printf函数的一般格式

printf函数的一般格式为：printf（格式控制，输出表列）例：printf(“%d,%c\n”,a,b);

（1）“格式控制”是用双撇号括起来的一个字符串，称“转换控制字符串”，简称“格式字符串”。它包括两个信息：

①格式说明。格式声明由“%”和格式字符组成，如%d、%f等。它的作用是将输出的数据转换为指定的格式然后输出。格式声明总是由“%”字符开始的。

②普通字符。普通字符即需要在输出时原样输出的字符。

（2）“输出表列”是程序需要输出的一些数据，可以是常量、变量或表达式。

例：

printf(“  %d , %c    \n”,        a , b );

           格式声明               输出表列

printf函数的一般形式可以表示为

printf(参数1，参数2，参数3……，参数n);

2.格式字符

(1)d格式字符。用来输出一个有符号的十进制整数。

可以在格式声明中指定输出数据的域宽(所占的列数)，如用“%5d”指定输出数据占5列。

(2)c格式符。用来输出一个字符。

如： char ch = ‘a’;

         printf(“%c”,ch);

运行时输出a

(3)s格式符。用来输出一个字符串。如：

printf(“%s”, ”china”);

(4)f格式符。用来输出实数（包括单、双、长双精度），以小数形式输出，有以下用法

①基本型，用%f

   不指定输出数据的长度，有系统根据数据的实际情况决定数据所占的猎术。系统处理的方法一般是：实数中的整数部分全部输出，小数部分输出6位。

②指定数据宽度和小数位数，用%m.nf.指定数据占m列，小数占有n列。若把小数部分n指定为0，则不仅不输出小数，并且小数点也不输出。

如printf(“%20.15f\n”,a);

注意：在用%f输出时要注意数据本身能提供的有效数字，如float型数据的存储单元只能保证6位有效数字。double型数据能保证15位有效数字。

③输出的数据想左对齐，用%-m.nf

在m.n的前面加一个负号，其作用与%m.nf形式作用基本相同；但当数据长度不超过m时，数据向左靠，右端补空格。换个说法就是，左对齐。

(5)e格式符，用格式声明%e指定以指数形式输出实数。如果不指定输出数据所占的宽度和数字部分的小数位数，许多c编译系统（如vc6.0）会自动给出数字部分的小数位为6位，指数部分占5列（如e+002，其中“e”占1列，指数符号占1列，指数占3列）。

数值按标准化指数形式输出（即小数点前必须有且只有1位非零数字）。如：

printf(“%e”,123.456);

输出如下：

1.234560 e+002

         6列  5列

所输出的实数共占有13列宽度。（注：不同系统的规定略有不同）

c语言还提供以下几种输出格式符，由于初学，用的次数不多，不过多详细介绍

(1)i格式符。作用于d格式符相同，按十进制整型数据的实际长度输出。一般习惯用%d而少用%i。

(2)o格式符。以八进制整数形式输出。

(3)x格式符。以十六进制数形式输出整数。

(4)u格式符。用来输出无符号(unsigned)型数据，以十进制整数形式输出。

(5)g格式符。用来输出浮点数，系统自动选f格式或e格式输出，选择其中长度较短的格式，不输出无意义的0.

综上所述，格式声明的一般形式可以表示为：

%   附加字符  格式字符

printf函数中用到的格式字符

printf函数中用到的格式附加字符

3.4.4 用scanf函数输入数据

1.scanf函数的一般形式

scanf(格式控制，地址表列)

“格式控制”的含义通printf函数。“地址表列”是由若干个地址组成的表列，可以是变量的地址，或字符串的首地址。

2.scanf函数中的格式声明

与printf函数中的格式声明类似，以%开始，以一个格式字符结束，中间可以插入附加的字符。

scanf函数中所用到的格式字符

scanf函数中用到的格式附加字符

3.使用scanf函数时应注意的问题

(1)scanf函数中的“格式控制”后面应当是变量地址，而不是变量名。

(2)如果在“格式控制字符串”中除了格式声明以外还有其他字符，则在输入数据时在对应的位置上应输入与这些字符相同的字符。

3.4.5 字符数据的输入输出

1.用putchar函数输出一个字符

想从计算机向显示器输出一个字符，可以调用系统函数库中的putchar函数（字符输出函数）。

putchar函数的一般形式为

putchar(c)

putchar是put character（给字符）的缩写。putchar(c)的作用是输出字符变量c的值，显然它是一个字符。

说明：putchar(c)中的c可以是字符常量、整型常量、字符变量或整型变量(其值在字符的ascii代码范围内)。

2.用getchar函数输入一个字符

   为了向计算机输入一个字符，可以调用系统函数库中的getchar函数(字符输入函数)。getchar函数的一般形式为：

getcahr()

getchar是get character（取得字符）的缩写。getchar函数没有参数，它的作用是从计算机终端（一般是键盘）输入一个字符，即计算机获得一个字符。

getchar函数只能接收一个字符。如果想输入多个字符就要用多个getchar函数。

注意：执行getchar函数不仅可以从输入设备获得一个可显示的字符，而且可以获得在屏幕尚无法显示的字符，如控制字符。