屌丝c++语言程序设计第二章 c++语言基础

本章介绍C++语言的一些基本知识，包括程序的基本结构、标识符、数据类型、变量、常量、基本的输入和输出方法等。通过本章的学习，应该能够编写简单的C++程序。
【重点和难点】
　　本章内容比较简单，没有难于理解的概念。重点内容包括：
　　◇ C++语言中的变量和常量的概念和使用；
　　◇ C++语言中输入输出库的使用。
【学习方法指导】
　　本章内容简单，但确是重要的基础知识，对基本概念应加强记忆与理解，为以后的学习打下坚实的基础。
【知识点】
　　标识符；关键字；变量；整型变量；浮点型变量
　　字符型变量；布尔型变量；字符串；常量；枚举变量
　　标准输出；标准输入；printf输出；scanf输入：

第一节 简单的c++程序

我们对这个程序逐行加以解释：

首先看下面这个简单的C++程序（为了方便起见，程序的每一行都加上了行号）。

程序2-1： 1．//simple.cpp是一个简单的C++程序
2．#include <iostream.h>
3．void main(void)
4．{
5. int i;
6． cout<<"Hello C++!";
7． cout<<"请输入一个整数：\n";
8． cin>>i;
9． cout<<"您输入的整数是：";
10． cout <<i;
11． cout <<'\n';
12．}　　请学习者自己键入这段程序，并自己编译、连接、运行该程序，输入不同的整数，看能否得到预期的结果。注意，程序中左边的数字是为了讲解的方便添加的，将该程序键入到开发环境的编辑窗口时，一定要略去这些数字。

　　（1）第一行是C++语言的注释。其中，"//"是C++语言的一种注释符号，自"//"开始，一直到本行结束，所有内容都会被当作注释对待。C++注释也可以写成下面的形式：
　　　　/*注释内容*/
　　　　即夹在"/*"与"*/"号间的部分是要注释的内容，例如，本句可以改为：
　　　　/*simple.cpp是一个简单的C++程序*/
　　我们进行程序设计时，这两种注释形式都会经常用到。它们的区别在于：前者只能注释一行内容，而后者可以注释多行内容。它可以用在程序的任何地方，编译器在编译时将这些信息忽略，注释就是用来帮助阅读和理解程序的信息，也可使用注释来帮助用户调试程序。
　　（2）第2行使用预处理指令#include将头文件iostream.h包含到程序中来， iostream.h是标准的C++头文件，它包含了输入和输出的定义。
　　（3）第3行定义了一个称为main的函数。
　　　◇ 一个函数有0个或多个参数，它们出现在函数名后的一对圆括号中。
　　　◇ 括号中的void表示main没有参数。
　　　◇ 一个函数可以有一个返回类型，它在函数名的左边。
　　　◇ main函数左边的返回类型为void，表示没有返回值。
　　　◇ C++程序的执行总是从main函数开始的。
　　（4）第4行是一个花括号，是main函数体开始的标记。
　　（5）第5行是一个语句。
　　　◇ 一个语句可能是定义或声明一个变量，也可能是得到一个数值的计算步骤。
　　　◇ 一个语句用分号(;)结尾，C/C++用分号来分隔语句。
　　　◇ 这个语句定义了一个整型变量i。
　　　◇ 一个变量能够保存一种特定类型的数据，整型变量能够保存一个整型数据。
　　（6）第6行也是一个语句。
　　　◇ 这个语句将字符串"Hello C++!"发送到cout输出流。
　　　◇ 一个字符串是一个用双引号包围的字符系列。
　　（7）第7行也是一个语句。
　　　◇ 这个语句将字符串"请输入一个整数："发送到cout输出流。
　　　◇ 字符串的最后一个字符（\n）是一个换行符。
　　　◇ 流是执行输入和输出的对象。
　　　◇ cout是C++标准的输出流，标准输出通常是指计算机屏幕。
　　　◇ 符号<<是一个输出运算符，带一个输出流作为它的左操作数，一个表达式作为它的右操作数。后者被发送到前者，字符串"请输入一个整数：\n"发送到cout的效果是把字符串打印到计算机屏幕上。
　　（8）第8行也是一个语句。
　　　◇ 这个语句将cin输入流抽取到变量i。
　　　◇ cin是C++标准的输入流，标准输入通常是指计算机键盘。
　　　◇ 符号>>是一个输入运算符，带一个输入流作为它的左操作数，一个变量作为它的右操作数。前者被抽取到后者，cin输入流抽取到变量i的效果是将键盘的输入值复制到变量i中。
　　（9）第9、10、11行分别是在屏幕上打印"您输入的整数是："、变量i和和换行符。这三行实际上可以综合为一个语句：
　　　　　　cout<<"您输入的整数是：" <<i <<'\n';
　　　　它的效果与使用三个语句是一样的。
　　（10）第12行的花括号是main函数体结束的标记。
　　　　运用第一章介绍的知识，我们在Visual C++6的开发环境里，编译、连接、运行该程序，可以得到下面的提示：
　　　　　　Hello C++!请输入一个整数：
　　　　假定我们输入整数5，即：
　　　　　　5↙
　　　　↙表示键入了"ENTER"键（或称为回车键），则得到运行结果：
　　　　　　您输入的整数是：5
　　通过这个实例，我们对C++程序的结构、语句、变量、函数、预处理指令、输入和输出等，已有了一个初步的印象，在后面的章节中，我们还将作更详细的介绍。
　　由于我们定义main( )函数的返回类型为void，所以最后就不用返回值了。如果我们定义main的返回类型的int，则要返回一个整型值：
　　　int main()
　　　{
　　　　…
　　　　return 0;
　　　}
　　要注意的是C/C++是区分大小写的，不能随便更改，cout是C++标准的输出流，而Cout不是，如果没有预先定义，编译器就不认识这个Cout。大多数C＋＋命令使用小写字母，大多数常量使用大写字母，而大多数变量是大小写混合使用。

