C++语言基础教程吕凤翥习题答案

第一章习题
一、选择填空
1.下列各种高级语言中，（）是面向对象的程序设计语言。

; ;++
2.下列各种高级语言中，（）是最早提出了对象的概念。

60; 67; ; ++
3.下述面向对象抽象的原理中，（）是不对的。

A. 数据抽象;
B. 行为共享;
C.进化;
D. 兼容;
4.（）不是面向对象系统所包含的要数。

A. 重载;
B. 对象;
C. 类;
D. 继承;
5.关于C++与C语言的关系的描述中，（）是错误的。

A. C语言是C++的一个子集;
B. C语言与C++是兼容的;
C. C++对C语言进行了一些改进;
D. C++和C语言都是面向对象的;
6.下面关于对象概念的描述中，（）是错误的。

A.对象就是C语言中的结构变量;
B.对象代表着正在创建的系统中的一个实体；
C. 对象是一个状态和操作（或方法）的封装体;
D.对象之间的信息传递是通过消息进行的;
7.下面关于类概念的描述中，（）是错误的。

A.类是抽象数据类型的实现;
B.类是具有共同行为的若干对象的统一描述体;
C.类是创建对象的样板;
D.类就是C语言中的结构类型;
8.C++对C语言作了很多改进，下列描述中（）使得C语言发生了质变，即从面向过程变成为
面向对象。

A.增加了一些新的运算符;
B.允许函数重载，并允许设置缺省参数;
C.规定函数说明必须用原型;
D.引进了类和对象的概念;
9.按照标识符的要求，（）符号不能组成标识符。

A.连接符;
B. 下划线;
C.大小写字母;
D.数字字符;
10.下列符号中，（）不可作为分隔符。

A.，;
B.：;
C.？;
D.;
二、判断下列描述的正确性，对者划√，错者划×。

1．C++引进了引用的概念，对编程带来了很多方便。

√2．C++允许使用友元，但是友元会破坏封装性。

√
C++中使用了新的注释符（#include<>
void main()
{
int a,b;
cout<<"input a,b:";
cin>>a>>b;
cout<<"a="<<a<<","<<"b="<<b<<endl;
cout<<"a-b="<<a-b<<"\n";
}
假定，输入如下两个数据：8 5
1．Input a,b:8 5
A=8,b=5
A-b=3
3．#include <>
void main()
{
char c=’m’;
int d=5;
cout<<"d="<<d<<":";
cout<<"c="<<c<<"\n";
}
D=5,c=m
四、编译下列程序，改正所出现的各种错误信息，并分析输出结果：
1、main ( )
{
cout<<"This is a string!";
}
1．#include<>
void main()
{
cout<<”This is a string!”;
}
输出结果：This is a string!
2、#include<>
void main( )
{
cin>>x;
int p=x*x;
cout<<"p=<<p<<\n";
}
#include<>
void main( )
{
int x;
cin>>x;
int p=x*x;
cout<<”p=”<<p<<”\n”;
}
输出结果：3
p=9
3、#include <>
void main ( )
{ int i,j;
i=5;
int k=i+j;
cout<<"i+j="<<k<<"\n";
}
#include <>
void main ( )
{int i,j;
i=5;
j=3;
int k=i+j;
cout<<”i+j=”<<k<<”\n”;
}
输出结果：I+j=8
五、通过对第四题中三个程序的所出现问题的修改，回答下列问题：
1.从对第四题1题的修改中，总结出编程时应注意哪三个问题？
2.C++程序中所出现的变量是否都必须先说明才能引用？
3.使用cout和运算符<<输出字符串时应注意什么问题？
4.有些变量虽然说明了但是没有赋值，这时能否使用？
5.一个程序编译通过了并且运行后得到了输出结果，这个结果是否一定是正确的？
第二章习题
一、选择填空
1、在16位机中，int型字宽为（）字节。

A．2； B。

4；C。

6； D 8
2、类型修饰符unsigned修饰（）类型是错误的。

A． char; B. int; int ; D float
3、下列十六进制的整型数常数表示中，（）是错误的。

A．0xaf； B. 0X1b; C. 2fx; D. 0xAE
4 、下列double型常量表示中，（）是错误的。

A．E15； B. .35； C. 3E5; D. 3E-5
5、下列字符常量表示中，（）是错误的。

A. ‘\105’ ;
B. ‘*’;
C.‘\4f’;
D. ‘\a’
6、下列字符串常量表示中，（）是错误的。

