《c++语言程序设计教程》习题及解答

更新时间：2024-01-17 02:48:01 阅读量：教育文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

c语言程序设计教程答案推荐度：
相关推荐

《c++语言程序设计教程》习题及解答

第1章 C++语言概述

练习题1

1.1 判断题

×1．C++语言和C语言都是面向对象的程序设计语言。 √2．面向对象方法具有封装性、继承性和多态性。

√3．C语言是C++语言的一个子集。C++语言继承了C语言。 ×4．C++语言程序与C语言程序一样都是函数串。 ×5．C++语言支持封装性和继承性，不支持多态性。 √6．C++语言比C语言对数据类型要求更加严格了。

√7．C++语言对C语言进行了一次改进，使得编程更加方便了。

×8．C++源程序在编译时可能出现错误信息，而在连接时不会出现错误信息。 √9．编译C++源程序时，出现了警告错（Warning）也可以生成可执行文件。 √10．C++语言程序的实现也要经过编辑、编译连接和运行3个步骤。 1.2 单选题

1．下列关于面向对象概念的描述中，错误的是（ C ）。 A．面向对象方法比面向过程方法更加先进

B．面向对象方法中使用了一些面向过程方法中没有的概念 C．面向对象方法替代了结构化程序设计方法

D．面向对象程序设计方法要使用面向对象的程序设计语言

2．下列各种高级语言中，不是面向对象的程序设计语言是（ D ）。 A．C++ B．Java C．VB D．C 3．下列关于类的描述中，错误的是（ A ）。 A．类就是C语言中的结构类型 B．类是创建对象的模板 C．类是抽象数据类型的实现

D．类是具有共同行为的若干对象的统一描述体 4．下列关于对象的描述中，错误的是（ C ）。 A．对象是类的一个实例

B．对象是属性和行为的封装体 C．对象就是C语言中的结构变量

D．对象是现实世界中客观存在的某种实体

5．下列关于C++程序中使用提取符和插入符的输入/输出语句的描述中，错误的是（ C ）。 A．提取符是对右移运算符（>>）重载得到的 B．插入符是对左移运算符（<<）重载得到的

C．提取符和插入符都是双目运算符，它们要求有两个操作数 D．提取符和插入符在输入/输出语句中不可以连用 1.3 填空题

1．C++语言具有面向对象方法中要求的三大特性：封装性、继承性和多态性。 2．C++程序中，有且仅有一个主函数。

第 1 页共 77 页

3．C++程序是由类和函数组成的。 4．C++源程序的扩展名是 cpp 。

5．使用插入符进行标准输出文件输出时，使用的输出流对象名是 cout 。 1.4 上机调试下列程序，并分析输出结果 1．

#include void main() {

int i,j;

cout<<\ cin>>i>>j;

cout<<\

cout<<\ }

假定，输入数据如下：

Enter x y:5?9? 答： i=5,j=9

i+j=14,i *j=45

2．

#include int max(int,int); void main() {

int a,b,c; a=5; b=8;

c=max(a,b);

cout<<\ }

int max(int x,int y) {

return x>y?x:y; }

答： max(5,8)=8

3．文件e1.4.3.cpp内容如下：

#include void f1(),f2(); void main() {

cout<<\在北京.\\n\ f1(); f2();

cout<<\再见.\\n\ }

文件1.4.3-1.cpp内容如下：

#include void f1() {

cout<<\在上海.\\n\ }

文件1.4.3-2.cpp内容如下：

#include void f2() {

cout<<\在广州.\\n\ }

第 2 页共 77 页

答：在北京。在上海。在广卅。再见。

1.5 编译下列程序，修改所出现的错误，获得正确结果 1．

main() {

cout<<\ }

答：修改后如下：

#include void main() {

cout<<\ }

2．

#include void MAIN() {

cin>>a; int b=a+a;

cout<<\ }

答：修改后如下：

#include void main() {

int a;

cin>>a; int b=a+a;

cout<<\”<

3．

#include void main() {

int i,j; i=5;

int k=i+j;

COUT<<\ }

答：

#include void main() {

int i,j; j=10; i=5;

int k=i+j;

cout<<\ }

1.6 通过对1.5题中3个程序的修改，回答下列问题

1．从1.5题中第1题程序的修改中，总结出编程应该注意哪些问题。

第 3 页共 77 页

答：C++程序要包含iostraem.h，main()函数前应加类型说明符void。

2． C++程序中所出现的变量是否必须先说明后使用？在函数体内说明变量时是否都要放在

函数体的开头？

答：C++程序中所出现的变量必须先说明后使用。在函数体内说明变量时不一定要放在函数体的开头。

3．使用cout和插入符（<<）输出字符串常量时应注意什么？

答：可输出一个字符串常量，也可输出多个字符串常量。每输出一个字符串常量要使用一次插入符(<<)。

4．程序中定义过的变量，但没有赋值，也没有默认值，这时能否使用？答：不能使用。因为它的值不确定。

5．一个程序编译通过并已生成执行文件，运行后并获得输出结果，这一结果是否一定正确？答：不一定正确。可能还有算法错。

第2章变量和表达式及数组

练习题2

2.1 判断题

√ 1．C++语言的合法字符集与C语言的完全相同。 × 2．标识符规定大小写字母没有区别。

× 3．C++程序中，不得使用没有定义或说明的变量。 √ 4．变量的存储类指出了变量的作用域和寿命。

√ 5．变量的数据类型指出了变量在内存中存放的字节数。 × 6．定义变量时，变量的存储类说明符不得省略。

× 7．自动类变量与内部静态类变量的作用域和寿命都是相同的。 × 8．自动类变量可以定义在函数体外，这时应加说明符auto。 × 9．外部类变量与外部静态类变量的作用域是相同的。

× 10．变量被定义后是否有默认值与存储类无关，与数据类型有关。

√ 11．C++程序中，通常使用const来定义符号常量，定义时必须指出类型。 × 12．变量被定义或说明后，它一定具有有意义的值。

× 13．字符串常量与字符常量的区别仅表现在定义形式上的不同，一个用双撇号，另一个用单撇号。

× 14．所有变量的可见性和存在性都是一致的。

√ 15．变量在它的作用域内一定是可见的，又是存在的。