第二节 标示符和关键字

标识符是一个字符序列，用来标识变量、函数、数据类型等。任何程序都离不开标识符，也就是说，不可能有没有标识符的C++程序。在程序2-1中，include、void、main、int、i、cin、cout等都是标识符。

标识符可以由大写字母、小写字母、下划线（_）和数字0~9组成，但必须是以大写字母、小写字母或下划线（_）开头。在C++语言程序中，大写字母和小写字母不能混用，比如Name和name就代表两个不同的标识符。在表2-1中，我们给出了几个正确和不正确的标识符实例。

 表2-1：正确和不正确的标识符实例 正确不正确smart5smart（不能数字开头）_decisionbomb?（有非法字符？）key_boardkey.board（有非法字符.）

标识符的命名规则：
　　1. 所有标识符必须由一个字母(a~z或A~Z)或下划线(_)开头；
　　2. 标识符的其它部分可以用字母、下划线或数字(0~9)组成；
　　3. 大小写字母表示不同意义, 即代表不同的标识符，如前面的cout和Cout；
　　在定义标识符时，虽然语法上允许用下划线开头，但是，我们最好避免定义用下划线开头的标识符，因为编译器常常定义一些下划线开头的标识符。
　　C++没有限制一个标识符中字符的个数，但是，大多数的编译器都会有限制。不过，我们在定义标识符时，通常并不用担心标识符中字符数会不会超过编译器的限制，因为编译器限制的数字很大（例如255）。
　　一个写得好的程序，标识符应该尽量有意义。 比如表示年可以用year，表示长度可以用length，表示累加和可以用sum等，这样的标识符本身就增加了程序的可读性，使程序更加清晰易懂。
C++语言的标识符经常用在以下情况中：
　　1. 标识对象或变量的名字
　　2. 类、结构和联合的成员
　　3. 函数或类的成员函数
　　4. 自定义类型名
　　5. 标识宏的名字
　　6. 宏的参数
第三节 基本数据类型

在C++中，数据具有不同的类型，类型定义了变量可存储的数值范围以及可进行的操作变量是用于内存中保存数据的，每个变量都必须有确定的数据类型，C++语言的数据类型如图2-1所示。
　　在图2-1中，把数据类型划分为基本的数据类型和复合的数据类型，我们也可把数据类型分为内置的类型和用户定义的类型两大类，用户定义的类型在使用以前，必须先定义，包括：结构、类、枚举和联合类型；内置的类型是指直接被C++提供的类型，也就是说，是除用户定义的类型以外的其它类型。

 

  图2-1 C++数据类型 

第四节 变量

 

