C++程序设计基础第二版（高等教育出版社）习题答案

习题一 参考答案

第1章 C++语言概述

一、选择题：

1. D 2. A 3. D 4. A 5. A 6. D 7. C 8. B 9. B

二、改后如下：

#include //预处理指令，原程序缺少“#”号

int main() //定义主函数，原程序缺少返回值类型“int”（也可为“void”） {

cout<<\ //语句必须以“；”结尾。原程序缺少“；”号 return 0; //原程序缺少返回值语句 }

运行后输出：

Hello World！

三、简答题

1、解答：在较大或较复杂的C++程序中，加上相关的注释信息，解释相应的程序，可提高程序的可读性。

2、C++语言有两种注释：

（1）C++型注释。从“//”开始，该行中所有字符都被作为注释处理。 （2）C型注释。“/*”表示注释的开始，“*/”表示注释的结束，在“/*”、 “*/”之间的字符均被视作注释。

3、C型注释主要用于大块注释，而且C++型注释可以嵌在C型注释中。

四、程序设计题

1、编写一个程序，在屏幕上输出“I can use C++”。 解：

#include int main() {

cout<<\ return 0; }

运行后输出：

I can use C++

2、参照例题, 设计一个C++程序，输入两门课程的成绩，求总成绩。 解：

# include main() {

int s1,s2,sum;

cout<<\请输入两门课程的成绩：\

1

cin>>s1>>s2; sum=s1+s2;

cout<<\

}

3、参照例题,设计一个C++程序，输入a、b两个整数，输出其中的最小数。 解：

#include void main(void) {

int min(int x,int y); int a,b,m;

cout<<\cin>>a>>b; m=min(a,b);

cout<<\}

int min(int x,int y) {

int z; if (x

z=y; return z; }

习题二 参考答案

第2章 数据类型和表达式

一、 选择题

1. C 2. B 3. B 4.B 5.A 6 B 7.D 8.C 9. D

11.D 12..A 13.D 14.A 15.B 16.B 17.B 18.C 19.A

二、 填空题

1、基本类型 导出类型 用户定义类型 2、6

3、iostream #include < iostream > 4、一个int型数据占用的字节数 5、0

2

10. C

6、7 7、100 8、？：

9、false false true 10、（50 < x ）&& (x <= 100 )或 ! ( ( 50 > x ) | | ( x > 100 ) ) 11、(m)*100 + ((m/10))*10+m/100 12、非零 13、1

14、字母 数字 下划线 15、4.5

三、 问答题

1. C++语言中用数值“1”表示“真”，数值“0”表示“假”。

2. 答：字符常量与字符串常量的主要区别在于：（1）定界符不同。字符常量使用单引号，而字符串常量使用双引号。（2）长度不同。字符常量的长度固定为1，而字符串常量的长度，可以是0，也可以是某个整数。（3）存储要求不同。字符常量存储的是字符的ASCII码值，而字符串常量除了要存储有效的字符外，还要存储一个结束标志?\\0?。

3. (1) x+a%3*(int)(x+y)%2/4 x=2.5,a=7,y=4.7

答：上述表达式=2.5+1*（int）7.2%2/4 = 2.5+1*7%2/4 = 2.5 (2) (float)(a+b)/2+(int)x%(int)y a=2,b=3,x=3.5,y=2.5 答：上述表达式=（float）5/2+3%2 = 2.5+1 = 3.5

4．答：C++语言中的数据类型有：整型（短整型，整型，长整型）；字符型；逻辑型；枚举型；实型（单精度，双精度，长双精度）；引用型（指针，引用）；复合型（结构，联合）；空类型。

5. (1)1/3 int (2) 48L long

(3) 5 % 3 int (4) x*3/y double (5) ?x?+20 int (6) (int )y int (7) y != 10 bool (8) x<1 || x>10 bool (9) x>10 ? x : sqrt (x) int或float (10) x && y bool (11) true bool (12) (char) (x+10) char (13) 1.0 /3 float (14) sizeof (float) int (15) x,y,x+y, double

说明：（9）题，如果x>10成立，表达式值的类型为int，如果x>10不成立，表达式值的类型为float。（15）题，为逗号表达式，x+y的值即为整个表达式的值，因而值的类型为double。bool型在C++用int代替，true值为1，false值为0。

6. 数值常量有：25，18，-3.67, 12.8

字符常量有：?4?，\\?，?\\32?

字符串有：“4”，“x2”， “1949.10”， “sy1.cpp”, “\\n” 保留字：cin ，int，endl，if 运算符：+ 标点：?

非法数据：“float x ,y “ ; ， 3ab 变量：x1，K_name

3

7.设程序中有说明语句: int a=20; double x=4.7; char r= ?a?; 试求出下列每个表达式的值（假定各表达式互不影响）。~

答案 答案 （1）a++ 20 (2) ++r 98

(3) 1+a/3%4 3 (4) 10*sizeof( int ) 40 (5) char (a+20) ( (6)a= =r || a= =floor(x) 0 (7) a/9.0 2.222222 (8)x=pow(3,5) 273.000000 (9) x=(a++,r++) 97.000000 (10) ceil(x-0.5) 5.000000 (11) a=abs(a)%8-10 -6 (12)x=fabs(-27.2)+6 33.200000 (13)floor(x+0.5) 5.000000 (14) ceil((x-=0.5)-0.5) 4.000000 (15)floor(x*1000+0.5)/1000 4.700000 (16)floor(x+0.5) 5.000000

(17)floor(x*1000)/1000 4.700000 (18)a+rand()@ 某一个随机整数

说明：函数ceil（x），返回大于等于x的最小整数；floor（x），返回小于等于x的最大整数；rand（），返回0~32767之间的整数。

8.设程序中有说明语句

int x=20; float y=4.7; char ch = ?k?;

试求出下列每个表达式的值（假定各表达式互不影响）

答案 答案 (1) x==0 0 (2) x!=y 1 (3) x++ >21 0 (4) ?a? == ?A? 0 (5) ch != 0 1 (6) x>0 && y>0 1 (7) x>0 && 1 1 (8) y>0 && 0 0 (9) !(x||y)==!x&&!y 0 (10) x++ !=20 || y 1 (11) !! ch==ch 0 (12) !(x&&y)==!x||!y 1

说明：C++语言提供了三种逻辑运算符：！，&&，||，其中！逻辑非的优先级最高，&&逻辑与次之，||逻辑或最低。！逻辑非是右结合性，&&逻辑与和||逻辑或是左结合性。

四、编程题

1：编写一个程序，从键盘输入半径和高，输出圆柱体的底面积和体积。

#include using namespace std; void main() {

double r, h, area, volume; cout<<”请输入半径:”; cin>>r;

cout<<”请输入高:”; cin>>h;

area=3.14*r*r; volume=area*h;

cout<<”底面积是: ”<

2. 设计一个程序，输入一个华氏温度值，要求输出其对应的摄氏温度值。温度转换公式为：c=(f-32)*5/9。

4

解：

# include using namespace std; void main() {

float c,f;

cout<<\请输入华氏温度：\cin>>f;

c=(f-32)*5/9;

cout<<\}

3．用C++语言写出下列要求的表达式：

? 判断char型变量ch是否为大写字母。 ch>=65 && ch<=?Z?

? 设y为int变量，判断y是否为奇数。 y%2 ==1

? 设x、y、z都为int型变量，描述“x、y和 z中有两个为负数”。 (x<0 || y<0 || z<0 ) && (x*y*z>0)

#include using namespace std; void main() {

char ch; cin>>ch; if(ch>='A' &&ch<='Z')

cout<<\cout<<\

cin>>t;

else int t;

if(t%2==1)

cout<

cin>>x>>y>>z;

else int x,y,z;

if((x<0||y<0||z<0) && x*y*z > 0)

cout<<\、y和 z中有两个为负数\

}