√ 16．C++语言中除了包含C语言的所有运算符外，还规定自身的若干个运算符。 √ 17．增1和减1运算符以及赋值运算符都具有副作用。

× 18．增1和减1运算符不仅可以作用在变量上，也可以作用在表达式上。

× 19．关系运算符可以用来比较两个字符的大小，也可以比较两个字符串的大小。 × 20．移位运算符在移位操作中，无论左移还是右移，对移出的空位一律补0。 × 21．变量的类型高低是指它被存放在内存的地址值大小。

× 22．使用sizeof运算符可以求得某种类型和某个变量在内存中占的字节数，不能求得某个表达式的类型在内存中所占的字节数。

√ 23．在C++语言中，非保值转换应用强制类型转换。

第 4 页共 77 页

√ 24．表达式中各操作数计算顺序取决于运算符的优先级和结合性。

√ 25．在C++程序中，变量值是可以改变的，变量的地址值是不能改变的。 √ 26．数组中所有元素的类型都是相同的。 × 27．定义数组时必须对数组进行初始化。

√ 28．数组某维的大小可以用常量表达式，不可用变量名。

× 29．定义一个数组没有对它进行初始化，则该数组的元素值都是无意义的。

√ 30．用来给数组进行初始化的初始值表内的数据项的个数必须小于等于数组元素个数。 × 31．在定义一个数组时，对其部分元素进行了初始化，没有初始化的元素的值都是无意义的。 √ 32．数组被初始化时是判越界的。 × 33．字符数组就是字符串。

√ 34．使用printf( )函数输出显示字符串时使用格式符%s，输出显示字符时使用%c或%d。 × 35．给数组元素赋值时只可用常量表达式。 2.2 单选题

1．下列变量名中，非法的是（ C ）。 A．A25 B．My_car C．My-str D．abc 2．下列常量中，十六进制int型常量是（ A ）。 A．0x5f B．x2a C．046 D．7a 3．下列常量中，不是字符常量的是（ B ）。 A．'\\n' B．\C．'x' D．'\\7'

4．在函数体内定义了下述变量a，a的存储类为（ D ）。 int a；

A．寄存器类 B．外部类 C．静态类 D．自动类 5．下列关于变量存储类的描述中，错误的是（ C ）。 A．任何变量定义后都具有一个确定的存储类 B．变量的存储类确定了变量的作用域和寿命 C．定义变量时没有存储类说明符者一律为自动类

D．内部静态类变量和外部静态类变量的存储类说明符都是static 6．下列关于变量数据类型的描述中，错误的是（ A ）。 A．定义变量时int型数据类型可以省略

B．变量的数据类型可以决定该变量占内存的字节数 C．变量的数据类型是可以被强制的 D．变量的数据类型是有高低之分的 7．长双精度浮点型常量的后缀是（ C ）。 A．U B．F C．L D．无

8．下列运算符中，不能用于浮点数操作的是（ D ）。 A．++ B．+ C．*= D．&（双目） 9．下列运算符中，优先级最高的是（ A ）。 A．*（双目） B．|| C．>> D．%= 10．下列运算符中，优先级最低的是（ B ）。

A．== B．？：

第 5 页共 77 页

cout<

答： 543345

13．

#include void main() {

int b[]={5,?3,4,1,?8,9,0,10}; int i=0,j; for(j=i;i<8;i++) if(b[i]>b[j]) j=i;

cout<

14．

#include void main() {

int a[][3]={1,2,3,4,5,6,7,8,9}; int s1(0),s2(0); for(int i=0;i<3;i++) for(int j=0;j<3;j++) { if(i!=j) s1+=a[i][j]; if(i+j==1) s2+=a[i][j]; }

cout<<\ }

答： s1=30,s2=6

15．

#include void main() {

