-
《C++语言基础教程》
第一章 习题
一、 选择填空
1.下列各种高级语言中，（ ）是面向对象的程序设计语言。
A.BASIC; B.PASCAL; C.C++ D.Ada
2.下列各种高级语言中，（ ）是最早提出了对象的概念。
A.Algol 60; B.Simula 67; C.Smalltalk; D.C++
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++允许使用友元，但是友元会破坏封装性。√
3． C++中使用了新的注释符（//），C语言中注释符（/*…*/）不能在C++中使用。×
4． C++中为了减轻使用者的负担，与C语言相比较C++中减少了一些运算符。×
5． C++程序中，每条语句结束时都加一个分号（；）。√
6． C++中标识符内的大小写字母是没有区别的。×
7． C++中不允许使用宏定义的方法定义符号常量，只能用关键字const来定义符号常量。×
8． 在编写C++程序时，一定要注意采用人们习惯使用的书写格式，否则将会降低其可读性。√
9． C++是一种以编译方式实现的高级语言。√
10． 在C++编译过程中，包含预处理过程、编译过程和连接过程，并且这三个过程的顺序是不能改变的。√
11． 预处理过程是一般编译过程之后连接过程之前进行的。×
12． 源程序在编译过程中可能会出现一些错误信息，但在连接过程中将不会出现错误信息。×
三、分析下列程序的输出结果
1．#include<iostream.h>
void main()
{
cout<<"BeiJing"<<" ";
cout<<"ShangHai"<<"\n ";
cout<<"TianJing"<<endl;
}
1． BeiJjing ShangHai
TianJing
2. #include<iostream.h>
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
2． Input a,b:8 5
A=8,b=5
A-b=3
3．#include <iostream.h>
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<iostream.h>
void main()
{
cout<<”This is a string!”;
}
输出结果：This is a string!
2、 #include<iostream.h>
void main( )
{
cin>>x;
int p=x*x;
cout<<"p=<<p<<\n";
}
#include<iostream.h>
void main( )
{
int x;
cin>>x;
int p=x*x;
cout<<”p=”<<p<<”\n”;
}
输出结果：3
p=9
3、 #include <iostream.h>
void main ( )
{ int i,j;
i=5;
int k=i+j;
cout<<"i+j="<<k<<"\n";
}
#include <iostream.h>
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; C.long 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、下列变量名中，（ ）是合法的。
A.CHINA; B. byte-size; C. double; D. A+a
8、在int a[5]={1,3,5};中，数组元素a[1]的值是（ ）。
A. 1; B. 0; C.3; D.2
9、在int b[][3]={{1},{3,2},{4,5,6},{0}};中a[2][2]的值是（ ）。
A.0; B. 5; C.6; D.2
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的地址值；D.3
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=5.5;
A. a%3+b; B. b*b&&++a; C.(a>b)+(int(b)%2); D. -- -a+b
22、下列表达式中，（）是合法的。
已知：double m=3.2; int n=3;
A. m<<2; B. (m+n)|n C. !m*=n; D. m=5,n=3.1,m+n
23、下列关于类型转换的描述中，（）是错误的。
A． 在不同类型操作数组成的表达式中，其表达式类型一定是最高类型double型；
B． 逗号表达式的类型是最后一个表达式的类型；
C． 赋值表达式的类型是左值的类型；
D． 在由底向高的类型转换中是保值映射。
24、下列各表达式中，（）有二义性。
已知：int a（5）; b（6）;
A. a+b>>3; B. ++a+b++; C.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; B.x^y; C.x&y; D.~x+~y; E.x<<=3; F.y>>=4.
| A | B | C | D | E | F |
| 47 | 38 | 9 | 4294967238 | 104 | 2 |
2、 已知:inti(10),j(5);
A.++i-j--; B.i=i*=j; C.i=3/2*(j=3-2); D.~i^j; E.i&j|1; F.i+i&0xff.
| A | B | C | D | E | F |
| 6 | 50 | 1 | -16 | 1 | 20 |
3、 已知：int a(5),b(3);计算下列表达式得值以及a和b的值。
A.！a&&b++; B.a||b+4&&a*b; C.a=1,b=2,a>b?++a:++b; D.++b,a=10,a+5;
E.a+=b%=a+b; F.a!=b>2<=a+1.
| A | B | C | D | E | F |
| 0,5,3 | 1,5,3 | 3,1,3 | 15,10,4 | 8,8,3 | 1,5,3 |
4、 已知：int d(5),*pd=&d,&rd=d;
A.d+-rd; B.*pd*rd; C.++*pd-rd; D.++rd-d.
| A | B | C | D |
| 0 | 25 | 0 | 0 |
5、 已知：’1’的ASCII码的值为49。
A.3+2<<1+1; B.2*9|3<<1; C.5%-3*2/6-3; D.8= =3<=2&5;
E.!(‘3’>’5’)||2<6; F.6>=3+2-(‘0’-7).
| A | B | C | D | E | F |
| 20 | 22 | -3 | 0 | 1 | 1 |
四、 按下列要求编写程序
1． 从键盘上输入两个int型数，比较其大小，并输出显示其中小的。
2． 从键盘上输入一个int型数，一个浮点型数比较其大小，并输出其中大的。
3． 输入一摄氏温度，编程输出华氏温度。已知：华氏温度转换为摄氏温度的计算公式如下：C=(F-32)*5/9
其中，F表示华氏温度，C表示摄氏温度。
#include <iostream.h>
void main()
{
float c,f;
cout<<”华氏温度：”; cin>>f;
c=(f-32)*5/9;
cout<<” 摄氏温度：”<<c<<endl;
}
4． 编程实现输入公里数，输出显示其英里数。已知：1英里=1.60934公里（用符号常量）。
#include <iostream.h>
const float r=1.60934;
void main()
{
float m,I;
cout<<” 公里数：”;
cin>>m;
I=r*m;
cout<<”英里数：”<<I<<endl;
}
5． 输入一个int型数，将它的低4位（右4位）都置为1。
#include <iostream.h>
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. ；; B.a=17; C .x+y; D. cout<<”\n”;
6. 下列for循环的次数为（ ）。
for(int i(0),x=0;!x&&i<=5;i++)
A.5; B.6; C .1; D.无限;
7. 下列while循环的次数是（ ）。
while(int i=0)i- -;
A.0; B.1; C .5 ; D.无限;
8. 下列do-while循环的循环次数为（ ）。
已知：int i(5);
do{cout<<i- - <<endl;
i- - ;
}while(i!=0);
A.0; B.1; C .5; D.无限;
9. 下列for循环的循环体执行次数为（ ）。
for(int i(0),j(10);i=j=10;i++,j- -)
A.0; B.1; 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<iostream.h>
#define M 1.5
#define A(a) M*a
void main()
{
int x(5),y(6);
cout<<A(x+y)<<endl;
}
13.5
2.
#include<iostream.h>
#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<iostream.h>
#include”f1.cpp”
void main()
{
int a(5),b;
b=f1(a);
cout<<b<<endl;
}
f1.cpp文件内容如下：
#define M(m) m*m
f1(int x)
{
int a(3);
return –M(x+a);
}
13
4.
#include<iostream.h>
void main()
{
int i(0);
while(++i)
{
if(i= =10) break;
if(i%3!=1) continue;
cout<<i<<endl;
}
}
1
4
7
5.
#include<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
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值时，输出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 型变量，在程序中使用频度很高，最好定义为( )。
A.register; B.auto; C .extern; D.static;
11. 下列标识符中，（ ）不是局部变量。
A.register类; B.外部static类; C .auto类; D.函数形参;
12. 下列存储类标识符中，（ ）的可见性与存在性不一值。
A. 外部类； B.自动类; C .内部静态类；D.寄存器类。
13. 下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（）合适。
A.内联函数; B.重载函数; C .递归调用；D.嵌套调用。
14. 采用函数重载的目的在于（ ）。
A.实现共享;B.减少空间；C .提高速度；D.使用方便，提高可读性。
15. 在将两个字符串连接起来组成一个字符串时，选用（ ）函数。
B. A.strlen();B.strcpy();C .strcat();D.strcmp.
二、 判断下列描述的正确性，对者划√，错者划×。
１． 在C++中，定义函数时必须给出函数的类型√
２． 在C++中，说明函数时要用函数原型，即定义函数时的函数头部分。√
３． 在C++中，所有函数在调用前都要说明。×
４． 如果一个函数没有返回值，定义时需用void说明。√
５． 在C++中，传址调用将被引用调用所代替。×
６． 使用内联函数是以牺牲增大空间开销为代价的。√
７． 返回值类型、参数个数和类型都相同的函数也可以重载。×
８． 在设置了参数默认值后，调用函数的对应实参就必须省略。×
９． 计算函数参数顺序引起的二义性完全是由不同的编译系统决定的。√
１０． For循环中，循环变量的作用域是该循环的循环体内。√
１１． 语句标号的作用域是定义该语句标号的文件内。×
１２． 函数形参的作用域是该函数的函数体。√
１３． 定义外部变量时，不用存储类说明符extern, 而说明外部变量时用它。√
１４． 内部静态类变量与自动类变量作用域相同，但是生存期不同。√
１５． 静态生存期的标识符的寿命是短的，而动态生存期的标识符的寿命是长的。×
１６． 重新定义的标识符在定义它的区域内是可见的，而与其同名的原标识符在此区域内是不可见的。但是，它是存在的。√
１７． 静态类标识符在它的作用域之外是不存在的。×
１８． 所有的函数在定义它的程序中都是可见的。×
１９． 编译系统所提供的系统函数都被定义在他所对应的头文件中。√
２０． 调用系统函数时，要先将该系统函数的原型说明所在的头文件包含进去。√
三、 分析下列程序的输出结果。
1.#include<iostream.h>
#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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
#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<iostream.h>
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<iostream.h>
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<iostream.h>
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<iostream.h>
void ff(int),ff(double);
void main()
{
float a(88.18);
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):88.18
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<iostream.h>
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);
m.print();
n.print();
}
Default constructor called.
Constructor called.
A=0,b=0
A=4,b=8
2.
#include<iostream.h>
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()
{
c.printb();
}
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);
m.printa();
}
A=7,b=9
3.
#include<iostream.h>
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<iostream.h>
class A
{
public:
A(double t,double r){Total=t;Rate=r;}
friend double Count(A&a)
{
a.Total+=a.Rate*a.Total;
return a.Total;
}
private:
double Total,Rate;
};
void main()
{
A a1(1000.0,0.035),a2(768.0,0.028);
cout<<Count(a1)<<”,”<<Count(a2)<<endl;
}
1035,789,504
5.
#include<iostream.h>
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=p.PC;
for(int i=0;i<PC;i++)
elems[i]=p.elems[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<<A.IsEmpty()<<endl;
A.Print();
Set B;
for(int i=1;i<=8;i++)
B.Add(i);
B.Print();
cout<<B.IsMemberOf(5)<<endl;
B.Empty();
for(int j=11;j<20;j++)
B.Add(j);
Set C(B);
C.Print();
reverse (&C);
C.Print();
}
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） 有一个友元函数
（4） 有一个静态函数
（5） 使用不同的构造函数创建不同对象。
第六章 习题
一、 选择填空
1. 已知一个类A，（ ）是指向类A成员函数的指针。假设类有三个公有成员：void f1(int)， void f2(int)和int a。
A. A*p; B. int A::*pc=&A::a; C. void A::*pa; D. A *pp;
2. 运算符->* 的功能是（ ）。
A. 用来表示指向对象指针对指向类成员指针的操作;
B. 用来表示对象对指向类成员指针的操作；
C. 用来表示指向对象指针对类成员的操作；
D. 用来表示对象类成员的操作。
3. 已知f1(int)是类A的公有成员函数，p是指向成员函数f1()的指针，采用（ ）是正确的。
A. p=f1;
B. p=A::f1;;
C. p=A::f1();
D. p=f1();
4. 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，（ ）是正确的。
A. A1.p=5;
B. A1->p=5;
C. A.*p=5;
D. *A1.p=5。
5. 已知：类A中一个成员函数说明如下：void Set(A&a);其中，A &a的含意是（ ）
A. 指向类A的指针为a；
B. 将a的地址值赋给变量Set;
C. a是类A的对象引用，用来作函数Set()的形参；
D. 变量A与a按位相与作为函数Set()的参数。
6. 下列关于对象数组的描述中，（ ）是错的。
A. 对象数组的下标是从0开始的;
B. 对象数组的数组名是一个常量指针;
C. 对象数组的每个元素是同一个类的对象;
D. 对象数组只能赋初值，而不能被赋值。
7. 下列定义中，（ ）是定义指向数组的指针p。
E. int *p[5];
F. int (*p)[5]；
A. (int *)p[5]；
B. int *p[ ]；
8. 下列说明中，const char *ptr; ptr应该是（ ）。
A. 指向字符常量的指针；
B. 指向字符的常量指针；
C. 指向字符串常量的指针；
D. 指向字符串的常量指针。
9. 已知：print()函数是一个类的常成员函数，它无返回值，下列表示中，（ ）是正确的。
A.void print () const; B.const void print()；
C.void const print()； D.void print(const);
10. 关于new运算符的下列描述中，( )是错的。
A. 它可以用来动态创建对象和对象数组；
B. 使用它创建的对象或对象数组可以使用运算符delete删除;
C. 使用它创建对象时要调用构造函数；
D. 使用它创建对象数组时必须指定初始值。
11. 关于delete运算符的下列描述中，( )是错的。
A. 它必须用于new返回的指针；
B. 它也适用于空指针;
C. 对一个指针可以使用多次该运算符；
D. 指针名前只用一对方括号符，不管所删除数组的维数。
12. 具有转换函数功能的构造函数，应该是（ ）。
A. 不带参数的构造函数;
B. 带有一个参数的构造函数；
C. 带有两个以上参数的构造函数；
D. 缺省构造函数;
二、 判断下列描述的正确性，对者划√，错者划×。
１． 指向对象的指针和指向类的成员的指针在表示形式上是不相同的。√
２． 已知：m是类A的对象，n是类A的公有数据成员，p是指向类A中n成员的指针。下述两种表示是等价的：m.c和m.*p。√
３． 指向对象的指针与对象都可以作函数参数，但是使用前者比后者好些。√
４． 对象引用作函数参数比用对象指针更方便些。√
５． 对象数组的元素可以是不同类的对象。×
６． 对象数组既可以赋初值又可以赋值。√
７． 指向对象数组的指针不一定必须指向数组的首元素。√
８． 一维对象指针数组的每个元素应该是某个类的对象的地址值。√
９． const char *p说明了p是指向字符串的常量指针。×
１０． 一个能够更新的变量使用在一个不能被更新的环境中是不破坏类型保护的，反之依然。√
１１． 一个类的构造函数中可以不包含对其子对象的初始化。×
１２． 转换函数不是成员函数，它是用来进行强制类型转换的。×
三、 分析下列程序的输出结果。
1.
#include<iostream.h>
class A {
public:
A();
A(int i,int j);
~A();
void Set(int i,int j){a=i;b=j;}
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 :a=”<<a<<”,b=”<<b<<endl;
}
A::~A()
{
cout<<”Destructor called. a=”<<a<<”,b=”<<b<<endl;
}
void main()
{
cout<<”Starting1…\n”;
A a[3];
for(int i=0;i<3;i++)
a[i].Set(2*i+1,(i+1)*2);
cout<<”Ending1…\n”;
cout<<”starting2…\n”;
A b[3]={A(1,2),A(3,4),A(5,6)};
cout<<”Ending2…\n”;
}
2.
#include<iostream.h>
class B {
int x,y;
public:
B();
B(int i);
B(int i,int j);
~B();
void print( );
};
B::B()
{
x=y=0;
cout<<”Default constructor called.\n”;
}
B::B(int i)
{
x=i;
y=0;
cout<<”Constructor1 called.\n”;
}
B::B(int i,int j)
{
x=i;
y=j;
cout<<”Constructor2 called.\n”;
}
B::~B()
{
cout<<”Destructor called.\n”;
}
void B::print()
{
cout<<”x=”<<x<<”,y=”<<y<<endl;
}
void main()
{
B *ptr;
ptr=new B[3];
ptr[0]=B();
ptr[1]=B(5);
ptr[2]=B(2,3);
for(int i=0;i<3;i++)
ptr[i].print();
delete[] ptr;
}
3.
#include<iostream.h>
class A
{
public:
A (int i=0) {m=i;cout<<”constructor called.”<<m<<”\n”;}
void Set(int i){m=i;}
void Print() const {cout<<m<<endl;}
~A(){cout<<”destructor called.”<<m<<”\n”;}
private:
int m;
};
void main()
{
const N=5;
A my;
my=N;
my.Print();
}
4.
#include<iostream.h>
class A
{
public:
A(int i=0){m=i;cout<<”constructor called.”<<m<<”\n”;}
void Set(int i){m=i;}
void Print() const{cout<<m<<endl;}
~A(){cout<<”destructor called.”<<m<<”\n”;}
private:
int m;
};
void fun(const A &c)
{
c.Print();
}
void main()
{
fun(5);
}
5.
#include<iostream.h>
class complex
{
public:
complex();
complex(double real);
complex(double real,double imag);
void print();
void set(double r,double i);
private:
double real,imag;
};
complex::complex()
{
set(0.0,0.0);
cout<<”Default constructor called.\n”;
}
complex::complex(double real)
{
set(real,0.0);
cout<<”Constructor:real=”<<real<<”.imag=”<<imag<<endl;
}
complex::complex(double real,double imag)
{
set(real,imag);
cout<<”Constructor:real=”<<real<<”.imag=”<<imag<<endl;
}
void complex::print()
{
if(imag<0)
cout<<real<<imag<<”i”<<endl;
else
cout<<real<<”+”<<imag<<”i”<<endl;
}
void complex::set(double r,double i)
{
real=r;
imag=i;
}
void main()
{
complex c1;
complex c2(6.8);
complex c3(5.6,7.9);
c1.print();
c2.print();
c3.print();
c1=complex(1.2,3.4);
c2=5;
c3=complex();
c1.print();
c2.print();
c3.print();
}
四、 分析下列程序，并回答提出的问题。
#include <iostream.h>
#include <string.h>
class String
{
public:
String(){Length=0;Buffer=0;}
String(const char *str);
void Setc(int index,char newchar);
char Getc(int index) const;
int GetLength() const {return Length;}
void Print() const
{
if(Buffer= = 0)
cout<<”empty.\n”;
else
cout<<Buffer<<endl;
}
void Append(const char *Tail);
~String() {delete[ ]Buffer;}
private:
int Length;
char *Buffer;
};
String::String(const char *str)
{
Length=strlen(str);
Buffer=new char[Length+1];
strcpy(Buffer,str);
}
void String::Setc(int index,char newchar)
{
if(index>0&&index<=Length)
Buffer[index-1]=newchar;
}
char String::Getc(int index) const
{
if(index>0&&index<=Length)
return Buffer[index-1];
else
return 0;
}
void String::Append(const char *Tail)
{
char *tmp;
Length+=strlen(Tail);
tmp=new char[Length+1];
strcpy(tmp,Buffer);
strcat(tmp,Tail);
delete[] Buffer;
Buffer=tmp;
}
void main()
{
String s0,s1(“a string.”);
s0.Print();
s1.Print();
cout<<s1.GetLength()<<endl;
s1.Setc(5,’p’);
s1.Print();
cout<<s1.Getc(6)<<endl;
String s2(“this”);
s2.Append(“a string.”);
s2.Print();
}
回答下列问题：
（1） 该程序中调用哪些在string.h中所包含的函数？
（2） 该程序的String类中是否用了函数重载的方法？哪些函数的重载的？
（3） 简述Setc()函数有何功能？
（4） 简述Getc()函数有何功能？
（5） 简述Append()函数有何功能？
（6） 该程序的成员函数Print()中不用if语句，只写成如下一条语句，行否？cout<Buffer<<endl;
（7） 该程序中有几处使用了new运算符？
（8） 写出该程序执行后的输出结果。
第七章 习题
一、 选择填空
1. 下列对派生类的描述中，（ ）是错的。
E. 一个派生类可以作另一个派生类的基类；
F. 派生类至少有一个基类；
G. 派生类的成员除了它自己的成员外，还包含了它的基类的成员；
H. 派生类中继承的基类成员的访问权限到派生类保持不变。
2. 派生类的对象对它的基类成员中（ ）是可以访问的。
I. 公有继承的公有成员;
J. 公有继承的私有成员；
K. 公有继承的保护成员；
L. 私有继承的公有成员。
3. 对基类和派生类的关系描述中，（ ）是错的。
M. 派生类是基类的具体化;
N. 派生类是基类的字集;
O. 派生类是基类定义的延续;
P. 派生类是基类的组合;
4. 派生类的构造函数的成员初始化列中，不能包含（ ）。
Q. 基类的构造函数;
R. 派生类中子对象的初始化;
S. 基类的子对象初始化;
T. 派生类中一般数据成员的初始化。
5. 关于子类型的描述中，（ ）是错的。
U. 子类型就是指派生类是基类的子类型；
V. 一种类型当它至少提供了另一种类型的行为，则这种类型是另一种类型的子类型;
W. 在公有继承下，派生类是基类的子类型；
X. 子类型关系是不可逆的。
6. 关于多继承二义性的描述中，（ ）是错的。
Y. 一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性;
Z. 解决二义性的最常用的方法是对成员名的限定法;
AA. 基类和派生类中同时出现的同名函数，也存在二义性问题;
BB. 一个派生类是从两个基类派生来得，而这两个基类又有一个共同的基类，对该基类成员进行访问时，也可能出现二义性。
7. 设置虚基类的目的是（ ）。
CC. 简化程序;
DD. 消除二义性；
EE. 提高运行效率；
FF. int *p[ ]减少目标代码；
8. 带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数，这样将对虚基类的子对象初始化（ ）。
GG. 与虚基类先面的派生类个数有关；
HH. 多次；
II. 二次；
JJ. 一次。
二、 判断下列描述的正确性，对者划√，错者划×。
１． C++语言中，既允许单继承，又允许多继承。√
２． 派生类是从基类派生出来，它不能再生成新的派生类。×
３． 派生类的继承方式有两种：公有继承和私有继承。×
４． 在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。×
５． 在公有继承中，基类中只有公有成员对派生类是可见的。√
６． 在私有继承中，基类中只有公有成员对派生类是可见的。。×
７． 在私有继承中，基类中所有成员对派生类的对象都是不可见的。√
８． 在保护继承中，对于垂直访问同于公有继承，而对于水平访问同于私有继承。。√
９． 派生类是它的基类组合。√
１０． 构造函数可以被继承。×
１１． 析构函数不能被继承。√
１２． 子类型是不可逆的。√
１３． 只要是类M继承了类N，就可以说类M是类N的子类型。×
１４． 如果A类型是B类型的子类型，则A类型必然适应于B类型。√
１５． 多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。√
１６． 单继承情况下，派生类中对基类成员的访问也会出现二义性。×
１７． 解决多继承情况下出现的二义性的方法之一是使用成员名限定法。√
１８． 虚基类是用来解决多继承中公共基类在派生类中只产生一个基类子对象的问题。√
三、 回答下列问题
1. 在下面给定的含有虚基类的复杂继承结构中，回答下列提出的各问题。
class A {
public:
void f();
};
class B:virtual public A
{
public:
void f();
};
class C:public B
{
};
class D:public c,virtual public A
{
public:
void g();
};
问题：
（1） 画出上述结构的DAG图。
（2） 设有D d,问d.f()是否有二义性？
（3） 设有void D::g() {f();} 问：g()函数中对f()调用是否有二义性？
2. 在下面给定的继承结构中，回答下列提出的问题：
class A
{
public:
int a;
int b();
int f();
int f(int);
int g();
};
class B {
public:
char f();
int g();
private:
int a;
int b();
};
class C:public A,public B
{
};
设有：C *pc;
问题：
（1） pc->a=1;是否有二义性？
（2） pc->b();是否有二义性？
（3） pc->f();是否有二义性？
（4） pc->f(10);是否有二义性？
（5） pc->g();是否有二义性？
提示：二义性检查是在访问控制权限或类型检查之前进行的。
四、 分析下列程序的输出结果。
1、
#include <iostream.h>
class A
{
public:
A(int i,int j){a=i;b=j;}
void Move(int x,int y){a+=x;b+=y;}
void Show(){cout<<”(”<<a<<”,”<<b<<”)”<<endl;}
private:
int a,b;
};
class B:private A
{
public:
B(int i,int j, int k,int l):A(i,j) {x=k;y=l;}
void Show() {cout<<x<<”,”<<y<<endl;}
void fun() {Move(3,5);}
void f1() {A::Show();}
private:
int x,y;
};
void main()
{
A e(1,2);
e.Show();
B d(3,4,5,6);
d.fun();
d.Show();
d.f1();
}
(1,2)
5,6
(6,9)
2、
#include <iostream.h>
class A
{
public:
A(int i,int j){a=i;b=j;}
void Move(int x,int y){a+=x;b+=y;}
void Show(){cout<<”(”<<a<<”,”<<b<<”)”<<endl;}
private:
int a,b;
};
class B:public A
{
public:
B(int i,int j, int k,int l):A(i,j),x(k),y(l) { }
void Show() {cout<<x<<”,”<<y<<endl;}
void fun() {Move(3,5);}
void f1() {A::Show();}
private:
int x,y;
};
void main()
{
A e(1,2);
e.Show();
B d(3,4,5,6);
d.fun();
d.A::Show();
d.B::Show();
d.f1();
}
(1,2)
(6,9)
5,6
(6,9)
3、
#include <iostream.h>
class L
{
public:
void InitL(int x,int y) {X=x;Y=y;}
void Move(int x,int y){X+=x;Y+=y;}
int GetX() {return X;}
int GetY(){return Y;}
private:
int X,Y;
};
class R:public L
{
public:
void InitR(int x,int y, int w, int h)
{
InitL(x,y);
W=w;
H=h;
}
int GetW(){return W;}
int GetH() {return H;}
private:
int W,H;
};
class V:public R
{
public:
void fun() {Move(3,2);}
};
void main()
{
V v;
v.InitR(10,20,30,40);
v.fun();
cout<<"{"<<v.GetX()<<","<<v.GetY()<<","<<v.GetW()<<","<<v.GetH()<<"}"<<endl;
}
{13，22，30，40}
4、
#include <iostream.h>
class P
{
public:
P(int p1,int p2) {pri1=p1;pri2=p2;}
int inc1() {return ++pri1;}
int inc2() {return ++pri2;}
void display() {cout<<”pri1=”<<pri1<<”,pri2=”<<pri2<<endl;}
private:
int pri1,pri2;
};
class D1:private P
{
public:
D1(int p1,int p2,int p3):P(p1,p2)
{
pri3=p3;
}
int inc1() {return P::inc1();}
int inc3() {return ++pri3;}
void display()
{
P::display();
cout<<”pri3=”<<pri3<<endl;
}
private:
int pri3;
};
class D2:public P
{
public:
D2(int p1,int p2,int p4):P(p1,p2)
{pri4=p4;}
int inc1()
{
P::inc1();
P::inc2();
return P::inc1();
}
int inc4() {return ++pri4;}
void display()
{P::display();
cout<<”pri4=”<<pri4<<endl;
}
private:
int pri4;
};
class D12:private D1,public D2
{
public:
D12(int p11,int p12,int p13,int p21,int p22,int p23,int p)
:D1(p11,p12,p13),D2(p21,p22,p23)
{ pri12=p;}
int inc1()
{
D2::inc1();
return D2::inc1();
}
int inc5() {return ++pri12;}
void display()
{
cout<<”D2::display()\n”;
D2::display();
cout<<”pri12=”<<pri12<<endl;
}
private:
int pri12;
};
void main()
{
D12 d(1,2,3,4,5,6,7);
d.display();
cout<<endl;
d.inc1();
d.inc4();
d.inc5();
d.D12::inc1();
d.display();
}
5、
#include <iostream.h>
class P
{
public:
P(int p1,int p2){pri1=p1;pri2=p2;}
int inc1() {return ++pri1;}
int inc2() {return ++pri2;}
void display() {cout<<”pri1=”<<pri1<<”,pri2=”<<pri2<<endl;}
private:
int pri1,pri2;
};
class D1:virtual private P
{
public:
D1(int p1,int p2,int p3):P(p1,p2)
{
pri3=p3;
}
int inc1() {return P::inc1();}
int inc3() {return ++pri3;}
void display()
{
P::display();
cout<<”pri3=”<<pri3<<endl;
}
private:
int pri3;
};
class D2:virtual public P
{
public:
D2(int p1,int p2,int p4):P(p1,p2)
{pri4=p4;}
int inc1()
{
P::inc1();
P::inc2();
return P::inc1();
}
int inc4() {return ++pri4;}
void display()
{P::display();
cout<<”pri4=”<<pri4<<endl;
}
private:
int pri4;
};
class D12:private D1,public D2
{
public:
D12(int p11,int p12,int p13,int p21,int p22,int p23,int p)
:D1(p11,p12,p13),D2(p21,p22,p23),P(p11,p21)
{ pri12=p;}
int inc1()
{
D2::inc1();
return D2::inc1();
}
int inc5() {return ++pri12;}
void display()
{
cout<<”D2::display()\n”;
D2::display();
cout<<”pri12=”<<pri12<<endl;
}
private:
int pri12;
};
void main()
{
D12 d(1,2,3,4,5,6,7);
d.display();
cout<<endl;
d.inc1();
d.inc4();
d.inc5();
d.D12::inc1();
d.display();
}
第八章 习题
一、 选择填空
1. 对定义重载函数的下列要求中，（ ）是错的。
KK. 要求参数的个数不同；
LL. 要求参数中至少有一个类型不同；
MM. 要求参数个数相同时，参数类型不同；
NN. 要求函数的返回值不同。
2. 下列函数中，（ ）不能重载。
OO. 成员函数;
PP. 非成员函数；
QQ. 析构函数；
RR. 构造函数。
3. 下列对重载函数的描述中，（ ）是错的。
SS. 重载函数中不允许使用缺省参数;
TT. 重载函数中编译系统会根据参数表进行选择;
UU. 不要使用重载函数来描述毫无相干的函数;
VV. 构造函数重载将会给初始化带来多种方式;
4. 下列运算符中，（ ）运算符不能重载。
WW. &&; B. [ ]; C. :: ; D.new
5. 下列关于运算符重载的描述中，（ ）是正确的。
XX. 运算符重载可以改变操作数的个数；
YY. 运算符重载可以改变优先级;
ZZ. 运算符重载可以改变结合性；
AAA. 运算符重载不可以改变语法结构。
6. 运算符重载函数是（ ）。
BBB. 成员函数;
CCC. 友元函数;
DDD. 内联函数;
EEE. 带缺省参数的函数。
7. 关于动态联编的下列描述中，（ ）是错误的。
FFF. 动态联编是以虚函数为基础的;
GGG. 动态联编是在运行时确定所调用的函数代码的；
HHH. 动态联编调用函数操作是指向对象的指针或对象引用；
III. 动态联编是在编译时确定操作函数的；
8. 关于虚函数的描述中，（ ）是正确的。
JJJ. 虚函数是一个static类型的成员函数；
KKK. 虚函数是一个非成员函数；
LLL. 基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数；
MMM. 派生类的虚函数与基类的虚函数具有不同的参数个数和类型。
9. 关于纯虚函数和抽象类的描述中，（ ）是错误的。
NNN. 纯虚函数是一种特殊的虚函数，它没有具体的实现;
OOO. 抽象类是指具有纯虚函数的类；
PPP. 一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类；
QQQ. 抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出；
10. 下列描述中，（ ）是抽象类的特性。
RRR. 可以说明虚函数；
SSS. 可以进行构造函数重载；
TTT. 可以定义友元函数；
UUU. 不能说明其对象。
二、 判断下列描述的正确性，对者划√，错者划×。
１． 函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。√
２． 重载函数可以带有缺省值参数，但是要注意二义性。√
３． 多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数定义实现的。√
４． 对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。。×
５． 对单目运算符重载为友元函数时，说明一个形参；重载为成员函数时，不能显式说明形参。√
６． 重载运算符保持原运算符的优先级和结合性不变。√
７． 虚函数是用virtual关键字说明的成员函数。√
８． 构造函数说明为纯虚函数是没有意义的。√
９． 抽象类是指一些没有说明对象的类。×
１０． 动态联编是在运行时选定调用的成员函数的。√
三、 分析下列程序的输出结果。
1、
#include <iostream.h>
class B
{
public:
B(int i){b=i+50;show();}
B(){}
virtual void show(){cout<<”B::show() called.”<<b<<endl;}
protected:
int b;
};
class D:public B
{
public:
D(int i):B(i) {d=i+100;show();}
D() {}
void show() {cout<<”D::show() called.”<<d<<endl;}
protected:
int d;
};
void main()
{
D d1(108);
}
2、
#include <iostream.h>
class B
{
public:
B(){}
B(int i){b=i;}
virtual void virfun(){cout<<”B::virfun() called.\n”;}
private:
int b;
};
class D:public B
{
public:
D(){}
D(int i,int j):B(i) {d=j; }
private:
int d;
void virfun() {cout<<”D::virfun() called.\n”; }
};
void fun(B *obj)
{ obj->virfun(); }
void main()
{
D *pd=new D;
fun(pd);
}
3、
#include <iostream.h>
class A
{
public:
A(){ver=’A’;}
void print() {cout<<”The A version”<<ver<<endl;}
protected:
char ver;
};
class D1:public A
{
public:
D1(int number){info=number; ver=’1’;}
void print()
{ cout<<”The D1 info: ”<<info<<”version”<<ver<<endl;}
private:
int info;
};
class D2:public A
{
public:
D2(int number){info=number;}
void print()
{cout<<”The D2 info”<<info<<”version”<<ver<<endl;}
private:
int info;
};
class D3:public D1
{
public:
D3(int number):D1(number)
{info=number; ver=’3’;}
void print()
{cout<<”The D3 info”<<info<<”version”<<ver<<endl;}
private:
int info;
};
void print_info(A *p)
{ p->print(); }
void main()
{
A a;
D1 d1(4);
D2 d2(100);
D3 d3(-25);
print_info(&a);
print_info(&d1);
print_info(&d2);
print_info(&d3);
}
4、
#include <iostream.h>
class A
{
public:
A() {ver=’A’;}
virtual void print() {cout<<”The A version”<<ver<<endl;}
protected:
char ver;
};
class D1:public A
{
public:
D1(int number)
{
info=number;ver=’1’;
}
void print()
{
cout<<”The D1 info:”<<info<<”version”<<ver<<endl;
}
private:
int info;
};
class D2:public A
{
public:
D2(int number) {info=number;}
void print()
{
cout<<”The D2 info:”<<info<<”version”<<ver<<endl;
}
private:
int info;
};
class D3:public D1
{
public:
D3(int number) :D1(number)
{ info=number;ver=’3’;}
void print()
{
cout<<”The D3 info:”<<info<<”version”<<ver<<endl;
}
private:
int info;
};
void print_info(A *p)
{ p->print(); }
void main()
{
A a;
D1 d1(4);
D2 d2(100);
D3 d3(-25);
print_info(&a);
print_info(&d1);
print_info(&d2);
print_info(&d3);
}
5、
#include <iostream.h>
class Matrix
{
public:
Matrix(int r,int c){row=r;col=c;elem=new double[row*col];}
double& operator()(int x,int y) {return elem[col*(x-1)+y-1]; }
double operator()(int x,int y) const {return elem[col*(x-1)+y-1]; }
~Matrix() {delete[] elem;}
private:
double *elem;
int row,col;
};
void main()
{
Matrix m(5,8);
for(int i=0;i<5;i++)
m(i,1)=i+5;
for(i=0;i<5;i++)
cout<<m(i,1)<<”,”;
cout<<endl;
}
第九章 习题
一、 选择填空
1. 进行文件操作时需要包含（ ）文件。
VVV. iostream.h； B. fstream.h; C. stdio.h; D.stdlib.h。
2. 使用操作符对数据进行格式输出时，应包含（ ）文件。
WWW. iostream.h； B. fstream.h; C. iomanip.h; D.stdlib.h。
3. 已知：int a,*pa=&a;；输出指针pa十进制的地址值的方法是（ ）。
XXX. cout<<pa； B. cout<<*pa; C. cout<<&pa; D. cout<<long(pa)。
4. 下列输出字符’A’的方法中，（ ）是错误的。
YYY. cout<<put(‘A’); B. cout<<’A’; C. cout.put(‘A’) ; D. char A=’A’;cout<<A;
5. 关于getline()函数的下列描述中，（ ）是错的。
ZZZ. 该函数是用来从键盘上读取字符串的；
AAAA. 该函数读取的字符串长度是受限制的;
BBBB. 该函数读取字符串时遇到终止符便停止；
CCCC. 该函数中所使用的终止符只能是换行符。
6. 关于read()函数的下列描述中，（ ）是对的。
DDDD. 该函数只能从键盘输入中获取字符串;
EEEE. 该函数所获取的字符多少是不受限制的;
FFFF. 该函数只能用于文本文件的操作中;
GGGG. 该函数只能按规定读取所指定的字符数。
7. 在ios中提供控制格式的标志位中，（ ）是转换为十六进制形式的标志位。
HHHH. hex； B. oct; C. dec; D. left。
8. 控制格式输出输入的操作符中，（ ）是设置域宽的。
IIII. ws； B. oct; C. setfill(); D.setw()。
9. 磁盘文件操作中，打开磁盘文件的访问方式常量中，（ ）是以追加方式打开文件的。
JJJJ. in； B. out; C. app; D. ate。
10. 下列函数中，（ ）是对文件进行写操作。
KKKK. get()； B. read(); C. seekg(); D. put()
二、 判断下列描述的正确性，对者划√，错者划×。
１． 使用提取符(<<)可以输出各种类型的变量的值，也可以输出指针值。
２． 预定义的插入符从键盘上接收数据是不带缓冲区的。
３． 预定义的提取符和插入符是可以重载的。
４． 记录流的当前格式化状态的标志字中每一个用于记录一种格式，这种格式是不能被设置或清除的。
５． 设置和清除格式标志字的成员函数需要通过对象来引用它们，输出显示格式的对象通常是cout。
６． 操作符本身是一个对象，它可以直接被提取符或插入符操作。
７． get()函数不能从流中提取终止字符，终止字符仍留在流中。getline()函数从流中提取终止字符，但终止字被丢弃。
８． ios类的成员函数clear()是用来清除整个屏幕的。
９． 使用打开文件函数open()之前，需要定义一个流类对象，使用open()函数来操作该对象。
１０． 使用关闭文件函数close()关闭一个文件时，但流对象仍存在。
１１． 以app方式打开文件时，当前的读指针和写指针都定位于文件尾。
１２． 打开ASCII码流文件和二进制流文件时，打开方式是相同的。
１３． read()和write()函数可以读写文本文件，也可以读写二进制文件。
１４． 流的状态包含流的内容、长度和下一次提取或插入操作的当前位置。
１５． seekg()函数和seekp()函数分别用来定位读指针和写指针的。如果使用seek()函数可以同时定义读写指针。
三、 分析下列程序的输出结果。
1、
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>
void main()
{
fstream outfile,infile;
outfile.open(“text.dat”,ios::out);
if (!outfile)
{
cout<<”text.dat can’t open.\n”;
abort();
}
outfile<<”123456789\n”;
outfile<<”aaabbbbbbccc\n”<<”dddddfffeeeeggggghhh\n”;
outfile<<”ok!\n”;
outfile.close();
infile.open(“text.dat”,ios::in);
if(!infile)
{
cout<<”file can’t open.\n”;
abort();
}
char textline[80];
while(!infile.eof())
{
infile.getline(textline,sizeof(textline));
cout<<textline<<endl;
}
}
2、
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>
void main()
{
fstream file1;
file1.open(“text1.dat”,ios::out|ios::in);
if (!file1)
{
cout<<”text1.dat can’t open.\n”;
abort();
}
char textline[]=”123456789abcdefghijkl.\n\0”;
for(int i=0;i<sizeof(textline);i++)
file1.put(textline[i]);
file1.seekg(0);
char ch;
while(file1.get(ch)) cout<<ch;
file1.close();
}
3、
#include <strstrea.h>
void main()
{
ostrstream ss;
ss<<”Hi,good morning!”;
char *buf=ss.str();
cout<<buf<<endl;
delete[] buf;
}
4、
#include <iostream.h>
#include <strstrea.h>
char a[]=”1000”;
void main()
{
int dval,oval,hval;
istrstream iss(a,sizeof(a));
iss>>dec>>dval;
iss.seekg(ios::beg);
iss>>oct>>oval;
iss.seekg(ios::beg);
iss>>hex>>hval;
cout<<”decVal: “<<dval<<endl;
cout<<”octVal: “<<oval<<endl;
cout<<”hexVal:”<<hval<<endl;
}
第一章 答案
一、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| C | B | D | A | D | A | D | D | A | C |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| √ | √ | × | × | √ | × | × | √ | √ | √ | × | × |
1． BeiJjing ShangHai
TianJing
2． Input a,b:8 5
A=8,b=5
A-b=3
3． D=5,c=m
五、 编译下列程序，改正所出现的各种错误信息，并分析输出结果：
1．#include<iostream.h>
void main()
{
cout<<”This is a string!”;
}
输出结果：This is a string!
2．
#include<iostream.h>
void main( )
{
int x;
cin>>x;
int p=x*x;
cout<<”p=”<<p<<”\n”;
}
输出结果：3
p=9
3、
#include <iostream.h>
void main ( )
{int i,j;
i=5;
j=3;
int k=i+j;
cout<<”i+j=”<<k<<”\n”;
}
输出结果：I+j=8
第二章 答案
二、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| A | D | C | A | C | 无 | A | C | C | A |
| 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
| D | D | D | A | A | A | D | B | A | C |
| 21 | 22 | 23 | 24 | ||||||
| D | D | A | D |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| × | √ | × | √ | √ | × | √ | √ | √ | √ |
| 11 | 12 | 13 | 14 | 15 | 16 | ||||
| √ | × | × | × | × | × |
（下列各表达式是相互独立的，不考虑前面对后面的影响。）
1.
| A | B | C | D | E | F |
| 47 | 38 | 9 | 4294967238 | 104 | 2 |
| A | B | C | D | E | F |
| 6 | 50 | 1 | -16 | 1 | 20 |
| A | B | C | D | E | F |
| 0,5,3 | 1,5,3 | 3,1,3 | 15,10,4 | 8,8,3 | 1,5,3 |
| A | B | C | D |
| 0 | 25 | 0 | 0 |
| A | B | C | D | E | F |
| 20 | 22 | -3 | 0 | 1 | 1 |
3 、#include <iostream.h>
void main()
{
float c,f;
cout<<”华氏温度：”; cin>>f;
c=(f-32)*5/9;
cout<<” 摄氏温度：”<<c<<endl;
}
4、#include <iostream.h>
const float r=1.60934;
void main()
{
float m,I;
cout<<” 公里数：”;
cin>>m;
I=r*m;
cout<<”英里数：”<<I<<endl;
}
5 、#include <iostream.h>
void main()
{
int n,m;
cout<<”输入一个整数：”;
cin>>n;
m=n|15;
cout<<”结果为：”<<m<<endl;
}
第三章 答案
三、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| B | D | A | A | A | B | A | D | D | A |
| 11 | 12 | 13 | 14 | 15 | |||||
| C | D | C | A | C |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| √ | × | × | × | √ | × | × | × | × | × |
| 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
| × | × | √ | × | × | × | √ | √ | √ | √ |
1．13.5
2．20
3．13
4． 1
4
7
5． 3
5
Ok!
6. 6
7
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. 3
1
-1
9. 1,2
10. SWITCH⊙WAMP
四、
1、#include <iostream.h>
void main()
{
int I=1,s=0;
while(I<=99)
{
s=s+I;
I+=2;
}
cout<<”s=”<<s<<endl;
}
2、#include <iostream.h>
void main()
{
int I=13,m;
while (I<100)
{
if(I%13= =0)
m=I;
I+=13;
}
cout<<”m=”<<m<<endl;
}
3、#include <iostream.h>
void main()
{
int r,I,j;
cout<<”I=”; cin>>I;
cout<<”j=”; cin>>j;
if (I<j) r=I,I=j,j=r;
r=I%j;
while(r)
{
I=j;j=r;r=I%j;
}
cout<<”最大公约数：”<<j<<endl;
}
#include <iostream.h>
void main()
{
int x,y,s;
cout<<”输入两个整数：”;
cin>>I>>j;
s=x;
while(1)
{
if(s%y= =0)break;
s+=x;
}
cout<<”最小公倍数：”<<s<<endl;
}
4、#include <iostream.h>
void main()
{
int I,m,n,k;
float s=0;
m=1;n=2;
for(I=1;I<=15;I++)
{
s=s+1.0*n/m;
k=m;n=n;n=k+n;
}
cout<<”s=”<<s<<endl;
}
5、#include <iostream.h>
void main()
{
int I,n=1;
long int s=0;
for(I=1;I<=10;I++)
{
n=n*I;
s=s+n;
}
cout<<”s=”<<s<<endl;
}
6、#include <iostream.h>
#include <math.h>
void main()
{
int I,n=0;
for(I=1;I<=(int)(sqrt(1000));I++)
{
n++;
if(n%8= =) cout<<I*I<<endl;
else cout<<I*I<<”,”;
}
cout<<endl;
}
8、#include <iostream.h>
void main()
{
double x,y;
cout<<"Please input x:";
cin>>x;
if(x<1) y=x;
else if(x>=10) y=x-5;
else y=x+5;
cout<<"x="<<x<<","<<"y="<<y<<endl;
}
9、#include <iostream.h>
#include <math.h>
void main()
{
double a,b,c,d,x1,x2;
cout<<"Please input a,b,c:";
cin>>a>>b>>c;
d=b*b-4*a*c;
if(a==0)
cout<<"不是二次方程！\n";
else if(d==0)
{ x1=x2=-b/2*a;
cout<<"有两个相等实根x1=x2="<<x1<<endl;}
else if(d>0)
{ x1=(-b+sqrt(d))/2*a;
x2=(-b-sqrt(d))/2*a;
cout<<"有两个不等实根x1="<<x1<<",x2="<<x2<<endl;}
else
{ cout<<"有两个共轭复根:";
cout<<"x1="<<(-b/2*a)<<"+"<<(sqrt(-d)/2*a)<<"i"<<endl;
cout<<"x2="<<(-b/2*a)<<"-"<<(sqrt(-d)/2*a)<<"i"<<endl;
}
}
10、#include <iostream.h>
void main()
{
for(int i=1;i<=5;i++)
{
for(int j=1;j<=5-i;j++)
cout<<" "; //先打印空格
for(int k=1;k<=2*i-1;k++)
cout<<"*"; //再打印＊
cout<<endl; //换行
} //打印上半部分
for(i=1;i<=4;i++)
{
for(int j=1;j<=i;j++)
cout<<" "; //先打印空格
for(int k=1;k<=9-2*i;k++)
cout<<"*"; //再打印＊
cout<<endl; //换行
} //打印下半部分
}
第四章 答案
一、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| A | D | B | D | D | C | C | D | C | A |
| 11 | 12 | 13 | 14 | 15 | |||||
| B | C | A | D | C |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| √ | √ | × | √ | × | √ | × | × | √ | √ |
| 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
| × | √ | √ | √ | × | √ | × | × | √ | √ |
1． 5
8
11
14
2． 25
3． 10+2+1=13
20+2+2=24
30+2+3=35
40+2+4=46
4． 6,11
5． 5!+4!+3!+2!+1!=153
6. 6,6,6
11. sum1=13
sum2=18
sum3=23
12. 720
13. a=5,b=8
a=8,b=5
14. 10
15. u
1998
abcd
16. ff(double):88.18
ff(int):97
四、
8、#include <iostream.h>
# include <string.h>
#include<malloc.h>
char *func(int,int);
void main()
{cout<<endl;
cout<<func(3,251)<<endl;
}
char *func(int n,int s)
{
char *p=(char *)malloc(1);
if(n= =1)
{
char str[2];
str[0]=’0’+s;str[1]=’\0’;
return str;
}
else
{
int n1=s%10;
int s1=s/10;
*p=’0’+n1;
return strcat(func(n-1,s1),p,1);
}
}
9、#include <iostream.h>
#include <math.h>
double func(int,int,int,int);
double func(double,double,double,double);
void main()
{
cout<<func(2,2,5,5)<<”,”;
cout<<func(2.0,2.0,5.0,5.0)<<endl;
}
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));
}
11、#include <iostream.h>
int func(int n=2);
void main()
{
cout<<func(1)<<”,”;
cout<<func()<<”,”;
cout<<func(3)<<endl;
}
int func(int n)
{
int s=0;
for(int I=1;I<=10;I++)
s=n*(1+s);
return s;
}
第五章 答案
一、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| A | C | D | C | D | A | C | A | D | A |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| √ | √ | × | × | √ | √ | × | √ | × | √ |
4． Default constructor called.
Constructor called.
A=0,b=0
A=4,b=8
5． A=7,b=9
6． 104
7． 1035,789,504
8． 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 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| C | A | B | C | C | D | B | C | A | D | C | B |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| √ | √ | √ | √ | × | √ | √ | √ | × | √ | × | × |
1． Starting 1 . . .
Default constructor called.
Default constructor called.
Default constructor called.
Ending1. . .
Starting2 . . .
Constructor: a=1,b=2
Constructor: a=3,b=4
Constructor: a=5,b=6
Ending2 . . .
Destructor called. A=5,b=6
Destructor called. A=3,b=4
Destructor called. A=1,b=2
Destructor called. A=5,b=6
Destructor called. A=3,b=4
Destructor called. A=1,b=2
2． Default constructor called.
Default constructor called.
Default constructor called.
Default constructor called.
Destructor called.
Constructor1 called.
Destructor called.
Constructor2 called.
Destructor called.
X=0,y=0
X=5,y=0
X=2,y=3
Destructor called.
Destructor called.
Destructor called.
3． Constructor called. 0
Constructor called. 5
Destructor called. 5
5
Destructor called. 5
4． Constructor called. 5
5
Destructor called. 5
5． Default constructor called.
Constructor: real=6.8,imag=0
Constructor: real=5.6,imag=7.9
0+0i
6.8+0i
5.6+7.9i
Constructor: real=1.2,imag=3.4
Constructor: real=5,imag=0
Default constructor called.
1.2+3.4i
5+0i
0+0i
第七章 答案
一、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| D | A | B | C | A | C | B | D |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| √ | × | × | × | √ | × | √ | √ | √ | × |
| 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | ||
| √ | √ | × | √ | √ | × | √ | √ |
四、 分析下列程序的输出结果。
1． (1,2)
5,6
(6,9)
2. (1,2)
(6,9)
5,6
(6,9)
3． {13，22，30，40}
4． D2::display()
pri1=4,pri2=5
pri4=6
pri12=7
D2::display()
pri1=12,pri2=9
pri4=7
pri12=8
5. D2::display()
pri1=1,pri2=4
pri4=6
pri12=7
D2::display()
pri1=9,pri2=8
pri4=7
pri12=8
第八章 答案
一、 选择填空
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| D | C | A | C | D | C | D | C | A | D |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| √ | √ | √ | × | √ | √ | √ | √ | × | √ |
1． B::show() called. 158
D::show() called. 208
2. D::virfun() called.
3． The A version A
The A version 1
The A version A
The A version 3
4． The A version A
The D1 info: 4 version 1
The D2 info: 100 version A
The D3 info: -25 version 3
5. 5,6,7,8,9,
第九章 答案
一、 选择填空| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| B | C | D | A | D | D | A | D | C | D |
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| √ | × | √ | × | √ | √ | √ | × | √ | √ |
| 11 | 12 | 13 | 14 | 15 | |||||
| √ | × | √ | × | × |
a) 123456789
aaabbbbbbccc
dddddfffeeeeggggghhh
ok!
2. 123456789abcdefghijkl.
b) decVal: 1000
octVal: 512
hexVal:4096
栏目列表
最新更新
C#基于接口设计三层架构Unity篇
C#线程 入门
C#读取静态类常量属性和值
C# 插件式编程
C# 委托与事件有啥区别？
C#队列学习笔记：队列(Queue)和堆栈(Stack
linq 多表分组左连接查询查询统计
C#队列学习笔记：MSMQ入门一
C# 基础知识系列- 1 数据类型
二、C#入门—基础语法
C# 在Word中添加Latex 数学公式和符号
inncheck命令 – 检查语法
基于UDP的服务器端和客户端
再谈UDP和TCP
在socket编程中使用域名
网络数据传输时的大小端问题
socket编程实现文件传输功能
如何优雅地断开TCP连接？
图解TCP四次握手断开连接
详细分析TCP数据的传输过程
SqlServer 利用游标批量更新数据
BOS只读状态修改
SQL Server等待事件—PAGEIOLATCH_EX
数据库多行转换为单一列
获取数据表最后最后访问，修改，更新，
计算经历的时间
SQL查询结果自定义排序
修改数据库默认位置
日期简单加或减
从日期获取年，月或日