4. 编写一个程序，从键盘输入两个整型的数，在屏幕上分别输出这两个数的和、差和积。

#include using namespace std; void main() {

int x,y; cin>>x>>y;

cout<<\

5

cout<<\cout<<\

}

5. 编写一个程序，从键盘输入两个数，分别求出这两个数的平方和和立方和，在屏幕上予以输出。

#include using namespace std; void main() {

int x,y;

cin>>x>>y;

cout<<\

cout<<\

}

6. 编写程序，从键盘输入某一字母的ASCII码，如：97（字母a），98（字母b），65（字母A）等，在屏幕上输出给字母。

#include using namespace std; void main() {

int x;

cout<<\请输入一个65~90之间,或者97~122之间的一个整数:\cin>>x;

char ch = (char)x; cout<

}

习题三 参考答案 第3章 结构化程序设计

一、选择题

1．A 2．C 3．C 4．B 5．B 6．D 7．B 8．D 9．A 10. C 11. C 12. B 13. C 14. B 15. B 16. A 17. C 18. D 19. D

二、填空题

1、12

2、141，64，452 3、52 4、210

5、顺序结构 选择结构 循环结构 6、23

6

习题四 参考答案

第4章 数组、指针

一、选择题

1.B，D 2.B 3.A 4.C 5.C 6.D 7.B 8.B 9.A 10.C

11.A 12.C 13. C 14.D 15.B 16.D 17.C 18.C 19.A 20.C 21.B 22.B 23.A

二、填空题

1. 0 ， 0 , 编译出错 。 2． 符号常量 3．值 ，地址 4. 21 5.

1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 6. fedcba

7. x=1.5 y=2.5z=4

8. 20 50 50 41

9. 101，101 10. 300 11. tuesday sunday 12. k=p 13. f

三、问答题

1. 什么是数组？

答：数组是若干个同类数据元素的集合。

2. 一维数组与二维数组在内存中是如何存储的？

答：一维数组a[n]定义后，系统分配n*k个连续存储单元，用于存放数组元素值，其中k=元素占用字节数。

二维数组a[m][n]定义后，系统分配m*n*k个连续存储单元，用于存放数组元素值，其中k=元素占用字节数。

存放方式为按行存放，即先存第一行元素，再存第二行元素，依次把各行元素存入一串连续的存储单元中。

7

3 有如下数组定义：int a[20];

指出该数组的数组名、数组元素类型、数组元素个数、第一个数组元素的下标值和最后一个数组元素的下标值。

答：数组名为a，数组元素类型为整型，数组元素个数为20，第一个数组元素的下标值为0和最后一个数组元素的下标值为19。

4. 什么叫指针？有哪些类型的指针？

答：所谓指针就是变量、数组、函数等的内存地址。

指针变量按定义格式大致可分为五种：指针变量、指针数组、指向一维数组的指针变量、返回指针值函数、函数指针变量。

5. 指针变量按定义格式分为哪5类？每类指针变量如何定义？ 答：指针变量按定义格式大致可分为五种：指针变量、指针数组、指向一维数组的指针变量、返回指针值的函数、函数指针变量。 （1）指针变量的定义格式如下：

〔存储类型〕 <类型> *<指针变量名> ；如： int b, a[10], * p; （2）指针数组的定义格式如下：