　　变量就是机器一个内存位置的符号名，在该内存位置可以保存数据，并可通过符号名进行访问。变量有三个特征：
　　◇ 每一个变量有一个名字，其命名规则与标识符相同。
　　◇ 每一个变量有一个类型。
　　◇ 每一个变量保存一个值。如果需要变量保存某一个值，就把该值赋给变量。
　　为了提高程序的可读性，给变量命名时，应该注意使用有意义的名字，以帮助描述变量所保存的值。最好是一开始就坚持使用小写字母。例如：要用一个变量保存工资总额，可以使用total_payroll，也可以使用XYZ34作变量名，它们都是合法的名字。但使用前者比使用后者就更好，因为从变量名，就能大致知道它保存了什么样的值，便于记忆。
　　在使用一个变量之前，必须先定义。变量的定义的一般格式如下：
　　数据类型 变量名1[＝ 初始值1], 变量名2[＝ 初始值2], ...；
　　"数据类型"是指C++有效的数据类型，如int、double、long等。方括号中的内容是可选的，它是在变量定义时，给变量赋初值。下面是几个变量定义的实例：
　　long n; //定义了一个长整型变量n，未赋初值
　　double a, b = 0.5; //定义双精度型变量a、b，a未赋初值，b的初值为0.5

 

 

下面是一个使用变量的程序实例：

程序2-3： #include <iostream.h>
int main (void)
{
　1． int workDays = 5;
　2． float workHours, payRate, weeklyPay;
　3． workHours = 7.5; payRate = 38.55;
　4． weeklyPay = workDays * workHours * payRate;
　5． cout << "Weekly Pay = " << weeklyPay << '\n';
}

　　第一行定义了一个整型变量workDays，并初始化为5，表示一周的工作天数。
　　第二行定义了三个实型变量，分别表示每天工作的小时数、每小时应支付的薪水及每周应支付的薪水。
　　第三行是两个赋值语句。7.5 赋给变量workHours，38.55赋给变量payRate。
　　第四行是计算每周的工资，即三个变量workDays、workHours、payRate的积，*是乘运算符，结果保存在变量weeklyPay变量中。
　　第五行输出字符串"Weekly Pay = "、变量weeklyPay 的值和换行符。
　　本程序的运行结果如下：
　　　　Weekly Pay = 1445.625
　　如果我们定义一个变量时，没有给它赋初值，它的值是不定的。例如，在上面的第四行执行前，weeklyPay的值是不定的。
　　变量第一次赋值称之为初始化，变量在使用之前应当先初始化。

第五节 常量

在进行程序设计时，常常需要常量，例如圆周率π = 3.1416。在需要常量的地方，直接使用常量的数值的方法非常不好，例如：
　　//计算圆的面积
　　s = 3.1416*r*r;
　　...
　　如果我们需要提高计算精度，将π的值改为3.1415927进行计算，我们就不得不将程序中所有的π值从3.1416改为3.1415927，这不仅繁琐，更重要的是很容易出错。
　　C++允许定义符号常量，定义常量的一般形式为：
　　const 类型 名字 = 值;
　　其中，"类型"是指常量的类型，如short、long、double等，"名字" 是指常量的名字，而"值"是指赋给常量的、合适的数据类型的数值。 参看例2-7。

 

下面给出一个有常量定义的实例程序，这个程序是打印给定半径的圆的面积和周长。

 例2-6： void main()
{
　const double PI = 3.1415926535898; //定义圆周率常量PI
　double radius; //定义圆半径变量
　double area; //定义圆面积变量
　double circumference; //定义圆周长变量
　cout << "Enter radius : ";
　cin >> radius;
　area = PI*radius*radius;
　circumference = 2.0*PI*radius;
　cout << "Area of circle of radius " << radius << " is "
　<< area << " \n";
　cout << "and its circumference is " << circumference
　<< " \n";
}
运行该程序，并输入半径值10.0：
　Enter radius : 10.0↙
则输出结果为：
　Area of circle of radius 10.0 is 314.159
　and its circumference is 62.8319　　常量就是在程序运行过程中其值不发生变化的量。常量可分为直接常量与符号常量。直接常量就是平常我们所说的常数，例如：
　　`r` // r为字符型直接常量
　　3.1415926 // 3.1415926为双精度直接常量
　　符号常量就是用一个标识符代表某个常量。符号常量可用关键字const声明，其格式如下：
　　const 数据类型　常量名＝常数值；
　　例如：
　　const int a= 1234; //定义a为整型常量其值为1234
　　const char b=`a` //定义b 为字符型常量其值为a
　　在程序设计中，尽量使用符号常量来代替常数，这是一种好的编程习惯，这样可以增加程序的可读性、可维护性。例如，在数值计算中，我们会经常遇到一些常量，比如圆周率。如果把它定义成符号常量，当需要更改常量值的时候，只需要更改符号常量的定义语句即可。
　　也可以使用预处理语句定义符号常量，例如我们用：
　　#define PI 3.14159
　　定义符号常量PI，然后在程序中使用PI，跟使用常数3.14159的效果是一样的。编译器在编译时，把符号PI替换成3.14159，当需要修改PI的值时，只需要修改上面的语句即可。但是我们不推荐这样做：因为预定义符号与符号常量不同，在编译时使用常数替代了所有的预定义符号，这样在代码中相应位置实际都是常数。程序中过多的常数会导致程序代码量变大，而且在多个源文件中定义了同样的符号，会产生符号重定义的问题。使用常量优于＃define宏，优点在于可指定类型信息。 例2-7： const double PI = 3.1415927; //圆周率π
const long number = 49L;
const char TAB = '\t';
const char QUERY = '?';
const double SOMENUM = 1.235E75;