char s[]=\ for(int i=0;i<3;i++) {

for(int j=0;j

第 11 页共 77 页

cout<

for(i=2;i>0;i??) {

for(int j=0;j

2.5 编程题

1．已知：int a=3，b=5；编程计算下列两个代数式的值，并比较它们是否相等。 (a+b)2 和

a2+2ab+b2 答：编程如下：

#include

void main() { int a=3,b=5; int d1=(a+b)*(a+b); int d2=a*a+2*a*b+b*b; cout<<\

}

从结果中可以看出d1和d2值是相等的。

2．已知：int x=5；编程求下列代数式的值。

f(x)=3x3+2x2+5x+2

答：编程如下：

#include

void main() { int x=5; int f=3*x*x*x+2*x*x+5*x+2; cout<

}

3．从键盘上输入两个double型数，编程输出其中最小者。答：编程如下：

#include

第 12 页共 77 页

void main() { double a,b; cout<<\请输入两个double型数：\ cin>>a>>b; cout<<\输入的两个数中较小的是\ if(a<=b) cout<

}

4．华氏温度转换成摄氏温度的计算公式如下：

C=(F?32)*5/9

其中，C表示摄氏温度，F表示华氏温度。从键盘上输入一摄氏温度，编程输出对应的华氏温度。

答：编程如下：

#include

void main() { double c,f; cout<<\请输入一个摄氏温度值：\ cin>>c; f=9.0/5.0*c+32.0; cout<<\摄氏温度为\华氏温度为\

}

5．从键盘上输入5个浮点数，输出它们的和以及平均值。答：编程如下：

#include void main() { double a,b,c,d,e; cout<<\请输入5个double型数：\ cin>>a>>b>>c>>d>>e; double f=a+b+c+d+e; cout<<\输入的5个数的和是\平均值是\}

6．将字符串\，逆向输出为\。答：编程如下：

#include void main() { char a[]=\ cout<

2.6 简单回答下述问题

1． C++语言中注释符的格式如何？注释信息的功能是什么？答：注释符格式有2种：

格式一： /* <注释信息> */

第 13 页共 77 页

格式二： // <注释信息>

注释信息是用来对程序进行提示和说明的。

2．使用const定义符号常量比使用#define定义符号常量有何优点？

答：使用const定义符号常量时要指出数据类型，而用#define定义符号常量时不需提出类

型，因此前者比后者对类型要求更严格，这样会更安全。 3．内部静态存储类变量有何特点？

答：内部静态存储类变贯的特点是作用域较小，但寿命很长，这种变量作用域与寿命不一

致，因此会出现不可见但又存在的情况。

4．在使用插入符（<<）输出若干个表达式值时，有的表达式中使用的运算符的优先级低

于插入符优先级时应该如何处理？

答：这时需将表达式用括号括起来，己改变其优先级。

5．由多种不同运算符组成的表达式，其类型如何确定？例如，

int a, b, c; …

a=b>c？b:c;

这是一个条件表达式还是赋值表达式？

答：表达式类型由优先级低的运算符组成的表达式来确定。

这是一个赋值表达式，因为赋值运算符优先级低于三目运算符。 6. 数组元素个数是由什么决定的？

答：数组元素个数是由维数及其大小来决定的。一维数组元素个数是该维的大小，二维数

组的元素个数是两维大小之积等。 7. 数组元素下标有何规定？

答：C++语言中，数组元素下标从0开始。 8. 初始值表中数据项的类型和个数有何规定？

答：初始值表中数据项的类型应与该变是类型相同，个数应小于或等于被初始化的数组元

素的个数。

9. 字符数组和字符串有什么关系？

答：字符数组中可存放字符串，而字符数组不都是存放字符串的。如果字符数组中有字符

串结束符，则说明该字符数存放的是字符串。

10．一个数组中的元素类型是否一定相同？何时定义的数组元素具有默认值？答：数组中元素类型必须相同。存储类为外部和静态的数组其元素具有默认值。

第3章语句和预处理

练习题3

3.1 判断题

√ 1．表达式和表达式语句是不同的。 × 2．空语句是一种没有用处的语句。 × 3．复合语句就是分程序。

× 4．条件语句中if子句和else子句都是必须有并且仅有一个。 √ 5．条件语句中else if子句可以没有，也可以有多个。 √ 6．开关语句可实现多路分支。

× 7．开关语句的<语句序列>中必须有一个break语句，否则该开关语句便无法退出。 × 8．任何循环语句都是至少执行一次循环体。

× 9．退出for循环语句必须是for后面括号内的中间一个表达式的值为0。

第 14 页共 77 页

√ 10．do-while循环语句至少要执行一次循环体。

× 11．循环语句的循环体中可以出现if语句，if语句的if体内不能出现循环语句。 × 12．goto语句中所使用的语句标号是一种标识符，它的作用域是文件级的。

√ 13．break语句和continue语句都可以出现在循环体中，但是它们的作用是不同的。 × 14．文件包含命令所能包含的文件类型是不受限制的。 3.2 单选题

1．下列关于语句的描述中，错误的是（ A ）。 A．C++程序中的函数是由若干条语句组成的 B．每条语句都要实现某种操作 C．条件语句是用来实现分支操作的

D．循环语句是用来在一定条件下重复执行某段程序的 2．下列关于条件语句的描述中，错误的是（ C ）。 A．if语句中最多只能有一个else子句 B．if语句的if体内可以出现开关语句

C．if语句中else if子句和else子句的顺序是没有限制的 D．if语句中else子句是与它最近的if子句配对的 3．下列关于开关语句的描述中，错误的是（ B ）。 A．开关语句中，case子句的个数是不受限制的

B．开关语句中，case子句的语句序列中一定要有break语句 C．开关语句中，default子句可以省略

D．开关语句中，右花括号具有退出开关语句的功能 4．下列关于循环语句的描述中，错误的是（ A ）。

A．while循环语句中<条件>给定的表达式不能为非0的常量，否则便是死循环 B．for循环语句的循环体内可以出现while循环语句、do-while循环语句和for循环语句 C．循环语句的循环体可以是空语句

D．循环语句的循环体内可以出现break语句，也可以出现continue语句 5．已知：int i(3)；下列do-while循环语句的循环次数是（ D ）。

do{

cout<

A．0 B．3 C．1 D．无限 6．下列for循环语句的循环次数是（ B ）。

for(int i(0), j(5); i=3; i++, j--);

A．3 B．无限 C．5 D．0 7．下列while循环语句的循环次数是（ A ）。

while(int i(0)) i--;

A．0 B．1 C．2 D．无限 8．下列程序段执行后，j值是（ B ）。

for(int i(0), j(0); i＜10; i++) if(i) j++;

A．0 B．9 C．10 D．无限

9．已知：typedef char CH；下列描述中，正确的是（ A ）。 A．使用CH定义的变量是char型变量 B．使用CH定义的是一个字符常量

第 15 页共 77 页

C．使用CH定义的变量其类型不确定 D．使用CH定义的是一个字符串

10．下列关于预处理命令的描述中，错误的是（ D ）。

A．预处理命令最左边的标识符是# B．预处理命令是在编译前处理的 C．宏定义命令可以定义符号常量 D．文件包含命令只能包含.h文件 3.3 填空题

1．表达式语句是一个表达式后边加上分号(;) 组成的。空语句是只有一个分号的语句。

2．复合语句是由两条条或两条条以上的语句加上花括号({}) 组成的。 3．分程序是一种带有说明语句的复合语句。

4．循环语句的共同特点是都应具有循环体和退出循环的条件。 5．下列程序是求100之内的能被7整除的自然数之和。

#inelude void main( ) {

int sum; _sum=0_; for(int i(1);__i<=100_; i++) if(_i%7==0__) sum+=i; cout<

3.4 上机调试下列程序，并分析其输出结果 1．

#include void main() {

int a(8),b(5); if(!a) } 答： 9,5

b--; if(a)

a++; a--; else

else if(b)

else

b++;

cout<

2．

#include

第 16 页共 77 页

void main() {

int a(10); while(--a) { } 答： 9 8 7

if(a==5) break;

if(a%2==0&&a%3==0) continue; cout<

}

3．

#include void main() {

int b(10); do {

++b;

cout<<++b<

}while(b<15); cout<<\ } 答： 12 14 16 ok!

4．

#include void main() {

int w(5); do {

switch(w%2) {

case 1: w--; break; case 0: w++; break; } w--;

第 17 页共 77 页

} 答： 3 1 -1

cout<

}while(w>0);

5．

#include void main() {

int a(4),b(5),i(0),j(0); switch(a) {

case 4: switch(b)

{

case 4: i++; break; case 5: j++; break; default: i++;j++;

} break;

case 5: i++; j++; default: i++;j++;

}

cout<

6．

#include void main() {

int b(10);

for(int i=9;i>=0;i--) {

switch(i)

{ }

case 1: case 4: case 7: b++;break; case 2: case 5: case 8: break; case 3: case 6: case 9: b+=2;

}

cout<

第 18 页共 77 页

} 答： 19

7．

#include void main() {

int a(6);

for(int i(1);i<=a;i++) { }

答： A AAA AAAAA AAAAAAA AAAAAAAAA AAAAAAAAAAA

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

cout<<' '; cout<<'A'; for(j=1;j<=2*i-1;j++) cout<

}