A."\"yes\"or\"No\"";
B."\’OK!\’";
C. "abcd\n";
D. "ABC\0"
7、下列变量名中，（）是合法的。

; B. byte-size; C. double; D. A+a
8、在int a[5]={1,3,5};中，数组元素a[1]的值是（）。

A. 1;
B. 0; ;
9、在int b[][3]={{1},{3,2},{4,5,6},{0}};中a[2][2]的值是（）。

; B. 5; ;
10、下列给字符数组进行初始化中，（）是正确的。

A．char s1[ ]="abcd; B. char s2[3]="xyz";
C. char s3[][3]={‘a’,’x’,’y’};
D. char s4[2[3]={"xyz","mnp"};
11、在int a=3,*p=&a; 中，*p的值是（）。

A. 变量a的地址值；
B.无意义；
C. 变量p的地址值；
12、对于int *pa[5];的描述，（）是正确的。

A.pa是一个指向数组的指针，所指向的数组是5个int型元素；
B.pa是一个指向某个数组中第5个元素的指针，该元素是int型变量；
C.pa[5]表示某个数组的第5个元素的值；
D.pa是一个具有5个元素的指针数组，每个元素是一个int型指针；
13、下列关于指针的运算中，（）是非法的。

A．两个指针在一定条件下，可以进行相等或不等的运算；
B．可以用一个空指针赋值给某个指针；
C．一个指针可以加上两个整数之差；
D．两个指针在一定条件下，可以相加。

14、指针可以用来表示数组元素，下列表示中（）是错误的。

已知：int a[3][7];
A. *(a+1)[5];
B. *(*a+3);
C. *(*(a+1));
D. *(&a[0][0]+2)
15、下列表示引用的方法中，（）是正确的。

已知：int m=10;
A. int &x=m;
B. int &y=10;
C. int &z;
D. float &t=&m
16、下列各运算符中，（）可以作用于浮点数。

A．++; B. %; C. >>; D. &
17、下列各运算符中，（）不能作用于浮点数。

A．/； B.&&; C.!; D.~
18、下列各运算符中，（）优先级最高。

A. +（双目）；
B. *（单目）；
C. <=;
D. *=
19、下列各运算符中，（）优先级最低。

A．？：；B. |； C. ||； D.！=
20、下列各运算符中，（）结合性从左到右。

A. 三目；
B. 赋值；
C.比较；
D.单目
21、下列表达式中，（）是非法的。

已知：int a=5; float b=;
A. a%3+b;
B. b*b&&++a;
C.(a>b)+(int(b)%2);
D. -- -a+b
22、下列表达式中，（）是合法的。

已知：double m=; int n=3;
A. m<<2;
B. (m+n)|n
C. !m*=n;
D. m=5,n=,m+n
23、下列关于类型转换的描述中，（）是错误的。

A．在不同类型操作数组成的表达式中，其表达式类型一定是最高类型double型；
B．逗号表达式的类型是最后一个表达式的类型；
C．赋值表达式的类型是左值的类型；
D．在由底向高的类型转换中是保值映射。

24、下列各表达式中，（）有二义性。

已知：int a（5）; b（6）;
A. a+b>>3;
B. ++a+b++; +(a=3); D. ( a=3)-a++
二、判断下列描述是否正确，对者划√，错者划×。

1、任何字符常量与一个任意大小的整型数进行加减都是有意义的。

×
2、转义序列表示法只能表示字符不能表示数字。

√
3、在命名标识符中，大小写字母是不加区别的。

×
4、C++的程序中，对变量一定要先说明再使用，说明只要在使用之前就可以。

√
5、C++中数组元素的下标是从0开始，数组元素是连续存储在内存单元中的。

√
6、数组赋初值时，初始值表中的数据项的数目可以大于或等于数组元素的个数。

×
7、枚举变量的取值受到该枚举变量所对应的枚举表中的枚举符的局限。

√
8、指针是用来存放某种变量的地址值的变量。

这种变量的地址值也可以存放在某个变量
中，存放某个指针的地址值的变量称为指向指针的指针，即二级指针。

√
9、引用是用来给某个变量以别名的变量。

，对引用的操作，实质上就是对被引用的变量的
操作。

√
10、运算符的优先级和结合性可以确定表达式的计算顺序。

√
11、在说明语句中，的值和的值是相等的。

√
12、已知：表达式具有两用性。

×
13、移位运算符在移位操作中，无论左移还是右移，所移出的空位一律补0；×
14、某个变量的类型高是指该变量被存放在内存中的高地址处。

×
15、隐含的类型转换都是保值映射，显式的类型转换都是非保值映射。

×
16、类型定义是用来定义一些C++中所没有的新的类型。

×
三、计算下列各表达式的值
（下列各表达式是相互独立的，不考虑前面对后面的影响。

）
1、已知:unsigned int x=015,y=0x2b;
A.x|y; ^y; &y; D.~x+~y; <<=3; >>=4.
2、已
知:inti(10),j(5);
A.++i-j--; =i*=j; =3/2*(j=3-2); D.~i^j; &j|1; +i&0xff.
3、已
知
：int a(5),b(3);计算下列表达式得值以及a和b的值。

A.！a&&b++; ||b+4&&a*b; =1,b=2,a>b?++a:++b; D.++b,a=10,a+5;
+=b%=a+b; !=b>2<=a+1.
4、已
知
：int d(5),*pd=&d,&rd=d;
A.d+-rd;
B.*pd*rd;
C.++*pd-rd;
D.++rd-d.
5、已知：’1’的ASCII码的值为
49。

+2<<1+1; *9|3<<1; %-3*2/6-3; = =3<=2&5;
E.!(‘3’>’5’)||2<6; >=3+2-(‘0’-7).
四、按
下列要求编写程序
1．从键盘上输入两个int型数，比较其大小，并输出显示其中小的。

2．从键盘上输入一个int型数，一个浮点型数比较其大小，并输出其中大的。

3．输入一摄氏温度，编程输出华氏温度。

已知：华氏温度转换为摄氏温度的计算公式如下：C=(F-32)*5/9
其中，F表示华氏温度，C表示摄氏温度。

#include <>
void main()
{
float c,f;
cout<<”华氏温度：”; cin>>f;
c=(f-32)*5/9;
cout<<” 摄氏温度：”<<c<<endl;
}
4．编程实现输入公里数，输出显示其英里数。

已知：1英里=公里（用符号常量）。

#include <>
const float r=;
void main()
{
float m,I;
cout<<” 公里数：”;
cin>>m;
I=r*m;
c out<<”英里数：”<<I<<endl;
}
5．输入一个int型数，将它的低4位（右4位）都置为1。

#include <>
void main()
{
int n,m;
cout<<”输入一个整数：”;
cin>>n;
m=n|15;
cout<<”结果为：”<<m<<endl;
}
第三章习题
一、选择填空
1.预处理命令在程序中都是以（）开头的。

A. * ;
B. # ; C . : ; D. / ;
2.文件包含命令中被包含的文件的扩转名（）。

A.必须为.h;
B.不能用.h; C .必须是.c; D.不一定是.h;
3.下列条件编译命令中
#if()
<语句序列1>
#else
<语句序列2>
#endif
A.整常量表达式；
B.任何标识符; C .任意表达式 ; D.被定义的宏名;
4.带参数的宏定义中，程序中引用宏定义的实参（）。

A.只能是常量;
B.只能是整型量; C .只能是整形表达式; D.可以是任意表达式;
5.下列（）是语句
A. ；; =17; C .x+y; D. cout<<”\n”;
6.下列for循环的次数为（）。

for(int i(0),x=0;!x&&i<=5;i++)
; ; C .1; D.无限;
7.下列while循环的次数是（）。

while(int i=0)i- -;
; ; C .5 ; D.无限;
8.下列do-while循环的循环次数为（）。

已知：int i(5);
do{cout<<i- - <<endl;
i- - ;
}while(i!=0);
; ; C .5; D.无限;
9.下列for循环的循环体执行次数为（）。

for(int i(0),j(10);i=j=10;i++,j- -)
; ; C .10; D.无限;
10.已知：int a,b;下列switch语句中，( )是正确的。

A.switch(a);
{case a:a++;break;
case b:b++;break;
}
B.switch(a+b)
{ case 1:a+b;break;
case 2:a-b
}|
C.switch(a*a)
{case1,2:++a;
case3,4:++b;
}
D.switch(a/10+b)
{case 5:a/5;break
default:a+b;
}
11.下述关于循环体的描述中，（）是错误的。

A.循环体中可以出现break语句和continue语句；
B.循环体中还可以出现循环语句；
C.循环体中不能出现goto语句;
D.循环体中可以出现开关语句。

12.下述关于goto语句的描述中，（）是正确的。

A.goto语句可在一个文件中随意转向；
B.goto语句后面要跟上一个他所转向的语句；
C.goto语句可以同时转向多条语句；
D.goto语句可以从一个循环体内转到循环体外。

13.下述关于break语句的描述中，（）是正确的。

A.break语句可用于循环体内，它将退出该重循环；
B.break语句可用于开关语句中，它将退出开关语句。

C.break语句可用于if体内,它将退出if语句;
D.break语句在一个循环体内可以出现多次。

14.下述关于开关语句的描述中，（）是正确的。

A.开关语句中default子句可以没有，也可以有一个;
B.开关语句中每个语句序列中必须有break语句;
C.开关语句中default子句只能放在最后；
D.开关语句中case子句后面的表达式可以是整形表达式。

15.下列关于条件语句的描述中，（）是错误的。

A.if语句中只有一个else子句；
B.if语句中可以有多个else if子句；
C.if语句中if体内不能是开关语句；
D.if语句中的if体中可以是循环语句。

二、判断下列描述是否正确，对者划√，错者划×。

１．预处理命令是在进行编译时首先执行的，然后再进行正常编译。

√
２．宏定义命令是以分号结束的。

×
３．带参数的宏定义只能有1至2个参数。

×
４．文件包含命令所包含的文件是不受限制的。

×
５．条件编译命令只在编译时才有作用。

√
６．预处理命令的主要作用是提高效率的。

×
７．复合语句就是分程序。

×
８．条件语句不能作为多路分支语句。

×
９．开关语句不可以嵌套，在开关语句的语句序列中不能再有开关语句×
10．开关语句中的default关键字，只能放在该语句的末尾，不能放在开头或中间。

×11．Switch语句中必须有break语句否则无法退出switch语句。

×
12．While循环语句的循环体至少执行一次。

×
13．Do-while循环可以写成while循环的格式。

√
14．For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。

×
15．只有for循环的循环体可以是空语句，其他种循环的循环体不能用空语句。

×16．当循环体为空语句时，将说明该循环不作任何工作，只起延时作用。

×
17．循环是可以嵌套的，一个循环体内可以包含另一种循环语句。

√
18．在多重循环中，内重循环的循环变量应用的次数比外重的多。

√
19．Break语句可以出现在各种循环体中。

√20．continue语句只能出现在循环体中。

√三、分析下列程序的输出结果。

1.
#include<>
#define M
#define A(a) M*a
void main()
{
int x(5),y(6);
cout<<A(x+y)<<endl;
}
2.
#include<>
#define MAX(a,b) (a)>(b)?(a):(b)
void main()
{
int m(1),n(2),p(0),q;
q=MAX(n,n+p)*10;
cout<<q<<endl;
}
20
3.
#include<>
#include””
void main()
{
int a(5),b;
b=f1(a);
cout<<b<<endl;
}
文件内容如下：
#define M(m) m*m
f1(int x)
{
int a(3);
return –M(x+a);
}
13
4.
#include<>
void main()
{
int i(0);
while(++i)
{
if(i= =10) break;
if(i%3!=1) continue;
cout<<i<<endl;
}
}
1
4
7
5.
#include<>
void main()
{
int i(1);
do{
i++;
cout<<++i<<endl;
if(i= =7) break;
}while(i= =3);
cout<<”Ok!\n”;
}
3
5
Ok!
6.
#include<>
void main()
{
int i(1),j(2),k(3),a(10);
if(!i)
a- -;
else if (j)
if(k) a=5;
else
a=6;
a++;
cout<<a<<endl;
if(i<j)
if(i!=3)
if(!k)
a=1;
else if(k)
a=5;
a+=2;
cout<<a<<endl;
}
6
7
7.
#include<>
void main()
{
int i,j,a[8][8];
* * a=1;
for(i=1;i<8;i++)
{
* *(a+i)=1;
*(*(a+i)+i)=1;
for(j=1;j<i;j++)
*(*(a+i)+j)= *(*(a+i-1)+j-1)+ *(*(a+i-1)+j);
}
for(i=0;i<8;i++)
{
for(j=0;j<=i;j++)
cout<<""<<*(*(a+i)+j);
cout<<endl;
}
}
7.1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1 8.
#include<>
void main()
{
int x(5);
do{
switch(x%2)
{
case 1:x- -;
break;
case 0:x++;
break;
}
x- -;
cout<<x<<endl;
}while(x>0);
}
8.3
1
-1
9.
#include<>
void main()
{
int a(5),b(6),i(0),j(0);
switch(a)
{
case 5:switch(b)
{
case 5:i++;break;
case 6:j++;break;
default: i++;j++;
}
case 6: i++;
j++;
break;
default: i++;j++;
}
cout<<i<<”,“<<j<<endl; }
1,2
10.
#include<>
char input[]="SSSWILTECH1\1\11W\1WALLMP1";
void main()
{
int i;
char c;
for(i=2;(c=input[i])!='\0';i++)
{
switch(c)
{
case 'a':cout<<'i';
continue;
case'1':break;
case 1:while((c=input[++i])!='\1'&&c!='\0');
case 9:cout<<c;
case 'E':
case 'L':continue;
default :cout<<c; continue;
}
cout<<' ';
}
cout<<endl;
}
SWITCH⊙WAMP
四、按下列要求编程，并上机调试。

１．求100之内的自然数中奇数之和。

２．求100之内的自然数中被13整除的最大数。

３．求输入两个正整数的最大公约数和最小公倍数。

４．求下列分数序列的前15项之和。

2/1，3/2，5/3，8/5，13/8，21/13，. . .
５．求∑i！(i=1,. . .,10)(即求1！+2！+3！+4！+5！+6！+7！+8！+9！+10！之和)
６．求出1～1000之间的完全平方数。

所谓完全平方数是指能够表示成为另一个证书的平方的整数。

要求每行输出8个数。

７．输入4个int型数，按其大小顺序输出。

８．有一函数如下所示：
x (x<1)
Y= x+5 (1≤x<10)
已知x值时，输出y值。

９．求一元二次方程ax2+bx+c=0的解。

讨论下述情况：
（1）b2-4ac=0,有两个相等实根；
（2）b2-4ac>0,有两个不等实根；
(3) b2-4ac<0,有两个共轭复根；
（4）a=0,不是二次方程。

10．编程输出如下图案。

*
* * *
* * * * *
* * * * * * *
* * * * * * * * *
* * * * * * *
* * * * *
* * *
*
第四章习题
一、选择填空
1.当一个函数无返回值时，定义它时函数的类型应是（）
A. void;
B. 任意; C . int; D. 无;
2.在函数说明时，下列（）项是不必要的。

A.函数的类型;
B.函数参数类型和名次; C .函数名字; D.返回值表达式;
3.在函数的返回值类型与返回值表达式的类型的描述中，（）是错误的。

A.函数的返回值的类型是定义函数时确定的；
B.函数的返回值的类型就是返回值表达式的类型;
C.函数的返回值表达式的类型与函数返回值类型不同时，表达示类型应转换成函数返回
值类型；
D.函数的返回值类型决定了返回值表达式的类型。

4.在一个被调用函数中，关于return语句使用的描述，（）是错误的。

A.被调用函数中可以不用 return语句;
B.被调用函数中可以使用多个return语句;
C.被调用函数中，如果有返回值，就一定要有return语句;
D.被调用函数中，一个return语句可返回多个值给调用函数。

5.下列（）是引用调用
A.形参是指针，实参是地址值；
B.形参和实参都是变量;
C.形参是数组名，实参是数组名；
D.形参是引用，实参是变量。

6.在传值调用中，要求（）。

A.形参和实参类型任意，个数相等;
B.形参和实参类型都完全一致，个数相等;
C.形参和实参对应的类型一致，个数相等;
D.形参和实参对应的类型一致，个数任意。

7.在C++中，关于下列设置参数默认的描述中，（）是正确的。

A.不允许设置参数的默认值;
B.设置参数默认值只能在定义函数时设置；
C.设置参数默认值时，应该是先设置右边的再设置左边的；
D.设置参数默认值时，应该全部参数都设置；
8.重载函数在调用时选择的依据中，（）是错误的。

A.参数个数;
B.参数的类型; C .函数名字; D.函数的类型;
9.下列的标识符中，（）是文件级作用域的。

A.函数形参;
B.语句标号; C .外部静态类标识符；D.自动类标识符。

10.有一个int 型变量，在程序中使用频度很高，最好定义为( )。

; ; C .extern; ;
11.下列标识符中，（）不是局部变量。

类; B.外部static类; C .auto类; D.函数形参;
12.下列存储类标识符中，（）的可见性与存在性不一值。

A.外部类；
B.自动类; C .内部静态类；D.寄存器类。

13.下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，
选用（）合适。

A.内联函数;
B.重载函数; C .递归调用；D.嵌套调用。

14.采用函数重载的目的在于（）。

A.实现共享;
B.减少空间；C .提高速度；D.使用方便，提高可读性。

15.在将两个字符串连接起来组成一个字符串时，选用（）函数。

B.();();C .strcat();.
二、判断下列描述的正确性，对者划√，错者划×。

１．在C++中，定义函数时必须给出函数的类型√
２．在C++中，说明函数时要用函数原型，即定义函数时的函数头部分。

√
３．在C++中，所有函数在调用前都要说明。

×
４．如果一个函数没有返回值，定义时需用void说明。

√
５．在C++中，传址调用将被引用调用所代替。

×
６．使用内联函数是以牺牲增大空间开销为代价的。

√
７．返回值类型、参数个数和类型都相同的函数也可以重载。

×
８．在设置了参数默认值后，调用函数的对应实参就必须省略。

×
９．计算函数参数顺序引起的二义性完全是由不同的编译系统决定的。

√
１０．For循环中，循环变量的作用域是该循环的循环体内。

√
１１．语句标号的作用域是定义该语句标号的文件内。

×
１２．函数形参的作用域是该函数的函数体。

√
１３．定义外部变量时，不用存储类说明符extern, 而说明外部变量时用它。

√
１４．内部静态类变量与自动类变量作用域相同，但是生存期不同。

√
１５．静态生存期的标识符的寿命是短的，而动态生存期的标识符的寿命是长的。

×
１６．重新定义的标识符在定义它的区域内是可见的，而与其同名的原标识符在此区域内是不可见的。

但是，它是存在的。

√
１７．静态类标识符在它的作用域之外是不存在的。

×
１８．所有的函数在定义它的程序中都是可见的。

×
１９．编译系统所提供的系统函数都被定义在他所对应的头文件中。

√
２０．调用系统函数时，要先将该系统函数的原型说明所在的头文件包含进去。

√
三、分析下列程序的输出结果。

1.#include<>
#define N 5
void fun();
void main()
{
for (int i(1);i<N;i++)
fun();
}
void fun ()
{
static int a;
int b(2);
cout<<(a+=3,a+b)<<endl;
}
1．5
8
11
14
2. #include<>
int add(int a,int b);
void main()
{
extern int x,y;
cout<<add(x,y)<<endl;
}
int x(20),y(5);
int add(int a,int b)
{
int s=a+b;
return s;
}
25
3.#include<>
void f(int j);
void main()
{
for(int i(1);i<=4;i++)
f(i);
}
void f(int j)
{
static int a(10);
int b(1);
b++;
cout<<a<<”+”<<b<<”+”<<j<<”=”<<a+b+j<<endl;
a+=10;
}
2．10+2+1=13
20+2+2=24
30+2+3=35
40+2+4=46
4.#include<>
void f(int n)
{
int x(5);
static int y(10);
if(n>0)
{
++x;
++y;
cout<<x<<”,”<<y<<endl;
}
}
void main()
{
int m(1);
f(m);
}
6,11
5.#include<>
int fac(int a);
void main()
{
int s(0);
for(int i(1);i<=5;i++)
s+=fac(i);
cout<<”5!+4!+3!+2!+1!=”<<s<<endl;
}
int fac(int a)
{
static int b=1;
b*=a;
return b;
}
5!+4!+3!+2!+1!=153
6.#include<>
void fun(int ,int , int *);
void main()
{
int x,y,z;
fun(5,6,&x);
fun(7,x,&y);
fun(x,y,&z);
cout<<x<<”,”<<y<<”,”<<z<<endl;
}
void fun(int a,int b,int *c)
{
b+=a;
*c=b-a;
}
6,6,6
7.#include<>
int add(int x, int y=8);
void main()
{
int a(5);
cout<<”sum1=”<<add(a)<<endl;
cout<<”sum2=”<<add(a,add(a))<<endl;
cout<<”sum3=”<<add(a,add(a,add(a)))<<endl;
}
int add(int x,int y)
{
return x+y;
sum1=13
sum2=18
sum3=23
8.#include<>
#define N 6
int f1(int a);
void main()
{
int a(N);
cout<<f1(a)<<endl;
}
int f1(int a)
{
return(a= =0)?1:a*f1(a-1);
}
720
9.#include<>
void swap(int &,int &);
void main()
{
int a(5),b(8);
cout<<”a=”<<a<<”,“<<”b=”<<b<<endl;
swap(a,b);
cout<<”a=”<<a<<”,“<<”b=”<<b<<endl;
}
void swap(int &x,int &y)
int temp;
temp=x;
x=y;
y=temp;
}
a=5,b=8
a=8,b=5
10.#include<>
int &f1(int n,int s[])
{
int &m=s[n];
return m;
}
void main()
{
int s[]={5,4,3,2,1,0};
f1(3,s)=10;
cout<<f1(3,s)<<endl;
}
10
11. #include<>
void print(int),print(char),print(char *);
void main()
{
int u(1998);
print(‘u’);
print(u);
print(“abcd”);
}
void print(char x)
{
cout<<x<<endl;
}
void print(char *x)
{
cout<<x<<endl;
}
void print(int x)
{
cout<<x<<endl;
}
u
1998
abcd
12.#include<>
void ff(int),ff(double);
void main()
{
float a;
ff(a);
char b(‘a’);
ff(b);
}
void ff(int x)
{
cout<<”ff(int):”<<x<<endl;
}
void ff(double x)
{
cout<<”ff(double):”<<x<<endl;
}
ff(double):
ff(int):97
四、按下列要求编程，并上机验证。

１．从键盘上输入15浮点数，求出其和几平均值。

要求写出求和平均值的函数。

２．从键盘上输入10个int型数，去掉重复的。

降其剩余的由大到小排序输出。

３．给定某个年、月、日的值，例如，1998年4月7日。

计算出这一天是该年的第几天。

要求写出计算润年的函数和计算日期的函数。

４．写出一个函数，使从键盘上输入的一个字符串反序存放，并在主函数中输入和输出该字符串。

５．写出一个函数，要求将输入的十六进制数转换成十进制数。

要求函数调用时，使用指针作函数形参。

６．编写两个函数：一个是将一个5位 int型数转换成为每两个数字间加一个空格的空字符串；
另一个是求出转换后的字符串的长度。

由主函数输入int型数，并输出转换后的字符串和长度。

７．输入5个学生4门功课的成绩，然后求出：
A.每个学生的总分；
B. 每门课程的平均分；
C. 输出总分最高的学生的姓名和总分数。

８．使用递归调用方法将一个n位整数转换成字符串。

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

１０．已知二维字符数组s[][5]={“abcd”,”efgh”,”ijkl”,”mnop”};使用字符串处理函
数，将该数组的4个字符串连接起来，组成一个字符串：abcdefghijklmnop。

１１．编程求下式的值：n1+n2+n3+n4+…+n10，其中n=1,2,3。

编写函数时，设置参数n的默认值为2。

１２．编一个程序验证哥德巴赫猜想：任何一个充分大的偶数（大于等于6）总可以表示成两个素数之和。

要求编一个求素数prime()函数，它有一个int型参数，当参数值为素数时返回1，否则返回0。

第五章习题
一、选择填空
1.在下列关键字中，用以说明类中公有成员的是（）
A. public;
B. private;
C. protected;
D. friend;
2.下列的各类函数中，（）不是类的成员函数。

A. 构造函数;
B. 析构函数; C . 友元函数; D. 拷贝初始化构造函数;
3.作用域运算符的功能是（）。

A.标识作用域的级别的；
B. 指出作用域的范围的;
C.给定作用域的大小的；
D. 标识某个成员是属于哪个类的。

4.（）是不可能作为该类的成员的。

A.自身类对象的指针;
B.自身类的对象;
C.自身类对象的引用;
D.另一个类的对象。

5.（）不是构造函数的特征
A.构造函数的函数名与类名相同；
B.构造函数可以重载;
C.构造函数可以设置缺省参数；
D.构造函数必须指定类型说明。

6.（）是析构函数的特征。

A.一个类中只能定义一个析构函数;
B.析构函数与类名不同;
C.析构函数的定义只能在类体内;
D.析构函数可以有各个或多个参数。

7.通常的拷贝初始化函数的参数是（）。

E.某个对象名;
A.某个对象的成员名；
B.某个对象的引用名；
C.某个对象的指针名；
8.关于成员函数特征的下述描述中，（）是错误的。

D.成员函数一般是内联函数；
A.成员函数可以重载；
B.成员函数可以设置参数的缺省值；
C.成员函数可以是静态的。

9.下述静态数据成员的特征中，（）是错误的。

D.说明静态数据成员时前边要加修饰符static;
A.静态数据成员要在类体外进行初始化；
B.引用静态数据成员时，要在静态数据成员名前加<类名>和作用域运算符；
C.静态数据成员不是所有对象所共用的。

10.友元的作用( )。

A.提高程序的运用效率；
B.加强类的封装性;
C.实现数据的隐藏性；
D.增加成员函数的种类。

二、判断下列描述的正确性，对者划√，错者划×。

１．使用关键字class定义的类中缺省的访问权限是私有(private)的。

√
２．作用域运算符（：：）只能用来限定成员函数所属的类。

√
３．析构函数是一种函数体为空的成员函数。

×
４．构造函数和析构函数都不能重载。

×
５．说明或定义对象时，类名前面不需要加class关键字。

√
６．对象成员的表示与结构变量成员表示相同，使用运算符.或->。

√
７．所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类外的函数对它们的访问都是非法的。

×
８．某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。

√
９．可以在类的构造函数中对静态数据成员进行初始化。

×
１０．如果一个成员函数只存取一个类的静态数据成员，则可将该成员函数说明为静态成员函数。

√
三、分析下列程序的输出结果。

1.
#include<>
class A {
public:
A();
A(int i,int j);
void print( );
private:
int a,b;
};
A::A( )
{
a=b=0;
cout<<”Default constructor called.\n”;
}
A::A(int i,int j)
{
a=i;
b=j;
cout<<”Constructor called.\n”;
}
void A::print()
{
cout<<”a=”<<a<<”,b=”<<b<<endl;
}
void main()
{
A m,n(4,8);
();
();
}
Default constructor called.
Constructor called.
A=0,b=0
A=4,b=8
2.
#include<>
class B {
public:
B();
B(int i,int j);
void printb( );
private:
int a,b;
};
class A {
public:
A();
A(int i,int j);
void printa( );
private:
B c;
};
A::A(int i,int j):c(i,j)
{}
void A::printa()
{
();
}
B::B(int i,int j)
{
a=i;
b=j;
}
void B::printb()
{
cout<<”a=”<<a<<”,b=”<<b<<endl;
}
void main()
{
A m(7,9);
();
}
A=7,b=9
3.
#include<>
class Count
{
public:
Count () {count++;}
static int HM(){return count;} ~Count(){count--;}
private:
static int count;
};
int Count::count=100;
void main()
{
Count c1,c2,c3,c4;
cout<<Count::HM()<<endl;
}
104
4.
#include<>
class A
{
public:
A(double t,double r){Total=t;Rate=r;} friend double Count(A&a)
{
+=*;
return ;
}
private:
double Total,Rate;
};
void main()
{
A a1,,a2,;
cout<<Count(a1)<<”,”<<Count(a2)<<endl; }
1035,789,504
5.
#include<>
class Set
{
public:
Set(){PC=0;}
Set(Set &s);
void Empty() {PC=0;}
int IsEmpty() {return PC= =0;}
int IsMemberOf(int n);
int Add(int n);
void Print();
friend void reverse(Set *m); private:
int elems[100];
int PC;
};
int Set::IsMemberOf(int n)
{
for (int i=0;i<PC;i++)
if(elems[i]= =n)
return 1;
return 0;
}
int Set::Add(int n)
{
if(IsMemberOf(n))
return 1;
else if(PC>=100)
return 0;
else
{
elems[PC++]=n;
return 1;
}
}
Set::Set(Set &p)
{
PC=;
for(int i=0;i<PC;i++)
elems[i]=[i];
}
void Set::Print()
{
cout<<”{“;
for (int i=0;i<PC-1;i++)
cout<<elems[i]<<”,”;
if(PC>0)
cout<<elems[PC-1];
cout<<”}”<<endl;
}
void reverse(Set *m)
{
int n=m->PC/2;
for(int i=0;i<n;i++)
{
int temp;
temp=m->elems[i];
m->elems[i]=m->elems[m->PC-i-1];
m->elems[m->PC-i-1]=temp;
}
}
void main()
{
Set A;
cout<<()<<endl;
();
Set B;
for(int i=1;i<=8;i++)
(i);
();
cout<<(5)<<endl;
();
for(int j=11;j<20;j++)
(j);
Set C(B);
();
reverse (&C);
();
}
1
{}
{1,2,3,4,5,6,7,8}
1
{11,12,13,14,15,16,17,18,19}
{19,18,17,16,15,14,13,12,11}
四、按下列要求编程。

在一个程序中，实现如下要求：
（1）构造函数重载；
（2）成员函数设置缺省参数
（3）有一个友元函数。