第六节 枚举类型

　我们常常需要一些整型常量表示某一个的数据范围。例如，假定需要表示汽车的颜色：
　　const int cRED = 0;
　　const int cBLUE = 1;
　　…
　　int auto_colour;
　　auto_colour = cBLUE;
　　上面的程序语句是用整型变量auto_colour表示颜色，下面的语句也是合法的：
　　auto_colour = -1;
　　…
　　显然，-1并不是所需要的颜色值。如果能够限定auto_colour在限定的整数范围（即规定的几种颜色集合）内取值就比较好，C++中的枚举类型能够让我们做到这一点。枚举类型是一种用户定义的数据类型，其一般定义形式为：
　　enum 枚举类型名
　　{
　　　标识符[=整型常数],
　　　标识符[=整型常数],
　　　...
　　　标识符[=整型常数],
　　};
　　"枚举类型名"右边花括号中的内容称之为枚举表，枚举表中的每一项称之为枚举成员，枚举成员是常量，也就是说，枚举表是整型常量的集合。枚举成员之间用逗号隔开，方括号中的"整型常数"是枚举成员的初值。
　　如果不给枚举成员赋初值，即省掉了标识符后的"=整型常数"时，则编译器为每一个枚举成员给一个不同的整型值，第一个成员为0，第二个为1，等等。当枚举类型中的某个成员赋值后，其后的成员则按依次加1的规则确定其值。下面是一个枚举类型定义实例：
　　enum Colour { eRED, eBLUE, eYELLOW, eGREEN,
　　eSILVERGREY,eBURGUNDY };
　　这样就定义了一个称之为Colour的枚举类型，编译器给枚举成员eRED，…，eBURGUNDY的值分别为0，…，5。 定义了枚举类型，就可以定义枚举类型的变量，其值限定为某一个枚举成员。例如：
　　Colour auto_colour;
　　…
　　auto_colour = eBURGUNDY;
　　Colour类型变量auto_colour只能取eRED，…，eBURGUNDY六个值中的一个，下面的语句将会出现编译错误：
　　auto_colour = 4;
　　我们也可以在定义枚举类型时，为枚举成员指定初值，例如：
　　enum Colour { eRED=5, eBLUE, eYELLOW, Egreen=30,
　　Esilvergrey=40,eBURGUNDY };
　　这时，eBLUE=6、Eyellow=7、Eburgundy=41。
　　由上述几种基本数据类型通过各种组合可以得到复合数据类型，这些数据类型在以后章节会有详细讲解。