8．

#include

#define MAX(x,y) (x)>(y)?(x):(y) void main() {

typedef int IN; IN a(3),b(4),c; c=MAX(a,b)*2; cout<

3.5 编程题

1．求100之内的自然数中奇数之和。答：编程如下：

#include void main() {

int s=0;

for(int i=1;i<100;i+=2)

第 19 页共 77 页

s+=i;

cout<

2．求两个整数的最大公约数和最小公倍数。答：编程如下：

假定两个整数分别为15和25，求它们的最大公约数和最小公倍数。 #include void main() {

int m,n,t; m=15; n=25; if(m

cout<<\最大公约数为\ cout<<\最小公倍数为\ }

3．求下列分数序列前15项之和。 2/1，3/2，5/3，8/5，13/8，… 答：编程如下：

#include void main() {

int a; double i=2,j=1,sum=0,t; for(a=1;a<15;a++) { sum+=i/j; t=i; i+=j; j=t; }

cout<<\ }

第 20 页共 77 页

int a=90; p=&a;

cout<<\ int b=50; rp=&b;

cout<<\ }

答： a=90,*rp=90 b=50,*rp=50

4.5 编程题（使用指针）

1．已知4个字符串，编程输出它们中最小的一个。答：编程如下：

#include #include

void swap(char p1[],char p2[]); void main() { char s1[10]=\ if(strcmp(s1,s2)) swap(s1,s2); if(strcmp(s3,s4)) swap(s3,s4); if(strcmp(s1,s3)) swap(s1,s3); cout<

void swap(char p1[],char p2[]) { char p[10]; strcpy(p,p1); strcpy(p1,p2); strcpy(p2,p); }

2．将一个长度为n的字符串，编程实现其逆序输出。答：编程如下：

#include #include void inverse(char []); void main() { char s[50]; cout<<\输入一个字符串：\ cin>>s; inverse(s); cout<<\反序后的字符串是 \}

void inverse(char p[]) { int n=strlen(p); int limit=n/2; for(int i=0;i

第 26 页共 77 页

{ }

char t=p[i]; p[i]=p[n-i-1]; p[n-i-1]=t;

}

3．已知一个二维int型数组，编程求出它的最小的元素值。答：编程如下：

#include void main() { int n[3][2]={{3,8},{-5,9},{2,4}}; int lim=n[0][0]; for(int i=0;i<3;i++) for(int j=0;j<2;j++) if(n[i][j]

4．已知字符型指针数组中存放若干个字符串，编程从键盘上修改其中某个字符串。答：编程如下：

#include #include

char *str[5]={\char *modify(int,char []); void main() { int n; char s[10]; cout<<\修改第几个字符串：\ cin>>n; cout<<\该字符串修改为：\ cin>>s; cout<<\修改后的字符串是 \ cout<<\修改后字符指针数组中的字符串如下：\\n\ for(int i=0;i<5;i++) cout<

char *modify(int n,char s[]) { return *(str+n-1)=s; }

5．有n个小孩排成一圈。从第1个小孩开始作1至3报数，凡报数为3的小孩从圈中出

来，求最后出圈的小孩的顺序号是多少？答：编程如下：

#include void main() {

第 27 页共 77 页

}

int n,num[100];

cout<<\输入排号人数：\cin>>n; int *p=num;

for(int i=0;i

int k=0,a=0; while(a

while(*p==0) p++;

cout<<\最后留下的是第 \号\

4.6 简单回答下列问题

1．指针与一般变量有何不同？

答：指针是变量，它不同于一般量。其一是指针存放的是地址值，其二指针的类型是它所指向的变量类型。

2．指针可以作哪些运算？答：指针的运算有4种：

赋值运算

加减一个整型数运算

在一定条件下，两个指针可以比较运算在一定条件下，两个指针可以相减运算

3．指针可以作数组元素，这种数组叫什么数组？答：指针作数组元素的数组称为指针数组。

4．什么是字符指针？字符指针与字符数组有何不同？

答：指符指针是指向字符串的指针。字符指针是变量指针，字符数组名是常量指针。 5．什么是引用？引用有哪些特征？

答：引用不是变量，是变量或对象的别名。引用的值和地址值都是被引用的变量的值和地址值。当被引用的变量值被改变，则引用的值也被改变，反之亦然。

第5章函数

第 28 页共 77 页

练习题5

5.1 判断题

√ 1．函数的调用可以嵌套，函数的定义不能嵌套。

× 2．C++语言中，函数可以用原型说明，也可用简单说明。 × 3．定义函数时，存储类可以缺省，数据类型也可以省略。 × 4．函数可以没有参数，但是不能没有返回值。

× 5．函数定义时必须给出函数体，函数体内至少有一条语句。 √ 6．没有参数的两个函数是不能重载的。

√ 7．函数调用方式有传值调用和引用调用两种，传值调用中又分传值和传址两种。 √ 8．函数的存储类有外部的和静态的两种，它们的作用域分别是程序级的和文件级的。 × 9．没有返回值的函数不能设臵为内联函数。

× 10．函数可以设臵默认的参数值，默认参数值必须设臵在函数定义时的形参上。 5.2 单选题

1．当一个函数没有返回值时，该函数类型应说明为（ A ）。 A．void B．int C．无 D．任意

2．下列关于设臵函数默认的参数值的描述中，错误的是（ C ）。 A．可对函数的部分参数或全部参数设臵默认值

B．在有函数说明时，默认值应设臵在函数说明时，而不是定义时 C．设臵函数默认参数值时，只可用常量不可用含有变量的表达式 D．设臵函数参数默认值应从右向左设臵

3．下列关于被调用函数中return语句的描述中，错误的是（ D ）。 A．一个函数中可以有多条return语句 B．return语句具有返回程序控制权的作用 C．函数通过return语句返回值时仅有一个 D．一个函数中有且仅有一条return语句 4．函数返回值的类型是由（ B ）决定的。 A．调用该函数的调用函数的类型 B．定义该函数时所指定的类型 C．return语句中表达式的类型

D．接收函数返回值的变量或对象的类型

5．下列设臵函数参数默认值的说明语句中，错误的是（ C ）。 A．int fun(int x , int y=10); B．int fun(int x=5, int =10); C．int fun(int x=5, int y); D．int fun(int x , int y=a+b); （其中，a和b是已定义过具有有效值的变量）

6．下列选择重载函数的不同实现的判断条件中，错误的是（ D ）。 A．参数类型不同 B．参数个数不同 C．参数顺序不同 D．函数返回值不同

7．已知：int fun (int ＆a),m=10；下列调用fum()函数的语句中，正确的是（ C ）。 A．fun(＆m); B．fun (m*2); C．fun (m); D．fun (m++);

8．在函数的引用调用中，函数的实参和形参分别应是（ C ）。 A．变量值和变量 B．地址值和指针 C．变量名和引用 D．地址值和引用

9．在函数的传址调用中，函数的实参和形参分别应是（ B ）。 A．变量值和变量 B．地址值和指针

第 29 页共 77 页

C．变量名和引用 D．地址值和引用 10．说明一个内联函数时，应加关键字是（ A ）。

A．inline B．static C．void D．extern 5.3 填空题

1．如果将调用一个函数的过程分为3个步骤，第1步是转去执行被调用函数，第2步是执行被调用函数的语句，第3步是返回操作。

2．函数的存储类分两种，它们分别是外部函数和内部函数，其中内部函数的存储类说明不可省略，该说明符是 static 。

3．使用关键字inline说明的函数称为内联函数，具有相同函数名但具有不同实现的函数称为重载函数。

4．在调用一个函数过程中可以直接或间接地调用该函数，则该函数称为被调用函数。这种调用称为嵌套调用。

5．在引用调用中，函数实参用变量名，形参用引用名。 5.4 分析下列程序的输出结果 1．

#include int fun(int n) {

int p(1),s(0);

for(int i(1);i

p*=i; s+=p; }

return s; }

void main() {

int s=fun(4); cout<

2．

#include void fun(); void main() {

for(int i(0);i<4;i++) fun(); }

void fun() {

int a(0); a++; static int b; b++;

cout<<\ } 答： a=1,b=1 a=1,b=2 a=1,b=3

第 30 页共 77 页

a=1,b=4

3．

#include int fac(int); void main() {

int s(0);

for(int i(1);i<=5;i++) s+=fac(i);

cout<<\ }

int fac(int n) {

static int b=1; b*=n; return b; }

答： 5!+4!+3!+2!+1!=153

4．

#include int fun(char *,char *); void main() {

char *p1,*p2; p1=\ p2=\ int n=fun(p1,p2); cout<

}

int fun(char *s1,char *s2) {

while(*s1&&*s2&&*s1++= =*s2++) ; s1--; s2--;

return *s1-*s2; } 答： 2

5．

#include void fun(int,int,int *); void main() {

int a,b,c; fun(5,6,&a); fun(7,a,&b); fun(a,b,&c);

第 31 页共 77 页

cout<

void fun(int i,int j,int *k) {

j+=i; *k=j-i; }

答： 6,6,6

6．

#include int add(int,int =5); void main() {

int a(8);

cout<<\

cout<<\ }

int add(int i,int j) {

return i+j; }

答： sum1=13 sum2=21 sum3=29

7．

#include void swap(int &,int &); void main() {

int a(8),b(5);

cout<<\ swap(a,b);

cout<<\ }