〔存储类型〕 <类型> *<数组名>[<数组长度>]； 例如： char c[3 ][4]={ \char *pc[3 ]={c[0],c[1],c[2]};

（3）指向一维数组的指针变量可用于处理二维数组的运算问题，其定义格式为： <类型> (*<指针变量名>)[<数组列数>]; 如：int (*p)[3];

（4）函数可返回一个指针值，该指针指向一个已定义好的任一类型的数据。定义返回指针值的函数格式为：<类型> *<函数名>(<形参>){<函数体>}

如：float * f ( float x) {? } 定义了一个返回实型指针的函数f ()，该函数的形参为实型的x。 （5）函数指针变量是用于存放函数指针的变量，也即存放函数入口地址的变量。函数指针变量的定义格式为：

<类型> (*<变量名>) (<参数表>)；

6. 定义一个整型指针变量pi，用什么方法才能使pi：（1）指向整型变量i，（2）指向整型一维数组a的首地址，（3）指向整型二维数组b的首地址。 答：

（1）pi=&i;

（2）pi=a;（或者pi=&a[0];） （3）pi=&a[0][0];(或者pi=a[0];)

7. 叙述二维数组a的行地址、行首地址、元素地址的概念、作用及表示方法，写出元素a[i][j]值的表示方法。

答：行首地址是第i行第0列的地址，第i行首地址表示方式有：*(a+i)、a[i]、&a[i][0]，用

8

于指向数组元素的指针变量。

行地址是第i行的地址，行地址表示方式有：a+i、&a[i]，用于指向一维数组的指针变量。注意，二维数组名a是表示第0行的行地址&a[0]，而不是第0行第0列的元素地址&a[0][0]。 第i行第j列元素a[i][j]地址的表示方式有：a[i]+j 、*(a+i)+j 、&a[i][0]+j、&a[i][j]。 第i行第j列元素值的表示方式有：*(a[i]+j) 、 *(*(a+i)+j) 、 *(&a[i][0]+j)、a[i][j]。

8. 引用类型变量与其相关变量有何关系？引用类型变量主要用于什么场合？

答：引用类型变量与其相关的变量使用相同的内存空间。

在C++中引入引用类型的主要目的是为了函数参数传送提供方便。由于引用类型变量与相关变量使用相同的内存空间，所以用引用类型变量作为函数形参时，形参与实参变量使用相同的内存，在函数内对形参的运算就是对实参的运算，因此可通过参数返回函数运算结果。

9. 对字符串指针变量，能否用cin、cout对其输入/输出字符串？能否对字符串指针变量进行赋值运算？字符串指针变量能否作为字符串处理函数的参数？

答：不能将字符串用cin直接输入指针变量。但可将指针变量所指字符串用直接输出。 可以对字符串指针变量进行赋值运算。

字符串指针变量能作为字符串处理函数的参数。

四、程序设计题 1：编程对用户输入一个含有10个整数的一维数组，分别计算数组中所有正数和所有负数的和。

程序代码如下：

#include using namespace std;

void main( ) {

int a[10],I,sum0=0,sum1=0;

cout<<”please input 10 number:”<

cin>>a[I];

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

if(a[I]>=0) sum0+=a[I]; else sum1+=a[I];

cout<<”正数和：”<

2：通过循环按行顺序为一个5*5的二维数组赋1—25的自然数，然后计算该数组的左下半三角元素之和并输出左下半三角元素。

程序代码如下：

#include

9

using namespace std; void main( ) {

int a[5][5],I,j,n=1,sum=0; for(I=0;I<5;I++) for(j=0;j<5;j++)

a[I][j]=n++; for(I=0;I<5;I++) {

for(j=0;j

sum+=a[I][j];

cout<

cout<<’\\n’; }

cout<<”该数组左下半三角的元素之和为：”<

3.有一个数组，内放10个整数，要求找出最小的数和它的下标,然后把它和数组中最前面的元素对换。

程序代码如下：

#include using namespace std; void main() {

int a[10];

int i,min,j,temp;

cout<<\请输入10个数\\n\ for(i=0;i<10;i++) cin>>a[i];

min=a[0];j=0;

for(i=1;i<10;i++) if(min>a[i]){

min=a[i]; j=i; }

if(j!=0){

temp=a[0]; a[0]=a[j]; a[j]=temp; }

cout<<\交换后数组\\n\ for(i=0;i<10;i++) cout<

10

4.有n个数，已按由小到大顺序排列好，要求输入一个数，把它插入到原有数列中，而且仍然保持有序，同时输出新的数列。

程序代码如下：

#include using namespace std;

void main() {

int i,n,j;

int a[11]={10,20,30,40,50,60,70,80,90,100}; for(i=0;i<10;i++) cout<

cout<

cout<<\输入插入数\\n\cin>>n; j=9;

while(j>=0&&n

a[j+1]=a[j]; j--; }

a[j+1]=n;

cout<<\插入后的数组\\n\ for(i=0;i<11;i++) cout<

cout<

5.水仙花数。如果一个正整数等于组成该数的各个数字的立方和，则称该数为水仙花数，亦称阿姆斯特朗数。如407=43+03+73，407是一个水仙花数。试编写求100～999之间的所有水仙花数的程序。

程序代码如下：

#include #include using namespace std;

void main() {

int i,j,k,t;

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

for(k=0;k<=9;k++) {

t=i*100+j*10+k;

if(i*i*i+j*j*j+k*k*k==t)

cout<

11

}

6. 输入一个n×n矩阵各元素的值，求出两条对角线元素值之和。

程序代码如下：

#include using namespace std; #define N 5 void main() {

int a[N][N]; int i,j,sum=0;

cout<<\请输入\数\\n\ for(i=0;i>a[i][j];

cout<<\二维数组为：\\n\ for(i=0;i

for(j=0;j

cout<

for(i=0;i

sum=sum+a[i][i]+a[i][N-i-1] ; if(i==N-i-1)

sum=sum-a[i][N-i-1]; }

cout<<\对角线元素和为 \}

7.编写一程序，将两个字符串连接起来，不用strcat函数。

程序代码如下：

#include using namespace std; void main() {

char st1[80],st2[20]; int i,k;

cout<<\请输入两个字符串\\n\ cin>>st1>>st2; i=0;

while(st1[i]!='\\0')

i++; k=0;

while(st2[k]!='\\0')

12

{

st1[i]=st2[k]; k++; i++;

}

st1[i]='\\0'; cout<

8.编写一程序，将字符串s1和s2比较，如果s1>s2，输出一个正数；s1=s2，输出0；s1

程序代码如下：

#include #include

using namespace std; void main() {

int i,resu;

char s1[100],s2[200];

cout<<\ gets(s1);

cout<<\ gets(s2); i=0;

while((s1[i]==s2[i])&&(s1[i]!='\\0')) i++; if(s1[i]=='\\0'&&s2[i]=='\\0')

resu=0; else

resu=s1[i]-s2[i];

cout<<\}

9．编写一程序，将字符数组s2中的全部字符拷贝到字符数组s1中。不用strcpy函数。拷贝时，’\\0’也要拷贝过去。’\\0’后面的字符不拷贝。

程序代码如下：

#include #include using namespace std;

void main() {

char s1[80],s2[80]; int i;

cout<<\ cin>>s2;

for(i=0;i<=strlen(s2);i++)

13

s1[i]=s2[i];

cout<<\

}

10．编写程序，在堆内存中申请一个float型数组，把10个float型数据0.1、0.2、0.3、?、1.0赋予该数组，然后使用float型指针输出该数组的各元素值并求出其累加和。

程序代码如下：

#include using namespace std; void main()

{ float *p= new float[10]; //在堆内申请一个float型数组 int i;

float sum=0.0;

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

*(p+i)=(i+1)*0.1; //给数组赋值0.1，0.2，??，1.0 cout<<*(p+i)<<'\\t'; //输出数组值

sum+=*(p+i); //求和 }

cout<<\ }

11．编写一个函数f，将传入此函数的直角坐标值转换为极坐标值，并返回主调函数中。求极

x2?y2坐标的公式是：c= q=arctan(y/x)

程序代码如下：

(1) 两值均以指针形参带回。

void fun(double x,double y,double *c,double *q) {

cout<

(2) 两值均以引用形参返回。

void fun(double x,double y,double &a,double &b) {

a=sqrt(x*x+y*y); b=atan(y/x); }

12．编写一个程序，实现在命令行中以参数的形式接收两个整数，输出这两个整数的和。

14

程序代码如下：

#include #include using namespace std;

void main(int argc,char *argv[]) {

int a,b;

a=atoi(argv[1]); b=atoi(argv[2]);

cout<

习题五 参考答案

第5章 函数

一、选择题

1：A 2：C 3：B 4：B 5. B 6. B 7. D 8. C 9. C 10. C 11. B 12. B 13. B 14. A

二、问答题

1. 什么是函数？函数是如何分类的？ 答：函数是实现特定功能的相对独立的程序段 .从不同的角度可以将函数分成 : 库函数和用户自定义函数、主调函数和被调函数、无参函数和有参函数。

2. 自定义函数如何定义？有哪三种调用方式？

答：自定义函数定义一般格式为：〔 类型 〕 < 函数名 > （ < 形式参数表 > ）{< 语句序列 > }函数调用的方式通常有三种，即：函数调用语句、函数表达式、函数参数。

3. 在函数的调用过程中，实参传送给形参有哪两种方式？这两种传送方式有什么区别？

答：在函数的调用过程中，实参传送给形参有“值传递”和“传地址”两种方式。

所谓的“值传递“，调用函数时，系统给形参分配存储单元，并将实参的值传递给对应的形参；在函数执行时，都是形参参与运算；函数返回时，形参值的改变不影响实参，实参保持原来的值。

所谓的“传地址”，当函数的形参为数组时，其实参只能是相同类型的数组。调用函数时，系统将实参数组的起始地址传递给形参数组，两个数组占用相同的内存空间单元。这时，在执行函数时，形参数组中各元素值的变化会使实参数组元素的值同时发生变化。

15

4. 什么情况下必须使用函数的原型说明？在函数的原型说明的形参表中，形参名是否是必须的？为什么？

答：在 C++ 程序中，当函数调用在前、函数定义在后时，则应在主调函数中，在调用前增加对被调函数的原型说明。在函数原型说明中，可只写形参的数据类型，而省略形参名。这是因为：函数原型说明的目的是告诉编译程序，该函数返回值的类型、参数的个数和各参数的类型，以便其后调用该函数时，编译程序对该函数的调用作参数的类型、个数及函数的返回值是否有效的检查。仅给出每一个参数的类型，实际上也已说明了参数的个数。

5. 什么是递归？递归方法解决问题时，必须分析清楚哪三个问题？

答：函数的递归调用指的是在一个函数定义的函数体中又出现直接或间接地调用该函数本身。利用递归方法解决问题时，必须注意三点：递归的公式、递归的结束条件、递归的限制条件。

6. 什么是作用域？在 C++ 中，作用域分成哪 5 类？在前 4 类作用域中，变量有效作用区域是什么？

答：作用域是变量在程序中可引用的区域。

在 C++ 中，作用域共分成五种：块作用域、文件作用域、函数原型作用域、函数作用域和类作用域。

(1) 块就是用花括号括起来的一部分程序。在块内说明的变量具有块作用域，其作用域从变量的说明处到块的结束处。

(2) 在函数外定义的变量或用 extern 说明的变量具有文件作用域。具有文件作用域的变量缺省的作用域是：从定义变量的位置开始到该源程序文件结束，即符合变量先说明、后使用的原则。

(3) 在函数原型的参数表中说明的变量所具有的作用域称为函数原型作用域，它从其说明处开始，到函数原型说明的结束处结束。

(4) 函数作用域是指在函数内定义的标识符在其定义的函数内均有效，即不论在函数内的任一地方定义，均可以引用这种标识符。 (5) 类的数据成员具有类作用域。

7. 什么是局部变量与全局变量？局部变量与全局变量的作用域是什么？什么是静态变量与动态变量？静态变量与动态变量分别存放在什么存储区？静态变量与动态变量各自生存期是什么？ 答：局部变量指的是在一个函数内部定义的变量或在一个块内定义的变量。全局变量指的是在函数外定义的变量。全局变量具有文件作用域。

当具有块作用域的局部变量与具有文件作用域的全局变量同名时，局部变量优先。在块作用域内可通过作用域运算符“ :: ”来引用与局部变量同名的全局变量。 动态变量指的是在程序的执行过程中，为其分配存储空间的变量。静态变量指的是在程序开始执行时系统就为变量分配存储空间，直到程序执行结束时，才收回为变量分配的存储空间。 动态变量存储在内存中的动态存储区；静态变量存储在内存中的静态存储区。静态变量的生

16

存期为整个程序的执行期间。动态变量的生存期仅在变量的作用域内。

8. 如何定义内联函数？使用内联函数的实质与目的是什么？

答：在类型前加关键字 inline 定义的函数称为所谓内联函数， 定义格式为：inline < 类型 > < 函数名 > （ < 形式参数表 > ）

{ 函数体 }内联函数的实质就是在编译时把函数的函数体直接插入到调用处。其目的是降低系统的开销，提高程序的执行效率。

9. 什么是函数的重载？调用重载函数时，通过什么来区分不同的重载函数？

答：函数的重载是指用重名函数完成不同功能的函数运算。

定义的重载函数的形参必须不同，即：或者参数个数不同或者数据类型不同。只有这样，编译器才有可能根据不同的参数去调用不同的重载函数。

三、分析程序并写出结果

1.运行结果： 10

5

2. 运行结果： 0 1 2 3

4

3. 运行结果：

5 8 13 21 34 55 89 144 233 377

4. 运行结果： 400 120

5.运行结果： 12

16

6.运行结果：

8

7.运行结果： this is a book. THIS IS A BOOK.

四、程序设计题

1．编写函数将化氏温度转换为摄氏温度，公式为C=（F-32）*5/9；并在主函数中调用。

17

程序如下：

#include using namespace std; float fun(float f) {

float c;

c=5.0/9*(f-32); //注意这里是5.0/9，不能写成5/9 return c; }

void main() {

float x;

cout<<\请输入一个温度值 \ cin>>x;

cout<<\转换值为 \}

2．分别利用非递归和递归的方法编写函数求斐波那契数列第n项。

程序如下：

（1）非递归：

#include using namespace std; float feb(int n0,int n1) {

return n0+n1; }

void main() {

int a=1,b=1,c,i;

cout<

c=feb(a,b); cout<

cout<

（2）递归：

#include using namespace std; float feb(int n) {

if(n==0 )

return 1; else if(n==1)

18

return 1; else

return feb(n-1)+feb(n-2);

}

void main() {

for(int i=0;i<20;i++) {

cout<

cout<

3．编写函数将字符串按逆序存放。

程序如下：

#include #include #include void main() { int i,n;

char s[100],temp;

cout<<\ gets(s); n=strlen(s);

for(i=0;i

{ temp=s[i];s[i]=s[n-i-1]; s[n-i-1]=temp; } cout<<\ puts(s); }

4．编写函数实现字符串拷贝功能。

程序如下：

#include #include using namespace std; void main()

{ char s1[80],s2[80]; int i;

cout<<\ cin>>s2;

for(i=0;i<=strlen(s2);i++) s1[i]=s2[i]; cout<<\}

5．编写函数利用数组名作参数计算数组arr[3][4]所有元素的和。

19

程序如下：

#include using namespace std;

int sum(int a[][4],int n,int m) {

int p=0,i,j; for(i=0;i

void main() {

int b[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; cout<

6．利用重载编写求整数绝对值和求实数绝对值两个函数。

程序如下：

#include using namespace std; float fabnum(float num1) {

float num;

if(num1>=1e-6) num=num1; else num=-num1; return num; }

int fabnum(int num2) {

int num;

if(num2>=0) num=num2; else num=-num2; return num; }

void main() {

float num1; int num2;

cout<<\ cin>>num1;

cout<<\ cout<<\ cin>>num2;

cout<<\}

20

#include #include void main() {

char ch;

fstream infile,outfile;

infile.open(“data.dat”,ios::in); if(!infliel) {

cout<<”data.dat文件不能打开”<

outfile.open(“data1.dat”,ios:out); if(!outfile) {

cout<<”data1.dat文件不能打开”<

while(infile.get(ch)) {

cout<

cout<

2. 编写一个程序，统计文件abc.txt的字符个数

程序代码如下：

#include #include #include void main() {

fstream file;

file.open(“abc.txt”,ios::in); if(!file) {

cout<<”abc.txt can’t be opened”<

41

abort();

}

char ch; int i=0;

while(!file.eof()) {

file.get(ch); i++; }

cout<<”文件字符个数：”<

}

3. 编写一个程序，将abc.txt文件的所有行加上行号后写到abc1.txt文件中。

程序代码如下：

#include #include #include void main() {

fstream outfile,infile;

infile.open(“abc.txt”,ios::in); if(!infile) {

cout<<”abc.txt can’t be opened!”<

outfile.open(“abc1.txt”,ios::out); if(!outfile) {

cout<<”abc1.txt can’t be created”<

char buf[80]； int i=0;

while(!infile.eof()) {

infile.getline(buf,sizeof(buf));

outfile<

cout<<”abc.txt=>abc1.txt 转换成功”<

42

outfile.close(); }

43

7．利用全局变量并编写函数统计数组中奇数和偶数的个数。

程序如下：

#include #include using namespace std; int oddnum=0,evennum=0; void main() {

int n,i,a[100];

cout<<\ cin>>n;

cout<<\ for(i=0;i>a[i];

cout<<\ for(i=0;i

cout< for(i=0;i

if(a[i]%2==0)

oddnum++;

else

evennum++; }

cout<<\ cout<<\}

8. 编写一个函数来检验输入的一个字符是大写字母还是小写字母或不是26个英文字母。

程序代码如下：

#include using namespace std; char ch;

int fun(char ch) {

int I;

if((ch>=’a’)&&(ch<=’z’)) I=1;

else if((ch>=’A’)&&(ch<=’Z’)) I=2; else I=3; return I; }

21

void main( ) {

int I;

cout<<”请输入一个字符 :”; cin>>ch; I=fun(ch); If(I==1)

cout<<”是小写字母！”<

cout<<”是大写字母！”<

cout<<”是其他字符！”<

9. 使用函数重载的方法定义两个重名函数，分别求出整型数的两点间距离和浮点型数的两点间距离。

程序如下：

#include #include

using namespace std;

double func(int,int,int,int);

double func(double,double,double,double);

void main( ) {

cout<

cout<

double func(int x1,int y1,int x2,int y2) {

return sqrt((x1-x2)* (x1-x2)+(y1-y2)*(y1-y2)); }

double func(double x1,double y1,double x2,double y2) {

return sqrt((x1-x2)* (x1-x2)+(y1-y2)*(y1-y2)); }

习题六参考答案 第6章 结构体与枚举类型

22

一、选择题

1. C 2.D 3.A 4.B 5. A 6. D 7. C 8. C 9. B 10. B 11.D 12. A 二、填空题 1. 运行结果是： 1 2 3 4 5 6 7 8 9

10

2．运行结果是： Li 89.6

3. 运行结果是： W 90.5

4．运行结果是： 10 A 54.6

5．运行结果是： 0 1 2 3 4 5 6

6．运行结果是： mon sat

7. 答案：(1) 0.0 (2)sum+st[i].mark[j]

8. 答案：(1) strcmp(s[i].name, a)= = 0

(2) return -1

三、程序设计题

23

(3)st[i].ave 1． 试定义一个表示学生成绩的结构体，要求包含学号、姓名、数学成绩、英语成绩、C++

语言成绩和三门课程的总分，再定义两个变量。

程序代码如下：

struct student {int no;

char *name[20]; //定义姓名 int math; //数学成绩 int eng; //英语成绩 int cpp; // C++成绩 int sum; //统计三门课总分 } st1,st2; //定义两个变量

2．定义结构体类型struct card ，代表一张扑克牌的结构，结构体中包含两个成员：牌的花色（定义字符串类型）和面值（定义整型），再定义一个结构变量deck，代表一张牌。

程序代码如下：

struct card

{int no; //表示点数

char hua; //'R'表示红桃，'B'表示黑桃，'F'表示方片， 'T'表示桃花 } deck;

3．定义一个第1题的结构体类型的结构体数组stud，输入学生三门课成绩，然后按总分成绩排序后输出学生成绩。

程序代码如下：

#include using namespace std;

struct stud { int no;

char name[20]; int math; int eng; int cpp; int sum; } st[10];

int n=-1; //表示数组元素当前下标 void main() { int x=1,i,j; stud t;

24

cout<<\请输入学生记录，按0 结束\while(x) { cin>>x;

if(x){ n++; //读入学号

st[n].no=x; //读入姓名

cin>>st[n].name>>st[n].math>>st[n].eng>>st[n].cpp; //读入三门课成绩 st[n].sum=st[n].math+st[n].eng+st[n].cpp; //计算三门课总分 }

else break; }

for(i=0;i

if(st[j].sum>st[j+1].sum)

{t=st[j];st[j]=st[j+1];st[j+1]=t;}

for(i=0;i<=n;i++) // 输出排序后学生信息 cout<

<<\

}

4．编写实现将两个已知的有序链表合并成一个有序链表的函数。

程序代码如下：

struct link { int data;

struct link *next; };

void hbsort(link *a,link *b,link *c) {link *pa,*pb,*pc; pa=a->next; pb=b->next; pc=a;c=pc;

while(pa!=NULL && pb!=NULL)

if (pa->datadata) {pc->next=pa;pc=pa;pa=pa->next;} else {pc->next=pb;pc=pb;pb=pb->next;} if(pa!=NULL) pc->next=pa; else pc->next=pb; }

5．编写从无序的整数链表中找出最小元，并将它从链表中删去的函数。

程序代码如下：

void findmin(link *a)

25

{link *p,*prior,*min,*pmin;

pmin=a;min=a->next; //min表示当前最小值地址，pmin表示min前驱地址

prior=min;p=prior->next; while(p)

{ if( p->datadata){pmin=prior;min=p;} prior=p;p=p->next; }

pmin->next=min->next; delete(min); }

习题七 参考答案

第7章 类与对象

一、选择题

1.C 2.B 3.C 4.D 5.D 6.B 7.A 8. D 9．B 10．C

11．C 12．D 13．C 14．D 15．B 16．D 17．C 18．D 19．A 20．D 21．C 22．C 23．C 24．A 25．A 26．A

二、填空题

1． 封装 、多态 2．类体内 ，类体外 3． ~test() 4．引用

5．形式参数和返回值 6．class、struct union。 7． 类名 8． private 9． 构造函数 10.(1)3 (2)3

11. (1) public (2) 成员函数 (3)友元函数

三、编程题

1． 编写一个程序，设计一个产品类Product,要求包含产品名称、单价及数量并低钠盐定义

相应的接口使得外部对象能够通过这些借口访问这三个成员。

程序代码如下：

#include #include using namespace std; class Product {

26

char *name; //产品名称 int price; //产品单价 int quantity； //剩余产品数量 public:

product(char *n,int p int q) //构造函数 {

strcpy(name,n); price = p; quantity = q; }

void setPrice(int p) {

price = p; }

int getPrice() {

return price; }

//其他类似。 };

2. 定义一个学生类，其中有3个数据成员：学号、姓名、年龄，以及若干成员函数。同时编写main函数使用这个类，实现对学生数据的赋值和输出。

程序代码如下：

#include #include using namespace std; class student {

int no;

char name[10]; int age; public:

student(int i, char *str, int g) {

no=i;

strcpy(name,str); age=g; }

student( ) {

no=0;

strcpy(name,”none”);

age=-1; }

void display() {

27

if (no>0)

cout<<”no” < else

cout<<”no”<

void main() {

student d1(1001,”Tom”,18); d1.display(); student d2; d2.display(); }

3. 定义计数器类Counter。要求具有以下成员：计数器值；可进行增值和减值记数；可提供记数值。

程序代码如下：

#include using namespace std; class Counter { int n; public:

Counter(int i=0) {n=i;}

void init_Counter(int m) {n=m;} void in_Counter() {n++;} void de_Counter() {n--;} int get_Counter() {return n;} void show() {cout<

void main() {

Counter a;

a.in_Counter(); a.show(); a.init_Counter(10); a.show();

a.de_Counter();

cout<

4. 编写一个程序计算两个给定的长方形的周长和面积。

程序代码如下：

#include using namespace std; class rectangle {

int len,wid;

28

public:

rectangle(int i=0,int j=0) {

len=i;wid=j; }

friend int area(rectangle temp) {

int s=temp.len*temp.wid;

return s; }

friend fun(rectangle temp) {

int p=2*(temp.len+temp.wid);

return p; } };

void main() {

rectangle a(10,20);

cout<<\长方形的周长和面积为：\ rectangle b(100,200);

cout<<\长方形的周长和面积为：\}

5. 编写一个程序，采用一个类求n!,并输出10!的值。

程序代码如下：

#include using namespace std; class fac {

int p;

public:

fac() { p=1;} fac( int j) {

p=1;

if(j>=0)

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

p=p*i;

else

cout<<\数据错误\\n\

}

void show() { cout<<\阶乘为：\};

void main()

29

{

int n;

cout<<\请输入一个整数：\ cin>>n; fac a(n);

cout<

6. 编写一个程序，设计一个Cdate类，它应该满足下面的条件： 1）用这样的格式输出日期：日-月-年； 2）输出在当前日期上加两天后的日期； 3）设置日期。

程序代码如下：

#include using namespace std; class Cdate {

int year,month,day; int y1,m1,d1;

public:

void setdate(int y,int m,int d) {year=y;month=m;day=d;}

void show() {

cout<<\当前日期： \

cout<<\两天后日期：\ }

void datetwo() //加一天后的年月日 {

d1=day;y1=year;m1=month;

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

d1++;

switch(d1){

case 29:

if(!(month==2 &&(year@0==0||year%4==0&&year0!=0)))

{

m1=3;d1=1; }; break;

case 30:

if(month==2 &&(year@0==0||year%4==0&&year0!=0))

{

m1=3;d1=1; }; break;

case 31:

if(month==4||month==6||month==9||month==11)

{

30

m1=m1+1;d1=1; }; break;

case 32:

m1=m1+1; d1=1;

if(month==12) {

y1=y1+1; m1=1; }; break;

} } } };

void main() {

Cdate d; int y,m,d1;

cout<<\请输入年月日: \cin>>y>>m>>d1;

d.setdate(y,m,d1);//加一天 d.setdate(y,m,d1);//再加一天 d.datetwo(); d.show(); }

习题八 参考答案

第八章 继承与派生

一、选择题

1.D 2. A 3. D 4. B 5. B 6. A 7. A 8. D 9. D 10 C

11. B 12. B 13. D 14. D 15. A 16. B 17. A 18

二、填空题

1. 单继承 多继承 2. 基类

3. 初始化基类数据成员、新增内嵌对象数据及新增一般成员数据所需要的全部参数。 4. 派生类 派生类中子对象类 基类

5. (1)c1、b2、b3、A2、A3 (2)c2 (3)c3 6. 基类 派生类自己

7. 现有类 父类 新类 子类 8. 能同时从多个基类 9. public

31

10. private

三、问答题

1.比较类的三种继承方式public(公有继承)、protected(保护继承)、private(私有继承)之间的差别。

答：继承方式决定了基类中的成员在派生类中的属性。三种继承方式的共同点：基类的private成员在派生类中不可见。区别：对于私有继承，基类的public，protected成员在派生类中作为private成员；对于公有继承，基类的public，protected成员在派生类中访问属性不变；对于保护继承，基类的public，protected成员在派生类中作为protected成员。

2. 派生类构造函数执行的次序是怎样的?

答：派生类构造函数的执行顺序是先执行所有基类的构造函数（顺序按照定义派生类是指定的各基类顺序），再执行对象成员所在类的构造函数（顺序按照他们在类中的声明顺序），最后执行派生类构造函数体中的内容。

3. 如果在派生类B已经重载了基类A的一个成员函数fn1()，没有重载成员函数fn2()，如何调用基类的成员函数fn1()，fn2()?

答：因为在派生类B已经重载了基类A的一个成员函数fn1()，所以要用作用域运算符对fn1()函数加以限定，调用基类的成员函数fn1()是A::fn1()；因为在派生类B没有重载成员函数fn2()，所以直接可调用fn2()。

4. 什么叫做虚基类?它有何作用?

答：在多重继承中，如果多条继承路径上有一个公共的基类，则在这些路径的汇合点上的派生类会产生来自不同路径的公共基类的多个拷贝，如果用virtual把公共基类定义成虚基类，则只会保留公共基类的一个拷贝。引进虚基类的目的是为了解决二义性问题，使得公共基类在它的派生类对象中只产生一个基类子对象。

四、程序设计题

1. 声明一个Shape基类，在此基础上派生出Rectangle和Circle类，二者都有GetArea()函数计算对象的面积。使用Rectangle类创建一个派生类Square。

程序代码如下：

#include Using namespace std;

const double PI = 3.1415926;

class shape {

32

protected: double s; public:

void show()

{cout<<\ } };

class Rectangle:public shape { double x,y; public:

Rectangle(double x1=0,double y1=0) void GetArea() {s=x*y;} };

class Circle:public shape { double r; public:

Circle(double r1=0) {r=r1;} void GetArea() {s=r*r*PI; } };

class Square :public Rectangle { double a; public:

Square(double a1=0 ) {a=a1;} void GetArea() {s=a*a; } };

{x=x1;y=y1;}

2. 建立一个基类Building ，用来存储一座楼房的层数、房间数以及它的总平方英尺数。建立派生类Housing，继承Building，并存储下面的内容：卧室和浴室的数量，另外，建立派生类Office,继承Building，并存储灭火器和电话的数目。然后，编制应用程序，建立住宅楼对象和办公楼对象，并输出它们的有关数据。

程序代码如下：

#include using namespace std;

class Building {public:

Building(int f,int r,double ft) {floors=f; rooms=r; footage=ft; }

void show()

{ cout<<\ cout<<\ cout<<\ }

protected: int floors; int rooms;

double footage; };

33

class Housing:public Building {public:

Housing(int f,int r,double ft,int bd,int bth):Building(f,r,ft) { bedrooms=bd;

bathrooms=bth; }

void show()

{cout<<\ Building::show();

cout<<\ cout<<\ } private:

int bedrooms; int bathrooms; };

class Office:public Building {

public:

Office(int f,int r,double ft,int ph,int ex):Building(f,r,ft) { phones=ph;

extinguishers=ex; }

void show()

{cout<<\ Building::show();

cout<<\

cout<<\ } private:

int phones;

int extinguishers; }; void main() {

Housing hob(5,7,140,2,2); Office oob(8,12,500,12,2); hob.show(); oob.show(); }

3. 声明一个哺乳动物Mammal类，再由此派生出狗Dog类，声明一个Dog类的对象，观察基类与派生类的构造函数与析构函数的调用顺序。

程序代码如下：

#include using namespace std;

class Mammal { public:

Mammal() { cout<<\ }

~Mammal() {cout<<\ } };

34

class Dog :public Mammal { public:

Dog() {cout<<\

~Dog() {cout<<\};

void main() { Dog b; }

4．定义一个基类有姓名、性别、年龄，再由基类派生出教师类和学生类，教师类增加工号、职称和工资，学生类增加学号、班级、专业和入学成绩。

程序代码如下：

#include #include #include using namespace std;

class base //定义一个基类 {protected:

char name[20]; //姓名 char sex[3]; //性别 int age; //年龄 };

class teacher:public base //基类派生出教师类 { int sno; //工号 char zc[20]; //职称 double wages; //工资 };

class student :public base //基类派生出学生类 { int sno; //学号 char bj[10]; //班级 char zy[10]; //专业 double score; //入学成绩 };

习题九 参考答案

第9章 虚函数和多态性

一、选择题

1. D 2. A 3. D 4. D 5. D 6. A 7. A 8. C 9. D 10. D 11. A 12. A 13. A

二、问答题

1．什么叫做抽象类?抽象类有何作用?抽象类的派生类是否一定要给出纯虚函数？ 答：带有纯虚函数的类是抽象类．抽象类的主要作用是通过它为一个类族建立一个公共的接口．使它们能够更有效地发挥多态特性。抽象类声明了一组派生类共同操作接口的通用语

35

义．面接口的完整实现，即纯虚函数的函数体，要由派生类自己给出．但抽象类的派生类并非一定要给出纯虚函数的实现．如果派生类没有给出纯虚函数的实现，这个派生类仍然是一个抽象类．

2. 什么叫做多态性?在C++语言中是如何实现多态的?

答：多态是指同样的消息被不同类型的对象接收时导致完全不同的行为，是对类的特定成员

函数的再抽象．c十+支持的多态有多种类型．重载(包括函数重载和运算符重载)和虚函数是其中主要的方式．

3．声明一个参数为整型、无返回值、名为fun1的虚函数。

答： virtual void fnl(int)；

4．在C++语言中，能否声明虚构造函数?为什么?能否声明虚析构函数?有何用途?

答：在C++-中不能声明虚构造函数．多态是不同的对象对同一消息有不同的行为特性．虚

函数作为运行过程中多态的基础，主要是针对对象的，面构造函数是在对盘产生之前运行的，因此虚构造函数是没有童义的．

在C++中可以声明虚析构函数．析构函数的功能是在该类对象消亡之前进行一些必要的清理工作，如果一个类的析构函数是虚函数，那么，由它派生而来的所有子类的析构函数也是虚函数．析构函数设置为虚函数之后，在使用指针引用时可以动态联编，实理运行时的多态，保证使用基类的指针就能够谓用适当的析构函数指针对不同的对象进行清理工作．

四、程序设计题 1． 声明一个Rectangle类，有长itsWidth、宽itsLength等属性，重载其构造函数Rectanle()和Rectangle(int width，int length)。

程序代码如下：

#include using namespace std;

class Rectangle {public:

Rectangle();

Rectangle(int width,int length); ~Rectangle(){ }

int GetWidth() const{ return itsWidth;} int GetLength() const{ return itsLength;} private:

int itsWidth; int itsLength; };

Rectangle::Rectangle() { itsWidht=5; itsLength=10; }

Rectangle::Rectangle(int width,int length) { itsWidth=width;

itsLength=length;

36

}

void main()

{ Rectangle Rect1;

cout<<”Rect1 width:”<>aWidth;

cout<<”\\nEnter a length”; cin>>aLength;

Rectangle Rect2(aWidth,aLength);

cout<<”\\nRect2 width:”<

程序代码如下：

#include #include using namespace std;

class shape { public:

virtual void getarea()=0; virtual void getperim()=0; };

class rectangle:public shape { int a,b,c; double s,p; public:

rectangle(int a1,int b1,int c1) {a=a1;b=b1;c=c1;} void getperim()

{ p=a+b+c; cout<<\周长 \ void getarea()

{ p=(a+b+c)/2.0;

s=sqrt(p*(p-a)*(p-b)*(p-c)); cout<<\面积 \} };

class circle :public shape { float r,s,p; public:

circle(float r1) {r=r1;}

void getperim() { p=2*r*3.1415926;cout<<\周长 \ void getarea() { s=r*r*3.1415926; cout<<\面积 \};

void show(shape *p) { p->getarea();

37

p->getperim(); }

void main() { shape *p;

rectangle a(3,4,5); circle b(10); p=&a; show(p); p=&b; show(p); }

3．应用抽象类，求圆、圆内接正方形和圆外切正方形的面积和周长。

程序代码如下：

#include #include using namespace std;

const double PI= 3.1415926;

class base //抽象基类B0声明 { public: //外部接口 virtual void display( )= 0; //纯虚函数成员 };

class circle:public base //公有派生 { protected:

double r,s,p; public:

circle(double x=0) { r=x;} void display( )

{ cout<<\圆的面积 \

cout<<\圆的周长 \虚成员函数

} };

class incircle:public circle //公有派生 { double a; public:

incircle(double x=0): circle(x) {} void display( ) { a=sqrt(r);

cout<<\内接正方形面积\

cout<<\内接正方形周长\虚成员函数

} };

class outcircle:public circle //公有派生 { public:

outcircle(double x=0): circle(x) {} void display( )

{ cout<<\外切正方形面积\

cout<<\外切正方形周长\虚成员函数 }};

void fun(base *ptr) //普通函数

38

{ ptr ->display( ); } void main( ) { base *p; circle b1(10); incircle d1(9); outcircle e1(10); p=&b1; fun(p); p=&d1; fun(p); p=&e1; fun(p); }

//主函数

//声明抽象基类指针 //声明派生类对象 //声明派生类对象

习题十 参考答案

第10章 流类库和输入输出

一、选择题

1.D 2.D 3. D 4 A 5 B

二、问答题

1． 当使用ifstream流类定义一个对象并打开一个磁盘文件时，文件的隐含打开方式是什么？ 答：ifstream afile;

afile.open(“filename”);

open函数由两个参数组成，第一个参数是指定的文件路径名，第二个参数是打开模式，系统默认按ios::in方式打开，即为隐含打开方式。

2． 当使用ofstream流类定义一个对象并打开一个磁盘文件时，文件的隐含打开方式是什么？

答：当用输出文件流对象调用open()成员函数打开一个文件时，打开方式参数也可以省略，即使用户指定了其他的打开方式，系统仍按默认的ios::out方式打开

3． 当使用fstream流类定义一个对象并打开一个磁盘文件时，文件的隐含打开方式是什么？

答：文件流类ifstream定义的对象实际上是一个输入文件；输出文件流类ofstream定义的对象实际上是一个输出文件；输入输出（双向）文件流类fstream定义的对象实际上是一个既可读又可写的文件。所以当使用fstream流类定义一个对象并打开一个磁盘文件时，文件的隐含打开方式是ios::in | ios::out

4．什么是格式状态标志? 答：格式状态标志是C++编译器提供的一种格式标记，有6种：left、right、showpoint、showpos、fixed和scientific。它们作为setiosflags和resetiosflags的参数使用，其类型为枚举型。格式化输入、输出使用到的格式控制符和格式状态标志均在根基类ios类中有定义

5． 现在需要打开afile文件，进行文件更新操作，应使用什么语句来实现？ 答：fstream myfile;

myfile.open(“c:\\\\afile”, ios :: out);

39

6．在C++语言中，二进制文件可以用来存放哪些数据类型的数据？

答：字节文件中存放的是可供机器直接读取的二进制代码，在打开方式中带有ios::binary选项。通常二进制文件的内容不能直接打印，也不允许用户直接阅读。但与字符文件相比它也有许多优点，如节省内存空间；可以存放结构类型的数据、记录等

7．简述几种打开文件方式ios::in 、ios::out、ios::app及ios::in|ios::out之间的区别。 答：1）ios :: in：打开的文件是输入文件，既从该文件中读取数据，用于数据输入。

2）ios :: out：打开的文件是输出文件，既该文件用于写入数据，用于数据输出。 3）ios :: in | ios :: out：打开的文件既可以用于输入也可以用于输出。

8．函数exit()的功能是什么？在程序中的作用是什么？

答：函数exit( )将强制程序结束执行，其格式为：exit(-1);

它仅有一个整型参数，执行这条语句时，结束程序的执行，将控制权交还给操作系统，同时给出程序的结束状态-1。通常负的参数值代表程序的非正常结束。

9．函数close()实现什么操作？为什么完成对文件的操作后应及时关闭文件？

答：每个文件流类中都提供有一个关闭文件的成员函数close( )，当打开文件并在文件上执行完相应操作后，应将文件关闭。关闭任何一个流对象所对应的文件，就是利用这个流对象调用close( )成员函数，调用格式如下：

internalfilename.close ( ) ;

internalfilename是相应I/O类对象的名，close()成员函数没有参数。如果文件是以输出或添加方式打开的，操作系统将在close( )成员函数的作用下在文件的末尾加上文件结束符，断开程序与文件间的连接；如果文件是以输入方式打开的，close( )成员函数直接断开程序与文件间的连接。并保证最后输出到文件缓冲区中的内容——无论是否已满——都将立即写入到对应的文件中。当文件关闭后，文件对象不再存在，此时不能再对该文件进行任何操作。可再次使用open( )函数打开文件。

如果使用完文件后，没有使用close( )成员函数将程序与文件断开，则当程序结束执行时，操作系统将自动关闭文件。

10．顺序访问文件与随机访问文件之间的区别是什么？

答：顺序访问文件是指只能按数据的存放顺序依次进行读取；随机访问文件是可以使用位移量对其中的数据进行访问，“位移量”指以当前位置（开始点或当前位置或文件末尾）为基点，移动的字节数。

三、程序设计题

1. 编写一个程序将data.dat文件中的内容在屏幕上显示出来并拷贝到data1.dat文件中。

程序代码如下：

#include

40

本文来源：https://www.bwwdw.com/article/bkdv.html