如果一个变量只有几种可能的值，就可以把它定义为枚举类型。"枚举"，顾名思义，就是把这种类型数据可取的值一一列举出来。
　　例如，可以定义一个表示日期的枚举类型weekday：
　　enum weekday{sun,mon,tru,wed,thu,fri,sat};
　　这里enum是关键字，用于定义枚举数据类型，weekday是枚举类型的名字，枚举元素用标识符表示。
　　接下来我们可以用weekday来定义变量，例如：
　　weekday today,nextday;
　　C++语言也允许在定义枚举类型的同时定义枚举变量，例如：
　　enum weekday{sun,mon,tru,wed,thu,fri,sat}today,nextday;
　　这样，变量today和nextday就具有weekday类型，它们的取值只能是sun，mon，…，sta，例如可有：
　　today = sun;
　　nextday = mon;
　　if(today == sat)
　　nextday = sun //如果today是sat的话，那么nextday赋值为sun
　　C++编译器对枚举元素实际上是按整型常数处理。所以，就象前面所说的那样，当遇到枚举元素列表时，编译程序就把其中第一个标识符赋0值，第二、三、…个标识符依次赋1、2、…。因此，当枚举元素赋给枚举变量时，该变量实际得到一个整数值。例如：
　　today = sun;
　　是将0赋给today，而不是将字符串"sun"赋给today。赋值后：
　　cout<<today;
　　语句的输出结果是0。
　　我们也可以在枚举类型定义时指定枚举元素的值，例如：
　　enum weekday{sun = 7,mon = 1,tue,wed,thu,fri,sat};
　　这时sun的值是7，mon的值是1，而tue以后各元素的值，从mon的值开始，每次递增1，即tue的值为2，wed的值为3，…。如果不写mon = 1，则mon的值为8，tue的值为9，依此类推。
　　由于枚举元素是常量，所以我们在程序中不能对它们进行赋值，如"sun = 0；mon = 1；"将产生错误。
　　既然枚举元素就是整型值，那么它有什么存在的必要呢？至少有两个原因：一个是用标识符表示数值增加了程序的可读性，例如：
　　if(today == sat)
　　next = sun
　　就比
　　if(today == 6)
　　nextday = 0;
　　清楚多了；另一个重要的原因是：它限制了变量取值的范围，如现在today只能取sun~sat中的值。
　　注意：enum在 C++和C中使用的不同。下面的C语言语句定义了名为day的变量：
　　enum Days { Monday, Tuesday, Wednesday, Thursday, Friday };
　　enum Days day;
　　在C++中，定义为：
　　enum Days { Monday, Tuesday, Wednesday, Thursday, Friday };
　　Days day;
　　C++中定义了枚举类型数据后，程序可以把它当作一种类型使用，不需在类型名Days前加enum关键字。

第七节 输入与输出

C/C++语言本身并不带输入和输出（即I/O）功能，而是提供了输入输出库，也称为I/O库。通过I/O库，我们可以完成输入和输出的操作。大多数C程序使用一种称为stdio（标准I/O）的I/O库，该库也能够在C++中使用。但是，在C++程序中，一种称为iostream（I/O 流库）的I/O库用得更多。
　　在C++中，I/O使用了流的概念-字符（或字节）流。每一个I/O 设备传送和接收一系列的字节，称之为流。输入操作可以看成是字节从一个设备流入内存，而输出操作可以看成是字节从内存流出到一个设备。流是输入输出设备的另一个名字-一个文件、屏幕、键盘等。要使用C++标准的I/O流库的功能，必须包括两个头文件：
　　#include<iostream.h>
　　#include<iomanip.h>
　　iostream.h文件提供基本的输入输出功能，iomanip.h 文件提供格式化的功能。通过包含iostream流库，内存中就创建了一些用于处理输入和输出操作的对象。标准的输出流（通常是屏幕）称为cout，标准的输入流（通常是键盘）称为cin。
　　输出变量d的值到标准输出设备的语法形式如下：
　　cout << d;
　　注意：（<<）是双小于号，不是左移操作符，它是一种输出操作符，指出程序哪个流发送数据。
　　本语句表示传送d的值到标准的输出设备（由cout表示）。理解这个语句的一种方法是调用了函数operator<<，d是函数参数（关于函数调用，在第五章学习）。明确地说，为了输出d的值到cout，可以使用语句：
　　cout.operator<<(d);
　　由于"cout.operator<<(d);"写起来繁琐，我们更喜欢把它写成"cout << d;"。

对于C语言的程序中，使用的是stdio（标准I/O）库，在这个库中不仅定义了面向控制台（显示器和键盘）的输入输出，还分别定义了文件输入输出函数和面向内存的输入输出函数。在C++程序中，我们最常使用的是iostream（I/O 流库），它是基于面向对象的，可以实现stdio库的所有功能，通过它统一了标准I/O、文件和存储块的函数接口，使得对所有设备的操作看上去都一样，隐藏了内部实现。与标准C输入输出库的各种各样的函数相比，输入输出流更容易、更安全、更有效。为了保证兼容性，I/O流类和C标准输入输出函数库是可以共同使用的。
　　使用stdio库，需要在程序中包含stdio.h头文件，若使用iostream库，需要包含iostream.h头文件，如果要带参数的格式化输入输出，还需要包含iomanip.h头文件。
　　使用stdio库的标准输入输出，要使用scanf和printf函数，scanf函数是从标准输入（键盘）设备读入，printf是向标准输出设备（显示器）输出。
　　iostream库在iostream.h中预定义了四个全局的流对象：cout、cerr、clog和cin，用于标准输出和输入，cout和cin在程序设计中会经常用到。cout流对象控制向控制台（显示器）的标准输出，cin控制从控制台（键盘）输入。