void swap(int &i,int &j) {

int t; t=i; i=j; j=t; }

答： a=8,b=5 a=5,b=8

8．

#include

void print(int),print(char),print(char *); void main() {

int a(800); print(a); print('a');

print(\ }

void print(int i) {

cout<

第 32 页共 77 页

void print(char i) {

cout<

void print(char *i) {

cout<

5.5 编程题

1. 从键盘上输入8个浮点数，编程求出其和以及平均值。要求写出求和以及平均值的函数。答：编程如下：

#include

double s,sum(double b[],int n),average(int n); void main() {

double a[8]; cout<<\输入8个double型数 ;\ for(int i=0;i<8;i++) cin>>a[i]; s=sum(a,8); double ave=average(8); cout<<\VERAGE=\ }

double sum(double b[],int n) {

double sum=0; for(int i=0;i

double average(int n) {

return s/n;

}

2. 从键盘上输入8个整型数，编辑求出它们中间最大的数和最小的数。要求写出求最大

数和最小数的函数。答：编程如下：

#include

int max(double b[],int n),min(double b[],int n); void main() {

int a[8]; cout<<\输入8个int型数 ;\ for(int i=0;i<8;i++) cin>>a[i]; cout<<\最大数为 \最小数为 \ }

int max(double b[],int n)

第 33 页共 77 页

{

int max=b[0]; for(int i=0;imax) max=b[i]; return max; }

int min(double b[],int n) {

int min=b[0]; for(int i=0;i

3. 给定某个年、月、日，计算出这一天是属于该年的第几天。要求写出计算闰年的函数

和计算日期的函数。答：编程如下：

#include

int sum_day(int,int),leap(int); void main() {

int year,month,day; cout<<\请输入一个日期(yyyy mm dd): \ cin>>year>>month>>day; int days=sum_day(month,day); if(leap(year)&&month>2) days++; cout<

int sum_day(int month,int day) {

int day_month[13]={0,31,28,31,30,31,30,31,31,30,31,30,31}; for(int i=1;i

int leap(int year) {

int leap=year%4==0&&year0!=0||year@0==0; return leap;

}

4. 使用递归方法将一个n位整数转换为一个字符串。编写转换函数。答：编程如下：

#include void convert(int); void main() {

int num; cout<<\请输入一个整型数: \

第 34 页共 77 页

cin>>num; cout<<\输出的字符串是\ convert(num); cout<

void convert(int n) {

int a; if((a=n/10)!=0) convert(a); char c=n+'0'; cout<

5. 编写一个程序验证：任何一个充分大的偶数（≥6）总可以表示成两个素数之和。要求编

写一个求素数的函数prine()，它有一个int型参数，当参数值为素数时返回1，否则返回0。答：编程如下：

#include int prime(int); void main() {

int n; cout<<\请输入一个大于或等于6的偶数: \ cin>>n; int i,j; cout<<\两个素数的所有可能有：\\n\ for(i=2;i<=n/2;i++) { j=n-i; if(prime(i)&&prime(j)) cout<<\ } }

int prime(int n) {

int j=2; while(n%j!=0) j++; if(n==j) return 1; else return 0; }

5.6 简单回答下列问题

1．没有返回值的函数是否有函数类型？函数参数类型与函数的类型是否有关系？答：没有返回值的函数的类型为void。没有关系。

2．函数的缺省的存储类是什么？函数的存储类与函数什么关系？

答：函数的缺省的存储类是外部类。函数的存储类决定了函数的作用域。 3．函数的调用方式有哪两种？传址和引用调用方式有何不同？

答：函数的调用方式有两种：传值调用和引用调用。传址调用时实参用地址值，形参用指

第 35 页共 77 页

针，引用调用时实参用变量名，形参用引用名。 4．内联函数与一般函数有何不同？

答：内联函数的函数体是在编译时被替换，一般函数的函数体是在调用时被转去执行。前者可以提高速度，后者可以减少代码，各有利弊。

5．对重载函数设臵默认参数值，对重载函数的选择是否会有影响？答：是会有影响的。

第6章类和对象(一)

练习题6

6.1 判断题

× 1．使用class定义的类，其默认的访问权限是公有的，使用struct定义的类，其默认的访问权限是私有的。

× 2．类中的成员函数都是公有的，数据成员都是私有的。

× 3．定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。 √ 4．类定义后，它的成员个数及名称就不会再被改变了。

× 5．定义或说明对象时，系统会自动调用构造函数为创建的对象初始化。如果类中没有定义任何构造函数时，就无法给定义的对象初始化。

√ 6．定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。

√ 7．对象成员的表示方法与结构变量成员的表示方法相同。

√ 8．创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。

√ 9．构造函数是一个其名与类名相同的特殊的成员函数。 × 10．析构函数是一个函数体为空的成员函数。

√ 11．构造函数和析构函数都是系统自动调用的成员函数。 × 12．构造函数和析构函数都可以重载。

√ 13．成员函数与一般函数一样可以重载、内联和设臵参数的默认值。 × 14．静态成员是指静态对象的成员。

× 15．静态数据成员必须在构造函数的成员初始化列表中进行初始化。 √ 16．静态成员都可以使用类名加作用域运算符的方法来引用。

× 17．静态成员函数中引用静态数据成员和非静态数据成员的方式是相同的。 √ 18．常成员指的是类体内使用const关键字说明的常数据成员和常成员函数。

× 19．常数据成员在常成员函数中的值是不允许改变的，而在非常成员函数中是允许改变的。

√ 20．常对象需要引用常成员函数，而不能引用非常成员函数。 × 21．常对象的数据成员都是常数据成员。

√ 22．友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。

× 23．可以把一个一般函数说明为某类的友元函数，也可以将某类的成员函数说明为另类的友元函数。

√ 24．友元类中的所有成员函数都是友元函数。

√ 25．类型转换函数是一种特殊的成员函数，定义时不加类型说明，无函数参数。 √ 26．单参数的构造函数具有类型转换的作用。 6.2 单选题

1．下列关于类的定义格式的描述中，错误的是（ C ）。 A．类中成员有3种访问权限

第 36 页共 77 页

B．类的定义可分说明部分和实现部分

C．类中成员函数都是公有的，数据成员都是私有的 D．定义类的关键字通常用class，也可用struct

2．下列关键字中，不属于定义类时使用的关键字是（ D ）。 A．class B．struct C．public D．default 3．下列关于成员函数的描述中，错误的是（ A ）。 A．成员函数的定义必须在类体外

B．成员函数可以是公有的，也可以是私有的

C．成员函数在类体外定义时，前加inline可为内联函数 D．成员函数可以设臵参数的默认值

4．下列关于对象的描述中，错误的是（ D ）。 A．定义对象时系统会自动进行初始化

B．对象成员的表示与C语言中结构变量的成员表示相同 C．属于同一个类的对象占有内存字节数相同 D．一个类所能创建对象的个数是有限制的

5．下列关于构造函数的描述中，错误的是（ C ）。 A．构造函数可以重载 B．构造函数名同类名

C．带参数的构造函数具有类型转换作用 D．构造函数是系统自动调用的

6．下列关于析构函数的描述中，错误的是（ A ）。 A．析构函数的函数体都为空 B．析构函数是用来释放对象的 C．析构函数是系统自动调用的 D．析构函数是不能重载的

7．下列关于静态成员的描述中，错误的是（ C ）。 A．静态成员都是使用static来说明的

B．静态成员是属于类的，不是属于某个对象的

C．静态成员只可以用类名加作用域运算符来引用，不可用对象引用 D．静态数据成员的初始化是在类体外进行的 8．下列关于常成员的描述中，错误的是（ C ）。 A．常成员是用关键字const说明的

B．常成员有常数据成员和常成员函数两种

C．常数据成员的初始化是在类体内定义它时进行的 D．常数据成员的值是不可以改变的

9．下列关于友元函数的描述中，错误的是（ B ）。 A．友元函数不是成员函数

B．友元函数只可访问类的私有成员 C．友元函数的调用方法同一般函数

D．友元函数可以是另一类中的成员函数

10．下列关于类型转换函数的描述中，错误的是（ C ）。

A．类型转换函数是一种成员函数

B．类型转换函数定义时不指出类型，也没有参数

C．类型转换函数的功能是将其函数名所指定的类型转换为该类类型 D．类型转换函数在一个类中可定义多个 6.3 填空题

第 37 页共 77 页

1．类体内成员有3个访问权限，说明它们的关键字分别是公有、私有和保护。 2．使用class定义的表中，成员的默认访问权限是私有的；由struct定义的类中，成员的默认的访问权限是公有的。

3．如果一个类中没有定义任何构造函数时，系统会自动提供一个默认构造函数；同样，类中没有定义析构函数时，系统会自动提供一个默认析构函数。

4．静态成员是属于类的，它除了可以通过对象名来引用外，还可以使用类名限定来引用。

5．友元函数是被说明在类体内的非成员函数。友元函数可访问该类中的成员。

6．完成下列类的定义。

class A {

public:

A() { a=0; }

int int Geta( A &m); private: int a; };

int Geta( A &m) { return m.a; }

6.4 分析下列程序的输出结果 1．

#include class A {

public: A() {

a1=a2=0;

cout<<\ }

A(int i,int j); ~A()

{ cout<<\ } void Print()

{ cout<<\ } private: int a1,a2; };

A::A(int i,int j) { a1=i; a2=j;

cout<<\ }

void main() {

A a,b(5,8); a.Print();

第 38 页共 77 页

b.Print(); }

答： Default constructor called. Constructor called. a1=0,a2=0 a1=5,a2=8 Destructor called. Destructor called.

2．

#include class B { public: B()

{ cout<<++b<

{ cout<

int B::b=10; void main() {

B b1,b2,b3;

cout<

3．

#include class Date {

public:

Date(int y,int m,int d) {

year=y; month=m; day=d;

第 39 页共 77 页

}

friend void Print(Date &); private:

int year,month,day; };

void Print(Date &d) {

cout<

void main() {

Date d1(2005,10,1),d2(2005,12,9); Print(d1); Print(d2); }

答： 2005/10/1 2005/12/9

4．

#include class C {

public:

C(int i,int j)

{ c1=i;c2=j; } void Sum(C a,C b) {

c1=a.c1+b.c1; c2=a.c2+b.c2; }

void Print()

{ cout<<\ } private: int c1,c2; };

void main() {

C a(6,9); C b(a); C c(b); c.Sum(a,b); c.Print(); }

答： c1=12,c2=18

5．

#include class S {

public: S()

{ PC=0; } S(S &s) {

PC=s.PC;

for(int i=0;i

void Empty() { PC=0; } int IsEmpty()

第 40 页共 77 页

{ return PC==0; } int IsMemberOf(int n); int Add(int n); void Print(); private:

int elems[100],PC; };

int S::IsMemberOf(int n) {

for(int i=0;i

int S::Add(int n) {

if(IsMemberOf(n)) return 1; else if(PC==100) return 0; else {

elems[PC++]=n; return 1; } }

void S::Print() {

cout<<'{';

for(int i=0;i0)

cout<

void main() { S a;

cout<

for(int i=1;i<=5;i++) b.Add(i);

b.Print();

cout<

第 41 页共 77 页

{}

{1,2,3,4,5} 1 0

{1,2,3,4,5,6,7,8,9,10}

6.5 编程题

1．按下列要求编程：

（1）定义一个描述矩形的类Rectangle，包括的数据成员有宽（width）和长（length）；（2）计算矩形周长；（3）计算矩形面积；（4）改变矩形大小。通过实例验证其正确性。答：编程如下：

#include class Rectangle {

public:

Rectangle(int a,int b) { width=a; length=b; } int Area()

{ return width*length; } int Periment() { return 2*(width+length); } void Changesize(int a,int b) { width=a; length=b; } void Print(); private:

int width,length; };

void Rectangle::Print() {

cout<<\ cout<<\ }

void main() {

Rectangle r(5,8); r.Print(); r.Changesize(3,9); r.Print(); }

6．编程实现一个简单的计算器。要求从键盘上输入两个浮点数，计算出它们的加、减、

乘、除运算的结果。答：编程如下：

#include class ASMD {

public:

ASMD(double a,double b) { x=a; y=b; }

第 42 页共 77 页

void Addition()

{ cout<

double x,y; };

void ASMD::Print() {

Addition(); Subtration(); Multiply(); Divison(); }

void main() {

ASMD a(40,8); a.Print(); }

3．编一个关于求多个某门功课总分和平均分的程序。具体要求如下：（1）每个学生信息包括姓名和某门功课成绩。（2）假设5个学生。

（3）使用静态成员计算5个学生的总成绩和平均分。答：编程如下：

#include #include class Student {

public:

Student(char s[],int gr)

{ strcpy(name,s); grade=gr; totalize+=gr; } static void Print(); private:

char name[10]; int grade; static int totalize; }; int Student::totalize=0; void Student::Print() {

cout<<\总成绩为 \平均成绩为 \ }

void main() {

第 43 页共 77 页

Student s1(\ Student::Print(); }

6.6 简单回答下列问题 1．一个类中是否必须有用户定义的构造函数？如果用户没有定义构造函数，又如何对

创建的对象初始化？

答：一个类用户可以不定义构造函数，这时系统自动提供一个默认的构造函数，并可用该构造函数对创建的对象初始化。 2．拷贝构造函数具有几个参数？它有类型转换的作用吗？

答：拷贝构造函数具有一个参数，即为该类对象的引用。拷贝构造函数没有类型转换作用。 3．静态成员属于类的，是否每个对象都可以引用该静态成员？答：可以。 4．常对象可以引用非常成员函数吗？非常对象可以引用常成员函数吗？答：不可以。可以。

5．友元函数能否访问类中的保护成员？友元函数访问类中私有成员与成员函数访问私有成员的形式相同吗？

答：能。相同。

第7章类和对象(二)

练习题7

7.1 判断题

× 1．定义对象指针时也要调用构造函数。

√ 2．对象指针可用同类对象的地址值给它赋值。 × 3．对象指针成员表示与对象引用相同。

√ 4．常类型指针有两种，一种是指针的地址值是常量，另一种是指针所指向的变量或对象是常量。

× 5．指向对象的常指针的地址值是可以改变的。 × 6．指向常对象的指针所指向的对象是可以改变的。

√ 7．this指针是系统生成的指向当前被某个成员函数操作对象的指针。 × 8．对象引用可以用一个同类对象的地址值对它赋值。

× 9．定义对象引用时，可以对其引用进行初始化，也可以不进行初始化。 × 10．对象数组的元素可以是不同类的对象。

× 11．对象指针数组可以使用不同类的对象的地址值进行初始化。 × 12．给对象数组元素赋值时都要创建临时对象。 √ 13．指向一维对象数组的指针是一个二级指针。 × 14．自身类对象可作该类的子对象。

√ 15．子对象的初始化要在构造函数的成员初始化列表中进行。 √ 16．使用new运算符创建的对象称为堆对象。 √ 17．任何对象都可以使用delete运算符来释放。

× 18．使用new运算符创建的对象数组其元素都具有默认值。 √ 19．类的作用域范围指的是类体内。 × 20．对象的存储类只有外部的和静态的。

7.2 单选题

第 44 页共 77 页

1．f1()函数是类A的公有成员函数，p是指向类的成员函数f1()的指针，下列表示中正确的是（ C ）。

A．p=f1() B．p=f1 C．p=A::f1 D．p=A::f1()

2．p是指向类A数据成员a的指针，a是类A的一个对象。在给a成员赋值为5的下列表达式中，正确的是（ C ）。

A．a.p=5 B．a->p=5 C．a.*p=5 D．*a.p=5

3．Void Set(A&a);是类A中一个成员函数的说明，其中A&a的含义是（ A ）。 A．类A的对象引用a作该函数的参数 B．类A的对象a的地址值作函数的参数 C．表达式变量A与变量a按位与作函数参数 D．指向类A对象指针a作函数参数

4．已知：const A a；其中A是一个类名，指向常对象指针的表示为（ D ）。 A．const * A pa; B．const A *pa; C．A * const pa; D．const *pa A; 5．下列关于子对象的描述中，错误的是（ D ）。 A．子对象不可以是自身类的对象 B．子对象是另一个类的对象 C．子对象的初始化要包含在构造函数中 D．一个类中只能有一个子对象 6．执行下列说明语句，其调用构造函数的次数为（ A ）。

A a[5]，*p[2]；其中，A是一个类名

A．5 B．6 C．7 D．10 7．下列关于运算符new的描述中，错误的是（ D ）。 A．它可以创建对象或变量

B．它可以创建对象数组或一般类型数组

C．用它创建对象或对象数组时要调用相应的构造函数 D．用它创建的对象可以不用delete运算符释放

8．下列关于运算符delete的描述中，错误的是（ B ）。

A．使用该运算符可以释放用new运算符创建的对象或对象数组 B．使用该运算符可以释放所有对象

C．使用delete运算符时会自动调用析构函数

D．用它释放对象数组时，它作用的指针名前要加下标运算符[ ] 9．定义不同存储类对象时，必须要加的存储类说明符是（ C ）。 A．auto B．extern C．statie D．register 10．下列关于this的描述中，错误的是（ D ）。

A．this是一个由系统自动生成的指针 B．this指针是指向对象的

C．this指针在用对象引用成员函数时系统创建的 D．this指针只能隐含使用，不能显式使用

7.3 填空题

已知：class A{ public:A (int i) { a=i;}

void print( ) { cont<

要求：

第 45 页共 77 页

1．定义一个指向对象的常指针p，应该是 A *const p; 。 2．定义一个指向常对象指针p，应该是 A const *p; 。

3．定义类A的含有5个元素的一维对象数组a，应该是 A a[5]; 。

4．定义一个对象指针数组pa，它有5个元素，每个元素是类A对象指针，应该是 A *pa[5]; 。 5．使用new创建一个堆对象，一个实参值为5，应该是 A *p; p=new A(5); 。

6．使用new创建一个对象数组，该数组用指针pa指向，并使数组的3个元素都是类A的对象a1的值。应该是 A a1,*pa; pa=new A[3]; pa[0]=pa[1]=pa[2]=a1; 。

7．在某个函数体内定义一个静态类的对象sa，应该是 static A sa; 。

8．定义一个类A的对象a1，并给它赋值，其实参值为8，应该是 A a1(8); 。

7.4 分析下列程序的输出结果 1．

#include class A { public: A(int i) { a=i; } A() { a=0;

cout<<\ } ~A()

{ cout<<\ } void Print()

{ cout<

A a[4],*p; int n=1; p=a;

for(int i=0;i<4;i++) a[i]=A(++n); for(i=0;i<4;i++) (p+i)->Print(); }

答： Default constructor called. 0 Default constructor called. 0 Default constructor called. 0 Default constructor called. 0 Destructor called. 2

第 46 页共 77 页

Destructor called. 3 Destructor called. 4 Destructor called. 5 2 3 4 5

Destructor called. 5 Destructor called. 4 Destructor called. 3 Destructor called. 2

2．

#include class B {

public:

B(int i) { b=i; } B() {

b=0;

cout<<\ } ~B()

{ cout<<\ } void Print()

{ cout<

B *pb[4]; int n=1;

for(int i=0;i<4;i++) pb[i]=new B(n++); for(i=0;i<4;i++) pb[i]->Print(); for(i=0;i<4;i++) delete *(pb+i); } 答： 1 2 3 4

Destructor called. 1

第 47 页共 77 页

Destructor called. 2 Destructor called. 3 Destructor called. 4

3．

#include class C { public: C(int i) { c=i; } C() { c=0;

cout<<\ }

~C()

{ cout<<\ } void Print()

{ cout<

void main() {

C *p;

p=new C[4]; int n=1;

for(int i=0;i<4;i++) p[i]=C(n++); for(i=0;i<4;i++) p[i].Print(); delete []p; }

答： Default constructor called. 0 Default constructor called. 0 Default constructor called. 0 Default constructor called. 0 Destructor called. 2 Destructor called. 3 Destructor called. 4 Destructor called. 5 2 3 4 5

Destructor called. 5

第 48 页共 77 页

Destructor called. 4 Destructor called. 3 Destructor called. 2

4．

#include class D { public: D() {

d1=d2=0;

cout<<\ }

D(int i,int j) {

d1=i; d2=j;

cout<<\ } ~D()

{ cout<<\ } void Set(int i,int j) { d1=i;d2=j; } private: int d1,d2;

};

void main() {

int n(10),m(20);

D d[4]={D(5,7),D(3,6),D(7,9),D(1,4)}; for(int i=0;i<4;i++) d[i].Set(n++,m++); }

答： Constructor called. d1=5,d2=7 Constructor called. d1=3,d2=6 Constructor called. d1=7,d2=9 Constructor called. d1=1,d2=4 Destructor called. d1=13,d2=23 Destructor called. d1=12,d2=22 Destructor called. d1=11,d2=21 Destructor called. d1=10,d2=20

5．

#include class E {

public:

E(int i,int j) {

第 49 页共 77 页

e1=i; e2=j;

cout<<\ }

void FunE(E *e) {

e1=e->e1; e2=e->e2;

cout<<\ }

void FunE(E &e) {

e1=e.e1; e2=e.e2;