本章小结

本章讲述了C++语言的基本知识。
　　◇ 在C++语言中，语句、变量、函数、预处理指令、输入和输出等，是重要的概念，应该在编程实践中逐渐掌握这些概念和它们的应用。
　　◇ 标识符是用来标识变量、函数、数据类型等的字符序列。C++中的标符可以由大写字母、小写字母、下划线（_）和数字0~9组成，但必须是以大写字母、小写字母或下划线（_）开头。C++语言中预定义了一些标识符，称之为关键字，它们不能被再定义。
　　◇ 布尔型、字符型、整型、浮点型和空类型是基本数据类型。指针、数组、引用、结构和类可以通过基本数据类型进行构造，称之为复合数据类型。
　　◇ 变量就是机器一个内存位置的符号名，在该内存位置可以保存数据，并可通过符号名进行访问。为了提高程序的可读性，给变量命名时，应该注意使用有意义的名字。变量第一次赋值称之为初始化，变量在使用之前应当先声明。
　　◇ 常量是在程序运行过程中，其值不能改变的量。
　　◇ C++语言本身没有输入输出功能，而是通过输入输出库完成I/O操作。C程序使用的stdio（标准I/O）I/O库也能够在C++中使用；另外C++语言还提供了一种称之为iostream（I/O 流库）的I/O库。

课后习题

一、选择题：

1．C++程序的执行总是从哪里开始的？
a.main函数
b.第一行
c.头文件
d.函数注释
2．字符型数据在内存中的存储形式是：
a.原码
b.补码
c.反码
d.ASCII码
3．下面常数中不能作为常量的是
a.0xA5
b.2.5e-2
c.3e2
d.0583
4．以下选项中是正确的整型常量的是：
a.1.2
b.–20
c.1,000
d.6 7 4
5．以下选项中不是正确的实型常量的是：
a.3.8E-1
b.0.4e 2
c.–43.5
d.243.43e-2
二、改错题

1．指出下面程序中的错误
　void main( )
　{
　　cout<<"This is a string"
　}


2．指出下面程序中的错误
　#include <iostream.h>
　void main( )
　{
　　cin>>x;
　　int p=x*x;
　　cout<<"p=<<p<<\n";
　}


3．指出下面程序中的错误
　#include <iostream.h>
　void main( )
　{
　　　int i,j;
　　　i=5;
　　　int k=i+j;
　　　cout<<"i+j="<<k<<"\n";
　}


4．"A"与'A'是等价的。

三、编程题：

1．写出能被编译、连接和运行的、最小的C++程序。


2．编写一个程序，实现一个温度格式转换器。接受用户输入华氏温度，要求输出摄氏温度（换算公式为C＝5（F－32）/ 9），输入输出要有文字说明。


3．编写程序，计算圆周长、面积及球体积。要求用户输入半径，输出计算结果（要有文字说明）。


4．给出下面程序输出的结果：
　#include <iostream.h>
　void main( )
　{
　　int a;
　　char ch;
　　ch='a' ;
　　ch++;
　　a=ch;
　　cout<<a<<',';
　}


5．给出下面程序输出的结果：
　#include <stdio.h>
　void main()
　{
　　int a=10;
　　float b=-5.2;
　　printf("a=%#o,b=%08.3f",a,b);
　}


6．给出下面程序输出的结果：
　#include <stdio.h>
　void main()
　{
　　int a=-3;
　　printf("%d,%o,%x,%X,%6x\n",a,a,a,a,a);
　}


7．给出下面程序输出的结果：
　#include <stdio.h>
　void main()
　{
　　char ch='a';
　　int a=65;
　　printf("%c,%d,%3c\n",ch,ch,ch);
　　printf("%c,%d,%3d\n",a,a,a);
　}


8．给出下面程序输出的结果：
　#include <stdio.h>
　void main()
　{
　　printf("%3s,%-5.3s,%5.2s\n","hello","hello","hello");
　}