C++试题

第一章

一、选择题

1．最初的计算机编程语言是：
a.机器语言
b.汇编语言
c.高级语言
d.低级语言
2．程序应该必须包含的部分是：
a.头文件
b.注释
c.高级语言
d.数据结构和算法
3．结构化程序设计的基本结构不包含以下哪项？
a.顺序
b.选择
c.跳转
d.循环
4．下列哪项不是面向对象程序设计的主要特征？
a.封装
b.继承
c.多态
d.结构
5．对象之间的相互作用和通信是通过消息。下列哪项不是消息的组成部分？
a.接受消息的对象
b.要执行的函数的名字
c.要执行的函数的内部结构
d.函数需要的参数
-----------------------------------------------------------------------------------------
答案:

　　1．答案为a
　　2．答案为d
　　3．答案为c
　　4．答案为d
　　5．答案为c

二、填空题

1．语言处理程序主要包括  ,  ,  三种。
2．汇编程序的功能是将汇编语言所编写的源程序翻译成由  组成的目标程序。
3．编译过程一般分成5个阶段：  、语法分析、  、代码优化和目标代码生成。
4．目前，有两种重要的程序设计方法，分别是：  和  。
5．在C++中，封装是通过  来实现的？
6．C++程序一般可以分为4个部分：  ，全局说明，  ，用户自定义的函数。
7．任何程序逻辑都可以用  、  和  等三种基本结构来表示。
-----------------------------------------------------------------------------------------
答案:

二、填空题

　1．汇编程序，解释程序，编译程序
　2．机器指令
　3．词法分析，中间代码生成
　4．结构化的程序设计，面向对象的程序设计
　5．类
　6．预处理指令，程序的主函数
　7．顺序选择循环

三、编程及问答题

1．叙述高级程序设计语言相对于低级语言的优点。

2．什么是结构定理？简单叙述结构化程序设计的过程。

3．面向对象程序设计的基本思想是什么？什么是对象、消息和类？什么是面向对象程序设计的基本特征？

4．C＋＋语言具有哪些特点？

5．既然机器语言和汇编语言都是计算机可以理解的语言，使用它们可以完全控制计算机的行为，那么为什么人们还要创造并使用高级程序设计语言呢？

6．软件危机的含义是什么？

三、简答题
　1．低级语言与计算机硬件联系紧密，涉及到许多计算机底层操作的细节，要求程序员详细说明由计算机执行的每一步操作，这样的特性决定了使用低级语言是很繁琐和易错的；低级语言指令会因为硬件型号不同而有很大差异，使得用其编写的程序不具有可移植性。
高级语言不涉及计算机底层的硬件，它提供较高层次的抽象，使用高级语言，编程者可以远离机器细节；高级语言不是面向机器的，而是面向问题的，这样更加接近编程者习惯的思维；高级语言编写的程序具有一定的可移植性。

　2．结构定理指出：任何程序逻辑都可以用顺序、选择和循环三种基本结构来表示。结构化程序设计方法采用"自顶向下逐步求精"的方式确定模块的执行过程，并且要求只用顺序、选择和循环三种基本结构反复嵌套来构造程序。结构化程序设计的详细过程可以参考本章图1.2（b）。

　3．向对象程序设计的基本思想，就是尽可能模拟人类习惯的思维方式，使开发软件的方法和过程尽可能接近人类认识世界、解决问题的方法和过程，也就是使描述问题的问题空间与实现解法的解空间在结构上尽可能一致。
　　面向对象程序设计中，重要的是现实世界的模型。面向对象程序设计围绕着建立问题领域的对象模型来进行，对问题领域进行自然的分解和抽象，确定需要使用的对象和类，在对象间传递信息实现必要的联系，从而按照人们习惯的思维方式建立起问题领域的模型，模拟客观世界。
　　面向对象程序设计的基本概念和主要特征详见本章第三节。

　4．本章第四节。

　5．因为机器语言和汇编语言都是低级语言，是面向机器的，与具体的计算机相关。学习起来困难，编程效率也低，可读性、可维护性也差。

　6．软件危机是指在计算机软件的开发和维护过程中遇到的一系列严重的问题。概括地讲，软件危机包含下述两方面的问题：如何开发软件以满足对软件日益增长的需求；如何维护数量不断膨胀的现有软件。

第二章
一、选择题：

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

一、选择题

　1．答案为a
　2．答案为d
　3．答案为d
　4．答案为b
　5．答案为b

二、改错题

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

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

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

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

二改错题

　1．答：错误有二，首先程序中用到输出对象cout，则必须在程序首部加上文件包含语句#include <iostream.h>。第二，语句结束必须有结束符"；"。

　2．答：错误有二，首先变量必须先定义后使用，而x未定义就输入值是错误的。第二，如果程序要输出p的值，括号位置是不对的，第二个语句应写为：cout<<"p="<<p<<"\n";

　3．答：变量应先定义再使用，但还要注意，变量要初始化后才能引用。因j未初始化， k的结果是不可预料的。

　4．二者一个是字符串，一个是字符，是不等价的，前者由两个字节组成（字符'A'与字符'\0'），而后者只有一个字节。

三、编程题：

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

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

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

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

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

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

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

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

答案:

三、编程题

　1． void main(){}

　2．
　参考程序如下：
　#include <iostream.h>
　void main()
　{
　　double F,C;
　　/* 输入部分 */
　　cout<<"请输入华氏温度：";
　　cin>>F;
　　/* 计算部分 */
　　C = 5.0 * (F - 32.0) / 9.0;

　　/* 输出部分 */
　　cout<<"相应的摄氏温度为："<<C<<endl;
　}

　3. 参考程序如下：
　#include <iostream.h>
　const double PI= 3.1415 ;
　void main()
　{
　　double R,C,S,V;

　　/* 输入部分 */
　　cout<<"请输入半径：";
　　cin>>R;

　　/* 计算部分 */
　　C = 2.0 * PI * R;
　　S = PI * R * R;
　　V = 4.0 * S * R / 3.0;

　　/* 输出部分 */
　　cout<<"圆周长为："<<C<<endl;
　　cout<<"圆面积为："<<S<<endl;
　　cout<<"圆球体积为："<<V<<endl;
　　}程序输出结果为：
　　请输入半径：2.0
　　圆周长为：12.566
　　圆面积为：12.566
　　圆球体积为：33.5093

　4．答：将输出 98

　5．输出结果为：a=012,b=-005.200

　6．输出结果为：-3,37777777775,fffffffd,FFFFFFFD,fffffffd

　7．输出结果为：
　　a,97, a
　　A,65, 65

　8．输出结果为：
　hello,hel , he
　说明：第一个"hello"按%3s输出，由于"hello"长度超过3，因此按实际长度输出。第二个"hello"输出宽度为5，且从前面截取3个字符左对齐输出，第三个"hello"的输出宽度仍为5，从"hello"中截取2个字符右对齐输出。

第三章
一：选择题
1．以下符号中不能作为标识符的是：
a._256
b.void
c.scanf
d.Struct
2．下面不能正确表示a*b/(c*d)的表达式是：
a.(a*b)/c*d
b.a*b/(c*d)
c.a/c/d*b
d.a*b/c/d
3．下列运算符中，运算对象必须是整型的是：
a./
b.%=
c.=
d.&
4．若x,y,z均被定义为整数，则下列表达式终能正确表达代数式1/（x*y*z）的是：
a.1/x*y*z
b.1.0/(x*y*z)
c.1/(x*y*z)
d.1/x/y/(float)z
5．已知a,b均被定义为double型，则表达式：b=1,a=b+5/2的值为：
a.1
b.3
c.3.0
d.3.5
6．如有int a=11;则表达式（a++*1/3）的值是
a.0
b.3
c.4
d.12
7．在下列运算符中，优先级最低的是：
a.||
b.!=
c.<
d.+
8．表达式9!=10的值为：
a.非零值
b.true
c.0
d.1
9．能正确表示x>=3或者x<1的关系表达式是：
a.x>=3 or x<1
b.x>=3|x<1
c.x>=3||x<1
d.x> =3||x<1
10．下列运算符中优先级最高的是：
a.!
b.%
c.-=
d.&&

答案：

一：选择题

　1．答案为b
　2．答案为a
　3．答案为b
　4．答案为b
　5．答案为c
　6．答案为b
　7．答案为a
　8．答案为d
　9．答案为c
　10. 答案为a

二：填空题
1．若a为double性的变量，表达式a=1,a+5,a++的值为  。
2．表达式7.5+1/2+45%10=  。
3．与! (x>2)等价的表达式是  。
4．表达式于语句的重要区别是  。
5．赋值运算符的结合性是由  至  。
6．x *= y+8等价于x=  。
7．给出下列程序的输出结果  。
　#include <iostream.h>
　void main()
　{
　　int a=3,b=6;
　　int c=a^b<<2;
　　cout<<c<<endl;
　}
8. 给出下列程序的输出结果  。
　#include <iostream.h>
　void main()
　{
　　int x=5;
　　int y=2+(x+=x++,x+8,++x);
　　cout<<y<<endl;
　}
9. 给出下列程序的输出结果  。
　#include <iostream.h>
　void main()
　{
　　int a=7,b=4;
　　float x,y=27.2,z=3.4;
　　x=a/2+b*y/z+1/3;
　　cout<<x<<endl;
　}
10. 给出下列程序的输出结果  。
　#include <iostream.h>
　void main()
　{
　　int a=-1,b=4,k;
　　k=(a++<=0)&&!(b--<=0);
　　cout<<k<<a<<b<<endl;
　}

二：填空题

　1. 答：1.0

　2. 答：12.5。注意，因为"/"两侧都是整型数，因此其结果也应该是整型，所以1/2的结果为0，而不是0.5。

　3: 答：x<=2

　4: 答：表达式具有值，而语句是没有值的并且语句末尾要加分号。

　5：答：右左

　6：答：x*(y+8)

　7. 答：27

　8. 答：14

　9. 答：35

　10. 答：1 0 3

三：编程及简答题
1．x=2, y=3, z= 4时，计算下面表达式的值A1、A2
A1 = x + y +2/2+z和 A2=x+(y+2)/(2-z)

2．述算术运算符的组成

3．下列运算符从高到底进行排序：‘+’、‘*’、‘&&’、 ‘&’、 ‘>’、 ‘>=’、 ‘*=’。

4．述下列运算符各能代表几种意义：‘-’、‘&’、‘*’。

5．下列运算符的结合性如何：‘+’、‘&’、‘=’、‘||’。

6．计算下列表达式的值：
i.1/2 + 5/2 + 7/6
ii.1/2. + 5/2. + 3.
iii.1/2 + 5./2 + 2
iv.(unsigned char) 500 + 200
v.(unsigned char) (500 + 200)
vi.(unsigned int)(unsingned char)750

7.编程实现：由键盘输入两个整数，然后输出最大者。

8．int a=5, b=0; 问下面表达式运算后a和b的值是多少？
(1) ! a && a+b && a++
(2) !a||a++||b++

9．有变量说明
int a=4,b;
指出下面表达式运算后a和b的结果？
b+=b=++a;

10. 编程实现：测试你机器的 int,float,double,long,char 各类型变量存储的字节数。

三：编程及简答题

　1: 答：A1 = 2+3 + 1 + 4 = 5+1+4=6+4=10; A2 = 2 + (3+2)/(2+4) = 2 + 5/6 = 2 + 0 = 2

　2: 答：算术运算符由加'+'减'-'乘'*'除'/'和取余'%'组成。

　3: 答：依次为'*'、'+'、'>'、 '>='、 '&'、'&&'、 '*='。

　4: 答：'-'可以用于代表双目运算符减运算，同时可以代表单目运算符使后面的操作数变换符号。'&'可以用于代表双目运算符按位与运算，同时可以是地址运算符，表示后面操作数的地址。'*'可以用于代表双目运算符乘运算，同时可以与'&'相对应的单目运算符，表示后面的操作数地址中的值。

　5: 答：'+'、'&'作为单目运算符时结合性和从右到左，而作为双目运算符时，则为从左到右。'='运算符的结合性为从右到左，'||'运算符的结合性为从左到右。

　6: 答：(1) 为3; (2) 为6.0; (3) 为4.5; (4) 为644; (5) 为188; (6) 为238;

　7: 答：
　#include <iostream.h>
　void main()
　{
　　int a,b;
　　int max;
　　cout<<"please input a and b:";
　　cin>>a>>b;
　　max=(a>b)? a:b ;
　　cout<<"a 和b 其中最大的是："<<max<<endl;
　}

　8: 答：（1）a=5, b=0
　　　　（2） a=6, b=0

　9: 答：a为5，b为10

　10：答：
　#include <iostream.h>
　void main()
　{
　　cout<<"Variables of type int use "<<sizeof(int)<<" bytes"<<endl;
　　cout<<"Variables of type float use "<<sizeof(float)<<" bytes"<<endl;
　　cout<<"Variables of type double use "<<sizeof(double)<<" bytes"<<endl;
　　cout<<"Variables of type long use "<<sizeof(long)<<" bytes"<<endl;
　　cout<<"Variables of type char use "<<sizeof(char)<<" bytes"<<endl;
　}

第4章
一：选择题
1．如果变量x,y已经正确定义，下列语句哪一项不能正确将x,y的值进行交换：
a. x=x+y,y=x-y,x=x-y;
b. t=x,x=y;y=t;
c. t=y,y=x,x=t;
d. x=t,t=y,y=x
2．如要求在if后一对括号中的表达式，表示a不等于0的时候的值为"真"，则能正确表示这一关系的表达式为：
a. a<>0
b. !a
c. a=0
d. a
3．下面的这个循环的循环次数是：for(int i=0,j=10;i=j=10;i++,j--)
a. 无限次
b. 语法错误，不能执行
c. 10
d. 1
4．以下哪个不是循环语句：
a. while语句
b. do-while语句
c. for语句
d. if-else语句
5．下列do-while循环的循环次数是：
　已知：int i=5;
　do{ cout<<i--<<endl;
　　i--;
　}while (i!=0)
a. 0
b. 2
c. 5
d. 无限次
6．下列do-while循环的循环次数是：
　　for(int i=0,x=0;!x&&i<=5;i++)
a.5
b.6
c.1
d.无限次

答案:

一：选择题

　1．答案为d
　2．答案为d
　3．答案为a
　4．答案为d
　5．答案为d
　6．答案为b

二：填空题
1． do-while语句与while语句的主要区别  。
2． x,y,z为int类型的时候，下列语句执行之后，x的值为  , y的值为  ,z的值为  。
　　x=10;y=20;z=30;
　　if(x>y) x=y;y=z;z=x;
3．  是构造程序最基本的单位，程序运行的过程就是  的过程。
4． break语句实现的功能是  。
5． continue语句实现的功能是  。
答案：

二：填空题

　1. 答：do-while语句是先执行循环体，然后检查循环条件；while语句是先检查循环条件，再执行循环体。

　2. 答：10，20，10

　3: 答：语句，执行程序语句

　4: 答：break语句用在循环语句的循环体内的作用是终止当前的循环语句。

　5：答：根据程序的目的，有时需要程序在满足另一个特定条件时跳出本次循环。

三：编程及简答题
1. 用两次for 循环和求余运算符测试和打印输出（2-100）中为素数的正整数。

2．写一段程序，使用while循环从标准输入设备中读取字符到字符串中，自己确定输入什么字符时退出循环，对每一个读取的字符先用if语句判别是否为数字，然后用switch语句判别是否为字母，并打印输出相应字母为首字母的英文单词到屏幕。退出循环后在屏幕上显示输入的字符串。

3．把下面程序中的if语句换成switch语句。
　#include <iostream.h>
　void main()
　{
　　char c;
　　while(true)
　　{
　　　cout << "MAIN MENU:" << endl;
　　　cout << "l: left, r: right, q: quit -> ";
　　　cin >> c;
　　　if (c == 'q')
　　　　break; // while结束
　　　if (c == 'l')
　　　{
　　　　cout << "LEFT MENU:" << endl;
　　　　cout << "select c or d: ";
　　　　cin >> c;
　　　　if(c == 'c')
　　　　{
　　　　　cout << "you chose 'c'" << endl;
　　　　　continue; // 返回主菜单
　　　　}
　　　　if(c == 'd')
　　　　{
　　　　　cout << "you chose 'd'" << endl;
　　　　　continue; // 返回主菜单
　　　　}
　　　　else
　　　　{
　　　　　cout << "you didn't choose c or d!"<< endl;
　　　　　continue; //返回主菜单
　　　　}
　　　}
　　　if (c == 'r')
　　　{
　　　　cout << "RIGHT MENU:" << endl;
　　　　cout << "select a or b: ";
　　　　cin >> c;
　　　　if (c == 'a')
　　　　{
　　　　　cout << "you chose 'a'" << endl;
　　　　　continue; //返回主菜单
　　　　}
　　　　if (c == 'b')
　　　　{
　　　　　cout << "you chose 'b'" << endl;
　　　　　continue; //返回主菜单
　　　　}
　　　　else
　　　　{
　　　　　cout << "you didn't choose c or d!"<< endl;
　　　　　continue; //返回主菜单
　　　　}
　　　}
　　cout << "you must type l or r or q!" << endl;
　}
　cout << "quitting menu..." << endl;
}

4．读下段程序，分析其功能是什么？
　#include <iostream.h>
　void main( )
　{
　　cout<<"please input the b key to hear a bell."<<endl;
　　char ch;
　　cin>>ch;
　　if (ch=='b')
　　　cout <<'\a';
　　else
　　　if (ch=='\n'
　　　　cout <<"what a boring select on..."<<endl;
　　　else
　　　　cout <<"bye! \n";
　}

5．编写一个程序实现以下功能：从键盘读入3个整数，比较其大小，输出其中的最大数。

6．以下程序中的else应该与哪一个if配对？
　1、 if （a==0）
　　　　p=0;
　　　if (a<0)
　　　　p=-1;
　　　else
　　　　p=1;
　2、 if （a==0）
　　　{
　　　　p=0;
　　　　if (a<0)
　　　　　p=-1;
　　　}
　　　else
　　　　p=1;

7．看下面几个循环语句，说明循环的含义。
　1、while ((c=getchar( ))!='Y'||c!='y'||c!='N'||c!='n' );
　2、 while (thue) {.... }
　3、while (i ) {... }
　4、int i=1,sum=0; while (i<=100) sum+=i++;

8．编程实现：输入一行字符，求其中字母、数字和其他符号的个数。

9．求满足下式的最小n值，其中的limit由键盘输入。
　　1+1/2+1/3+……+1/n>limit

10．编写程序输出菲波那切数列的前20项。即前两项为1，以后每一项为前两项之和。

11．编写程序根据学生成绩输出优、良、中、及格和不及格。

12．编程实现如下功能：读入一行字母，求其中元音字母出现的次数。

答案:

三：编程及简答题

　

1 1: 答：

2 　#include <stdio.h>

3 　int main()

4 　{

5 　　int i,j;

6 　　for (i=2; i<=100; i++)

7 　　{

8 　　　for (j=2; j<i; j++)

9 　　　{

10 　　　　if (i%j == 0)

11 　　　　　break;

12 　　　}

13 　　　if (j==i)

14 　　　{

15 　　　　printf("%d 是素数\n", i);

16 　　　}

17 　　}

18 　　printf("按任意键结束");

19 　　return 0;

20 　}

22 　2: 答：

23 　#include <stdio.h>

24 　#include <iostream.h>

26 　int main()

27 　{

28 　　unsigned char iChar, sString[512];

29 　　int i = 0;

31 　　while (true && i<511)

32 　　{

33 　　　printf("请输入一个能显示的字符(q或Q退出)：");

34 　　　cin>>iChar;

35 　　　if (iChar == 'q' || iChar == 'Q')

36 　　　　break;

37 　　　else if (iChar <='9' && iChar >= '0')

38 　　　　printf("%c为数字\n", iChar);

39 　　　else

40 　　　{

41 　　　　switch(iChar)

42 　　　　{

43 　　　　　case 'a':

44 　　　　　case 'A':

45 　　　　　　printf("The first char of word 'an'\n");

46 　　　　　　break;

47 　　　　　case 'b':

48 　　　　　case 'B':

49 　　　　　　printf("The first char of word 'big'\n");

50 　　　　　　break;

51 　　　　　case 'c':

52 　　　　　case 'C':

53 　　　　　　printf("The first char of word 'china'\n");

54 　　　　　　break;

55 　　　　　case 'd':

56 　　　　　case 'D':

57 　　　　　　printf("The first char of word 'decad'\n");

58 　　　　　　break;

59 　　　　　case 'e':

60 　　　　　case 'E':

61 　　　　　　printf("The first char of word 'english'\n");

62 　　　　　　break;

63 　　　　　case 'f':

64 　　　　　case 'F':

65 　　　　　　printf("The first char of word 'flash'\n");

66 　　　　　　break;

67 　　　　　case 'g':

68 　　　　　case 'G':

69 　　　　　　printf("The first char of word 'great'\n");

70 　　　　　　break;

71 　　　　　case 'h':

72 　　　　　case 'H':

73 　　　　　　printf("The first char of word 'happy'\n");

74 　　　　　　break;

75 　　　　　case 'i':

76 　　　　　case 'I':

77 　　　　　　printf("The first char of word 'integer'\n");

78 　　　　　　break;

79 　　　　　case 'j':

80 　　　　　case 'J':

81 　　　　　　printf("The first char of word 'judge'\n");

82 　　　　　　break;

83 　　　　　case 'k':

84 　　　　　case 'K':

85 　　　　　　printf("The first char of word 'kick'\n");

86 　　　　　　break;

87 　　　　　case 'l':

88 　　　　　case 'L':

89 　　　　　　printf("The first char of word 'large'\n");

90 　　　　　　break;

91 　　　　　case 'm':

92 　　　　　case 'M':

93 　　　　　　printf("The first char of word 'manage'\n");

94 　　　　　　break;

95 　　　　　case 'n':

96 　　　　　case 'N':

97 　　　　　　printf("The first char of word 'nurse'\n");

98 　　　　　　break;

99 　　　　　case 'o':

100 　　　　　case 'O':

101 　　　　　　printf("The first char of word 'ok'\n");

102 　　　　　　break;

103 　　　　　case 'p':

104 　　　　　case 'P':

105 　　　　　 printf("The first char of word 'public'\n");

106 　　　　　 break;

107

108 　　　　　case 'r':

109 　　　　　case 'R':

110 　　　　　printf("The first char of word 'repair'\n");

111 　　　　　 break;

112 　　　　　case 's':

113 　　　　　case 'S':

114 　　　　　 printf("The first char of word 'save'\n");

115 　　　　　 break;

116 　　　　　case 't':

117 　　　　　case 'T':

118 　　　　　 printf("The first char of word 'test'\n");

119 　　　　　 break;

120 　　　　　case 'u':

121 　　　　　case 'U':

122 　　　　　 printf("The first char of word 'unable'\n");

123 　　　　　 break;

124 　　　　　case 'v':

125 　　　　　case 'V':

126 　　　　　 printf("The first char of word 'valid'\n");

127 　　　　　 break;

128 　　　　　case 'w':

129 　　　　　case 'W':

130 　　　　　printf("The first char of word 'west'\n");

131 　　　　　break;

132 　　　　　case 'x':

133 　　　　　case 'X':

134 　　　　　 printf("The first char of word 'xanthin'\n");

135 　　　　　 break;

136 　　　　　case 'y':

137 　　　　　case 'Y':

138 　　　　　 printf("The first char of word 'yes'\n");

139 　　　　　 break;

140 　　　　　case 'z':

141 　　　　　case 'Z':

142 　　　　　 printf("The first char of word 'zoo'\n");

143 　　　　　 break;

144 　　　　　default:

145 　　　　　 printf("忽略输入的为控制字符！\n");

146 　　　　　 continue;

147 　　　　　}

148 　　　　}

149 　　　　sString[i] = iChar;

150 　　　　i++;

151 　　　}

152 　　　sString[i] = '\0';

153 　　　printf("\n输入的字符串为:%s\n", sString);

154 　　　printf("按任意键结束");

155 　　　return 0;

156 　}

157

158 　3: 答：

159 　#include <iostream.h>

160

161 　void main()

162 　{

163 　　char c;

164 　　while(true)

165 　　{

166 　　　cout << "MAIN MENU:" << endl;

167 　　　cout << "l: left, r: right, q: quit -> ";

168 　　　cin >> c;

169 　　　if (c == 'q') // while结束

170 　　　　break;

171 　　　switch(c)

172 　　　{

173 　　　　case 'l':

174 　　　　　cout << "LEFT MENU:" << endl;

175 　　　　　cout << "select c or d: ";

176 　　　　　cin >> c;

177 　　　　　switch(c)

178 　　　　　{

179 　　　　　　case 'c':

180 　　　　　　　cout << "you chose 'c'" << endl;

181 　　　　　　　break;

182 　　　　　　case 'd':

183 　　　　　　　cout << "you chose 'd'" << endl;

184 　　　　　　　break;

185 　　　　　　default:

186 　　　　　　　cout << "you didn't choose c or d!" << endl;

187 　　　　　　　break;

188 　　　　　}

189 　　　　　break;

190 　　　　case 'r':

191 　　　　　cout << "RIGHT MENU:" << endl;

192 　　　　　cout << "select a or b: ";

193 　　　　　cin >> c;

194 　　　　　switch(c)

195 　　　　　{

196 　　　　　　case 'a':

197 　　　　　　　cout << "you chose 'a'" << endl;

198 　　　　　　　break;

199 　　　　　　case 'b':

200 　　　　　　　cout << "you chose 'b'" << endl;

201 　　　　　　　break;

202 　　　　　　default:

203 　　　　　　　cout << "you didn't choose a or b!" << endl;

204 　　　　　　 break;

205 　　　　　}

206 　　　　　break;

207 　　　　default:

208 　　　　 cout << "you must type l or r or q!" << endl;

209 　　　　 break;

210 　　　　}

211 　　　}

212 　　　cout << "quitting menu..." << endl;　

213 　}

　4: 答：是等待输入一个字符，如果是字符b，则响铃，否则，如果是回车，则输出what a boring select on...，不是，则输出bye!。

　5: 答：

214 　#include <iostream.h>

215 　void main( )

216 　{

217 　　long a,b,c;

218 　　cout<<"输入三个数"<<endl;

219 　　cin>>a>>b>>c;

220 　　if (a<b)

221 　　　if (b<c)

222 　　　　cout <<c;

223 　　　else

224 　　　　cout<<b;

225 　　else

226 　　　if (a<c)

227 　　　　cout<<c;

228 　　　else

229 　　　　cout<<a;

230 　}

　6: 答：程序段1中else 与第二个if 配对，程序段2中else 与第一个if 配对。

　7: 答：
　程序段1接受键盘输入，直到输入的是Y,y,N,n为止。
　程序段2是一个死循环。
　程序段3当i为0时,结束循环。
　程序段4求1+2+3+……+100的和。

231 　8: 答：

232 　#include <iostream.h>

233 　#include <stdio.h>

234 　void main( )

235 　{

236 　　char c;

237 　　int letters=0,digits=0,others=0;

238 　　cout<<"Please input a line charaters\n";

239 　　while ((c=getchar( ))!='\n')

240 　　{

241 　　　if (c>='a' && c<='z' || c>='A' && c<='Z' )

242 　　　　letters++;

243 　　　else

244 　　　　if (c>='0' && c<='9')

245 　　　　　digits++;

246 　　　　else

247 　　　　　others++;

248 　　}

249 　　cout<<"letters:"<<letters<<endl

250 　　<<"digits"<<digits<<endl

251 　　<<"others"<<others<<endl;

252 　}

253

254 　9: 答：

255 　#include <iostream.h>

256 　void main()

257 　{

258 　　int i=0;

259 　　double sum=0.0,limit;

260 　　cout <<"Please input limit:\n";

261 　　cin>>limit;

262 　　do {

263 　　　i++;

264 　　　sum+=1.0/i;

265 　　　cout<<i<<" "<<sum<<endl;

266 　　} while (sum<limit);

267 　　cout<<i;

268 　}

269

270 　10：答：

271 　#include <iostream.h>

272 　void main()

273 　{

274 　　int i1=1,i2=1,i3,i;

275 　　cout<<i1<<' '<<i2<<' ';

276 　　for (i=3;i<=20;i++)

277 　　{

278 　　　i3=i1+i2;

279 　　　cout<<i3<<' ';

280 　　　i1=i2;

281 　　　i2=i3;

282 　　}

283 　}

284

285 　11：答：

286 　#include <iostream.h>

287 　void main ( )

288 　{

289 　　int sco, grade;

290 　　cout<<"please input a num\n";

291 　　cin>>sco;

292 　　grade=sco/10;

293 　　switch (grade)

294 　　{

295 　　　case 10:

296 　　　case 9: cout<<"优"; break;

297 　　　case 8: cout<<"良"; break;

298 　　　case 7: cout<<"中"; break;

299 　　　case 6: cout<<"及格"; break;

300 　　　case 5:

301 　　　case 4:

302 　　　case 3:

303 　　　case 2:

304 　　　case 1:

305 　　　case 0: cout<<"不及格"; break;

306 　　　default :cout<<"输入错误\n"; break; //break 可省略

307 　　}

308 　}

　12：答：

309 　#include <iostream.h>

310 　#include <stdio.h>

311 　void main( )

312 　{

313 　　char c;

314 　　int count=0;

315 　　while ((c=getchar())!='\n')

316 　　{

317 　　　switch (c) {

318 　　　　case 'a':

319 　　　　case 'A':

320 　　　　case 'e':

321 　　　　case 'E':

322 　　　　case 'i':

323 　　　　case 'I':

324 　　　　case 'o':

325 　　　　case 'O':

326 　　　　case 'u':

327 　　　　case 'U': count++;break;

328 　　　}

329 　　}

330 　　cout<<count<<endl;

331 　}

第五章
一：选择题
1．下列叙述中正确的是：
a. C++语言程序必须要有return语句
b. C++语言程序中，要调用的函数必须在main()函数中定义
c. C++语言程序中，只有int类型的函数可以未经声明而出现在调用之后
d. C++语言程序中，main()函数必须放在程序开始的部分
2．下列叙述中正确的是：
a. C++语言程序总是从第一个定义的函数开始执行
b. C++语言程序中，函数类型必须进行显式声明
c. C++语言程序中，return语句必须放在函数的最后
d. C++语言程序中，return语句中表达式的类型应该与函数的类型一致
3．下列叙述中正确的是：
a. C++语言程序中，main()函数必须在其它函数之前，函数内可以嵌套定义函数
b. C++语言程序中，main()函数的位置没有限制，函数内不可以嵌套定义函数
c. C++语言程序中，main()函数必须在其它函数之前，函数内不可以嵌套定义函数
d. C++语言程序中，main()函数必须在其它函数之后，函数内可以嵌套定义函数
4．一个C++语言程序总是从_______开始执行：
a. 主程序
b. 子程序
c. 主函数
d. 第一个函数
5．已知函数test定义为：
　void test()
　{
　　…………
　}
　则函数定义中void的含义是：
a. 执行函数test后，函数没有返回值
b．执行函数test后，函数不再返回
c．执行函数test后，函数返回任意类型值
d．以上三个答案都是错误的
6．以下对于C++语言的描述中，正确的是：
a.C++语言中调用函数时，值传递方式只能将实参的值传递给形参，形参的值不能传递给实参
b.C++语言中函数既可以嵌套定义，也可以递归调用
c.函数必须有返回值
d.C++程序中有调用关系的所有函数必须放在同一源程序文件中
7． C++语言中函数返回值的类型是由______决定的？
a.return语句中的表达式类型
b.调用该函数的主调函数类型
c.定义函数时所指定的函数类型
d.以上说法都不正确
8．在一个源文件中定义的全局变量的作用域为：
a.本程序的全部范围
b.本函数的全部范围
c.从定义该变量的位置开始到本文件结束
d.以上说法都不正确
9．以下说法错误的是：
a.全局变量就是在函数外定义的变量，因此又叫做外部变量
b.一个函数中既可以使用本函数中的局部变量，也可以使用全局变量
c.局部变量的定义和全局变量的定义的含义不同
d.如果在同一个源文件中，全局变量和局部变量同名，则在局部变量的作用范围内，全局变量通常不起作用
10．当一个函数无返回值时，定义它的函数类型应是＿＿＿。
a.void
b.int
c.任意
d.无
答案:

一：选择题：

　1 （c）是正确的，本题为基础题，可参考教材得出答案。
　2 （d）是正确的，本题为基础题，可参考教材得出答案。
　3 （b）是正确的，在C++语言中，主函数main()在程序中的位置是没有限制的，可以在程序中的任何地方，但是C++语言中不允许进行函数嵌套定义。
　4 （c）是正确的，本题为基础题，可参考教材得出答案。
　5 （a）是正确的，本题为基础题，可参考教材得出答案。
　6 （a）是正确的。（b）错误，C++语言中函数不可以嵌套定义。（c）错误，void类型的函数可以没有返回值。（d）错误，一个C++程序允许由多个文件组成，有调用关系的函数可以放在不同的源程序文件中。
　7 （c）是正确的
　8 （c）是正确的
　9: (a) 是正确的
　10: (a) 是正确的

二：编程及简答题
1．下面的程序共有17行，程序中变量num、i、temp、对象cout和函数func()的作用域范围分别是什么？
　1、#include<iostream.h>
　2、int num;
　3、void func();
　4、void main()
　5、{
　6、 char name[20];
　7、 int i;
　8、 for(i=0;i<20;i++)
　9、 {
　10、 char temp;
　11、 temp=name;
　12、 cout<<temp;
　13、 }
　14、}
　15、void func()
　16、{
　17、 cout<<"A function!";
　18、}

2．用递归函数完成以下运算：
　sum(n)=1+2+3+…＋n
　函数的原型如下：
　int sum(int n);
　该函数完成1+2+3+…n的运算，并返回运算结果,其中n>0

3．阅读下面的程序，回答问题：
　//file1.cpp
　static int i = 20;
　int x;
　static int g(int p)
　{
　　return i + p;
　}
　void f(int v)
　{
　　x = g(v);
　}
　//file2.cpp
　#include <iostream.h>
　extern int x;
　void f(int);
　void main()
　{
　　int i = 5;
　　f(i);
　　cout << x;
　}
　回答以下问题:
　（1）、程序的运行结果是什么样的？
　（2）、为什么文件file2.cpp中要包含头文件<iostream.h>？
　（3）、在函数main()中是否可以直接调用函数g()，为什么？
　（4）、如果把文件file1.cpp中的两个函数定义的位置换一下，程序是否正确，为什么？
　（5）、文件file1.cpp和file2.cpp中的变量i的作用域分别是怎样的？在程序中直接标出两个变量各自的作用域

4．给出下列程序中的输出结果。
　(1) #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;
　　}
　(2) #include<iostream.h>
　　void fn(int n)
　　{
　　　int x=5;
　　　static int y=10;
　　　if(n>0)
　　　{
　　　　++x;
　　　　++y;
　　　　cout<<x<<","<<y<<endl;
　　　}
　　}
　　void main()
　　{
　　　int m=1;
　　　fn(m);
　　}
　（3）分析如下程序输出结果：
　　#include "iostream.h"
　　fun(int a,int b,int c)
　　{
　　　c=a*b;
　　}
　　void main()
　　{
　　　int c;
　　　fun(2,3,c);
　　　cout<<"c="<<c<<endl;
　　}
　(4). 分析如下程序输出结果：
　　#include "iostream.h"
　　void outputab(int a,int b)
　　{
　　　cout<<"a= "<<a<<" b= "<<b<<endl;
　　　a=100;
　　　b=200;
　　}
　　void main()
　　{
　　　int a=300;
　　　int b=400;
　　　outputab(a,b);
　　　cout<<"a= "<<a<<" b= "<<b<<endl;
　　}

5．为什么要使用函数？函数声明与函数体之间有什么区别？

6．求组合数，编程计算c(m,n)=(m!)/((n!)*(m-n)!)。

7．已知银行的存款利息如下。某人有2000元钱，要存20年，问怎样存才能使20年后得到的本利合计最多（假定银行对定期存款过期部分不付利息）？
　　　　　　0.63% 期限一年
　　　　　　0.66% 期限二年
　月息利率= 0.69% 期限三年
　　　　　　0.75% 期限五年
　　　　　　0.84% 期限八年

8．下面的函数调用语句中，含有的实参个数有多少？
　　Func(rec1,rec2+1,(rec3,rec4));

9．写函数int newint(double x)求x的整数部分。例如：传送给函数参数x的值为3.45623，函数的返回值为3。

10．编程实现，任输入一个正整数num，求1！＋2！＋3！….+num!的和。
答案:

二：简答及编程
1．答：
　num 的作用域为从第__2__行到第__18__行.
　i 的作用域为从第__7__行到第__14__行.
　temp 的作用域为从第__10__行到第__13__行.
　cout 的作用域为从第__1__行到第__18_行.
　func 的作用域为从第__3__行到第__18__行.

2．答：

1 　int sum(int n)

2 　{

3 　　if(n==1)

4 　　　return 1;

5 　　else

6 　　　return n + sum(n-1);

7 　}

3．答：
　（1）、程序的运行结果：25
　（2）、因为程序中需要利用cout对象进行输出，而cout是在C++标准I/O库iostream中定义的类ostream的一个对象。
　（3）、在函数main()中不可以直接调用函数g()，因为g()是静态函数，只在它所在的文件内可见。
　（4）、如果把文件file1.cpp中的两个函数定义的位置换一下，程序不正确，因为C++规定所有使用的变量和函数需要先声明，后使用。在函数f中用到了函数g，所以函数f不能出现在函数g的定义或声明之前。
　（5）、文件file1.cpp中的变量i的作用域从它的定义开始到文件结束。File2.cpp中的变量i的作用域从它的定义开始到main函数结束。

4．答：(1) 25 (2) 6 , 11
　(3) 分析这道题首先要弄清楚两点：1：未赋初值的变量，它的值是什么。2：形参变量的值和实参变量的值的关系。本题在main函数中定义了一个整型变量c,系统为其分配了一个存储单元。此单元中的原有信息并未被清除，这时变量c的值是不确定的"随机数"。调用函数fun时，将实参常量2和3分别传给了形参a和b，实参变量c中的随机值传给了形参变量c。通过函数fun的运算，形参变量c中存放了a*b的运算结果，这一结果并不能反馈给实参变量c。因此在主函数中输出的c值是一个不确定的值。
　(4) 输出结果为：
　a= 300 b= 400
　a= 300 b= 400
　本题只要把握住一点即可：当函数调用的参数传递方式为值传递时，形参变量的值的改变不影响到实参变量。因此在outputab函数内部对变量a、b的赋值并不会对main函数中的a、b的值造成影响。

5．答：使用函数可以将大程序分成许多独立的模块，而且函数能在模块中单独编译并链接。使用函数还可将复杂的过程分解为简单的模块组合。函数声明要给出名称、返回值和参数。函数体中则是程序调用该函数时该函数所需执行的语句。

6．答：
　#include "iostream.h"
　//定义facto函数，在这里facto函数定义在main()函数之前，
　//如果定义在main()函数之后，
　//main()函数在调用facto函数之前需要先对facto函数进行声明
　

8 long facto(int x)

9 　{

10 　　long y;

11 　　for(y=1;x>0;--x)

12 　　　y*=x;

13 　　　return y;

14 　}

16 　void main()

17 　{

18 　　int m,n,temp;

19 　　double cmn;

20 　　cout<<"input m :"<<endl;

21 　　cin>>m;

22 　　cout<<"input n :"<<endl;

23 　　cin>>n;

25 　　if ( m < n )

26 　　{

27 　　　temp = n;

28 　　　n = m;

29 　　　m = temp;

30 　　}

31 　　cmn=facto(m)/(facto(n)*facto(m-n));

32 　　//三次调用facto函数

33 　　cout<<"the combination is "<<cmn<<endl;

34 　}

7．答：
　　为了得到最多的利息，存入银行的钱应该在到期时马上取出来，然后立刻将原来的本金和利息加起来再作为新的本金存入银行，这样本利不断的滚动直到满20年为止。由于存款的利率不同，所以有很多不同的存款方法（年限）存20年得到的利息也是不一样的。
分析题意：设2000元存20年，其中一年期存了i1次，二年期存了i2次，三年期存了i3次，五年期存了i5次，八年期存了i8次，则到期时存款人应该得到的本利合计应该为：
　　2000*(1+rate1) *(1+rate2) * (1+rate3) * (1+rate5) * (1+rate8) 其中rateN为对应存款年限的利率。根据题义还可以得到以下的限制条件：
　　0<=i8<=2
　　0<=i5<=(20-8*i8)/5
　　0<=i3<=(20-8*i8-5*i5)/3
　　0<=i2<=(20-8*i8-5*i5-3*i3)/2
　　0<=i1<=20-8*i8-5*i5-3*i3-2*i2
　　可以采用穷举法穷举所有的i8、i5、i3、i2、i1的组合，带入求本利的公式，算出本利为最大值时的存款方案。

35 　　#include "iostream.h"

36 　　#include <math.h>

37 　　void main()

38 　　{

39 　　　int i8,i5,i3,i2,i1,n8,n5,n3,n2,n1;

40 　　　//i:存款的年限，n：当前找到的最佳存款方法

41 　　　double max=0,term;

42 　　　for(i8=0;i8<3;i8++)

43 　　　　for(i5=0;i5<=(20-8*i8)/5;i5++)

44 　　　　　for(i3=0;i3<=(20-8*i8-5*i5)/3;i3++)

45 　　　　　　for(i2=0; i2<=(20-8*i8-5*i5-3*i3)/2;i2++)

46 　　　　　　{

47 　　　　　　　i1=20-8*i8-5*i5-3*i3-2*i2;

48 　　　　　　　term=2000.0*pow(1+0.0063*12,(double)i1)

49 　　　　　　　　*pow(1+2*0.0066*12,(double)i2)

50 　　　　　　　　*pow(1+3*0.0069*12,(double)i3)

51 　　　　　　　　*pow(1+5*0.0063*12,(double)i5)

52 　　　　　　　　*pow(1+8*0.0063*12,(double)i8);

53 　　　　　　　if(term>max)

54 　　　　　　　{

55 　　　　　　　　max=term;

56 　　　　　　　　n1=i1;

57 　　　　　　　　n2=i2;

58 　　　　　　　　n3=i3;

59 　　　　　　　　n5=i5;

60 　　　　　　　　n8=i8;

61 　　　　　　　}

62 　　　　　　}

63 　　　　　　cout<<"8 year: "<<n8<<endl;

64 　　　　　　cout<<"5 year: "<<n5<<endl;

65 　　　　　　cout<<"3 year: "<<n3<<endl;

66 　　　　　　cout<<"2 year: "<<n2<<endl;

67 　　　　　　cout<<"1 year: "<<n1<<endl;

68 　　　　　　cout<<"Total: "<<max<<endl;

69 　　}

8．答： C++函数调用的一般形式为：函数名（实参1，实参2……）
　　其中实参可以是常量、变量或者是表达式。本题中容易知道前面的rec1,rec2+1均为实参，前者是一个变量，后者是一个表达式；关键是要正确识别（rec3,rec4），这也是一个表达式--逗号表达式。因为逗号表达式的优先级最低，所以只有用圆括号括起来才可以将他们看成是一个表达式。明确这一点后，就可以清楚地辨别出上述语句共有3个实参。

9．答：
　可以利用强制类型转换方法实现，程序如下：

70 　int newint(double x)

71 　{

72 　　int I;

73 　　I=(int)x;

74 　　return I;

75 　}

10. 答：
　

76 #include "iostream.h"

77 　int fn(int a);

78 　void main()

79 　{

80 　　int s=0;

81 　　cout<<"please putin a num:";

82 　　int num;

83 　　cin>>num;

84 　　for(int i=1;i<=num;i++) s+=fn(i);

85 　　　cout<<"1!+2!+...+num!="<<s<<endl;

86 　}

87 　int fn(int a)

88 　{

89 　　static int b=1;

90 　　b*=a;

91 　　return b;

92 　}

1
第6章
一：选择题
1．要声明一个有10个int型元素的数组，正确的语句是____。
a. int a[10];
b. int a[2,5];
c. int a[];
d. int *a[10];
2．合法的数组初始化语句是____。
a. char a = "string";
b. int a[5] = {0,1,2,3,4,5};
c. int a[] = "string"
d. char a[] = {0,1,2,3,4,5};
3．在下述对C++语言字符数组的描述中，有错误的是____。
a. 字符数组可以存放字符串
b. 字符数组中的字符串可以进行整体输入输出
c. 可以在赋值语句中通过赋值运算符"="对字符数组整体赋值
d. 字符数组的下标从0开始
4．若用数组名作为函数调用时的实参，则实际上传递给形参的是____。
a. 数组首地址
b. 数组的第一个元素值
c. 数组中全部元素的值
d. 数组元素的个数
5．.已知：
　　int i,x[3][3] = {1,2,3,4,5,6,7,8,9};
　　则下面语句的输出结果是____。　　for(i = 0;i < 3;i ++)

2 　　printf("%d ",x[i][2-i]);

a． 1 5 9
b． 1 4 7
c． 3 5 7
d． 3 6 9
6．在C++语言中，引用数组元素时，其数组下标的数据类型允许是____。
a.只能整型常量
b.只能整型表达式
c.整型常量或整型表达式
d.任何类型的表达式
7．以下对二维数组a的正确声明是____。
a.int a[3][]
b.float a(3,4)
c.double a[1][4]
d.float a(3)(4)
8．已知：int[3][4]，则对数组元素引用正确的是____。
a.a[2][4]
b.a[1,3]
c.a[1+1][0]
d.a(2)(1)
9．在C++语言中，二维数组元素在内存中的存放顺序是____。
a.按行存放
b.按列存放
c.由用户自己定义
d.由编译器决定
10．下面程序的运行结果是____。
　　char c[5] = {'a','b','\0','c','\0'};
　　printf("%s",c);
a.'a''b'
b.ab
c.ab c
d.以上三个答案均有错误
答案:

一：选择题：

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

3

二：程序填空题
1．程序读入20个整数，统计非负数个数，并计算非负数之和。　#include <stdio.h>

4 　void main(void)

5 　{

6 　　int i,a[20],s,count;

7 　　s = count = 0;

8 　　for(i = 0;i < 20;i ++)

9 　　　scanf("%d", );

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

11 　　{

12 　　　if(a[i] < 0)

13 　　 ;

14 　　　s += a[i];

15 　　　count ++;

16 　　}

17 　　printf("s = %d\t count = %d\n",s,count);

18 　}

19 2．函数index(char s[],char t[])检查字符串s中是否包含字符串t，若包含，则返回t在s中的开始位置（下标值），否则返回-1。　int index(char s[],char t[])

20 　{

21 　　int i,j,k;

22 　　for(i = 0;s[i] != '\0';i ++)

23 　　{

24 　　　for(j = i,k = 0; &&s[j] == t[k];j ++,k ++);

25 　　　　if( )

26 　　　　　return i;

27 　　}

28 　　return -1;

29 　}

30 3．以下程序将数组中的数据按逆序存放。　#include<stdio.h>

31 　void main()

32 　{

33 　　int a[12],i,j,t;

34 　　for(i=0;i<12;i++) scanf("%d",&a[i]);

35 　　　i=0;j=12;

36 　　while( )

37 　　{ t=a[i]; ; ;i++;j ;}

38 　　　for(i=0;i<12;i++)printf("%3d",a[i]);

39 　　　printf("\n");

40 　}

答案:

二、程序填空

41 　1．① &a[i] ② continue

42 　2．① t[k] != '\0' ②t[k] == '\0'

43 　3．（1）i<j/2 (2) a[i]=a[j-1] (3) a[j-1]=t (4) --

三：编程题
1．编写3×3矩阵转置程序。

2．编程实现两字符串的连接，要求使用字符数组保存字符串(要求不使用库函数)。

3．写统计输入的正文中有多少单词的程序，这里的单词指的是用空白符分隔开的字符串。

4．编写程序实现一个简单的加密器，实现英文字符串的加密。加密规则如下：将字符替换成它后面的第二个字符。比如'a'替换成'c'，'C'替换成'E'，'z'替换成'|'。"Panda"替换成"Rcpfc"。

5．编程实现对分查找。当数组很大时，循环查找很费时。如果程序已对数组进行升序和降序排序，就可用对分查找。对分查找是每一次查找操作都把要检查的数值个数对半分。对查找不到的数，输出－1。
答案:

三、编程题

1．写3×3矩阵转置程序。

44 　#include <iostream.h>

45 　void move (int matrix[3][3])

46 　{

47 　　int i, j, k;

48 　　for(i=0; i<3; i++)

49 　　for (j=0; j<i; j++)

50 　　{

51 　　　k = matrix[i][j];

52 　　　matrix[i][j] = matrix[j][i];

53 　　　matrix[j][i] = k;

54 　　}

55 　}

56 　void main()

57 　{

58 　　int i, j;

59 　　int data[3][3];

60 　　cout << "输入矩阵的元素" << endl;

61 　　for(i=0; i<3; i++)

62 　　　for (j=0; j<3; j++)

63 　　　{

64 　　　　cout << "第" << i+1 << "行第" << j+1

65 　　　　<<"个元素为：";

66 　　　　cin >> data[i][j];

67 　　　}

68 　　cout << "输入的矩阵为：" << endl;

69 　　for(i=0; i<3; i++)

70 　　{

71 　　　for (j=0; j<3; j++)

72 　　　　cout << data[i][j] << " ";

73 　　　　cout << endl;

74 　　}

75 　　move(data);

76 　　cout << "转置后的矩阵为：" << endl;

77 　　for(i=0; i<3; i++)

78 　　{

79 　　　for (j=0; j<3; j++)

80 　　　　cout << data[i][j] << " ";

81 　　　　cout << endl;

82 　　}

83 　}

2. 编程实现两字符串的连接，要求使用字符数组保存字符串(要求不使用库函数)。

84 　#include <iostream.h>

85 　void main()

86 　{

87 　　int i=0,j=0;

88 　　char s1[200],s2[100];

89 　　cout << "请输入第一个字符串：";

90 　　cin >> s1;

91 　　cout << "请输入第二个字符串：";

92 　　cin >>s2;

93 　　while(s1[i])

94 　　　i++;

95 　　while(s2[j])

96 　　　s1[i++] = s2[j++];

97 　　　s1[i] = '\0';

98 　　　cout << "连接后的字符串为：" << s1 << endl;

99 　}

3. 写统计输入的正文中有多少单词的程序，这里的单词指的是用空白符分隔开的字符串。

100 　#include <stdio.h>

101 　void main()

102 　{

103 　　int c,n;

104 　　bool inword;

105 　　n = 0;

106 　　inword = false;

107 　　while((c = getchar()) != EOF)

108 　　　if(c == ' '||c == '\t'||c == '\n')

109 　　　　inword = false;

110 　　　else if(inword == false)

111 　　　{

112 　　　　inword = true;

113 　　　　n ++;

114 　　　}

115 　　printf("There are %d words\n",n);

116 　}

4．参考程序如下：

117 　#include <iostream.h>

118 　const MAX_STR_LENGTH = 100;

119

120 　void main()

121 　{

122 　　char str[MAX_STR_LENGTH];

123

124 　　/* 输入部分 */

125 　　cout<<"Input a string:";

126 　　cin>>str;

127

128 　　/* 加密部分 */

129 　　for(int i = 0; i < MAX_STR_LENGTH; i++)

130 　　{

131 　　　if(str[i] == '\0') break;

132 　　　str[i] = str[i] + 2;

133 　　}

134

135 　　/* 输出部分 */

136 　　cout<<"加密后的字符串为："<<str<<endl;

137 　}

　程序输出结果如下：
　Input a string:China
　加密后的字符串为：Ejkpc

5．答：

138 　#include<iostream.h>

139 　int binary_search(int array[],int value,int size)

140 　{

141 　　int found=0;

142 　　int high=size,low=0,mid;

143 　　mid=(high+low)/2;

144 　　cout<<"Looking for: "<<value<<endl;

145 　　while((!found)&&(high>=low))

146 　　{

147 　　　cout<<"low mid high "<<endl;

148 　　　cout<<low<<" "<<mid<<" "<<high<<endl;

149 　　　if(value==array[mid])

150 　　　　found=1;

151 　　　else if(value<array[mid])

152 　　　　high=mid-1;

153 　　　else

154 　　　　low=mid+1;

155 　　　　mid=(high+low)/2;

156 　　}

157 　　return((found)? mid: -1);

158 　}

159 　void main(void)

160 　{

161 　　int array[100],i;

162 　　for(i=0;i<100;i++)

163 　　array[i]=i;

164 　　cout<<"Result of search: "<<binary_search(array,33,100)<<endl;

165 　　cout<<"Result of search: "<<binary_search(array,76,100)<<endl;

166 　　cout<<"Result of search: "<<binary_search(array,566,100)<<endl;

167 　}

第七章指针和引用

一：选择题
1．下面函数的功能是：（）
　int fun(char *x)
　{
　　char *y=x;
　　while(*y++){};
　　return y-x-1;
　}
a. 求字符串的长度
b. 求字符串存放位置
c. 比较两个字符串的大小
d. 将字符串x连接到字符串y后面
2．若有以下说明和语句，且0<i<10,则（）是对数组元素的错误引用。
　　int a[ ]={1,2,3,4,5,6,7,8,9,0},*p,i;
　　p=a;
a. *(a+i)
b. a[p-a]
c. p+i
d. *(&a)
3．下面程序的输出是：（）
　#include <stdio.h>
　void main( )
　{
　　int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
　　printf("%d", *(p+2));
　}
a. 3
b. 4
c. 1
d. 2
4．若有以下定义和语句，且0<i<10,则对数组元素地址的正确表示是：（）
　　int a[ ]={1,2,3,4,5,6,7,8,9,0},*p,i;
　　p=a;
a. &(a+1)
b. a++
c. *p
d. &p
5．已知：int a,x=1;则下面正确的赋值语句是：（）
a． a=(a[1]+a[2])/2;
b． a=(a[1]+a[2])/2;
c． a=x+2;
d． a="good";
6．已知：int a[]={1,2,3,4,5,6}，*p=a；下面表达式中其值为5的是：（）
a.p+=3;*(p++);
b.p+=5;*p++ ;
c.p+=4;*++p;
d.p+=4;++*p;
7．若有以下语句，且0<=k<6，则正确表示数组元素地址的语句是（）
　　int x[]={1,9,10,7,32,4},*ptr=x,k=1;
a.x++
b.&ptr
c.&ptr[k]
d.&(x+1)
8．若有说明：int i,j=7,*p;p=&i；则与i=j等价的语句是（）
a.i=*p;
b.*p=*&j;
c.i=&j
d.i=**p;
9．设p1和p2是指向同一个int型一维数组的指针变量，k为int型变量，则不能正确执行的语句是（）
a.k=*p1+*p2;
b.p2=k;
c.p1=p2;
d.k=*p1*(*p2);
10．设有以下函数定义，则该函数返回的值是（）
　int * fun(int a)
　{
　　int *t,n;
　　n=a;t=&n;
　　return t;
　}
a.一个不可用的存储单元地址值
b.一个可用的存储单元地址值
c.n中的值
d.形参a中的值
答案:

一：选择题：

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

二：填空题
1、给出以下程序的输出结果是
　#include<stdio.h>
　void main()
　{
　　int *v,b;
　　v=&b; b=100; *v+=b;
　　printf("%d\n",b);
　}
2、说明语句"int (* p)();"的含义是
3、已知函数说明语句：void *fun();则它的含义是
4、已知：int i;char *s="a\045+045\'b"；执行语句"fot(i=0;*s++;i++);"之后，变量i的结果是
5、下面的程序是求两个整数之和，并通过形参传回结果。
　int add(intx,int y,  z)
　{  =x+y;}
6、给出以下程序的输出结果是
　void fun(int *x)
　{ printf("%d\n",++*x)'; }
　main()
　{
　　int a=25;
　　fun(&a);
　}
7、给出以下程序运行的结果
　#include <stdio.h>
　void main( )
　{
　　int a[ ]={1,2,3,4,5};
　　int x, y, *p;
　　p=&a[0];
　　x=*(p+2);
　　y=*(p+4);
　　printf("*p=%d,x=%d,y=%d\n",*p,x,y);
　　return;
　}
8、给出以下程序运行的结果
　#include<iostream.h>
　void callbyval(int a,int b,int c)
　{
　　a=3;b=2;c=1;
　}
　void callbypointer(int* a,int* b,int* c)
　{
　　*a=3;*b=2;*c=1;
　}
　void callbyreference(int& a,int& b,int& c)
　{
　　a=1;b=2;c=3;
　}
　void main()
　{
　　int a=1,b=2,c=3;
　　int& a1=a;
　　int& b1=a;
　　int& c1=a;
　　callbyval(a,b,c);
　　cout<<a<<b<<c<<endl;
　　callbypointer(&a,&b,&c);
　　cout<<a<<b<<c<<endl;
　　callbyreference(a1,b1,c1);
　　cout<<a<<b<<c<<endl;
　}
9、给出以下程序运行的结果
　#include<iostream.h>
　void ast(int x,int y,int *cp,int *dp)
　{
　　*cp=x*y;
　　*dp=x%y;
　}
　void main()
　{
　　int a,b,c,d;
　　a=2; b=3;
　　ast(a,b,&c,&d);
　　cout<<c<<d<<endl;
　}
10、给出以下程序运行的结果
　#include <stdio.h>
　void main( )
　{
　　int a=10,b=0,*pa, *pb;
　　pa=&a; pb=&b;
　　printf("%d,%d\n",a,b);
　　printf("%d,%d\n",*pa,*pb);
　　a=20; b=30;
　　*pa=a++; *pb=b++;
　　printf("%d,%d\n",a,b);
　　printf("%d,%d\n",*pa,*pb);
　　(*pa)++;
　　(*pb)++;
　　printf("%d,%d\n",a,b);
　　printf("%d,%d\n",*pa,*pb);
　}
答案:

二：填空题
　1. 200
　2. p是一个指向函数的指针，该函数的返回值是一个整型
　3. 函数fun的返回值是一个通用型的指针
　4. 8
　　由于for语句就是求字符串的长度，所以可以知道i的结果是8
　5. （1）int * （2）*z
　6. 26
　7. *p=1 x=3 y=5
　8． 123
　　　321
　　　321
　9. 6 2
　10. 10，0
　　　10，0
　　　21，31
　　　21，31
　　　22，32
　　　22，32

三：简答和编程题
1．判断执行下面的语句后，ab的值变为多少
　int *var, ab;
　ab=100;
　var=&ab;
　ab=*var+10;

2．已知指针p的指向下图所示，则表达式*--p的值是多少？（这里，a[0],a[1],a[2]……仅作为连续存储单元的代号，a[0]在低地址，a[1]在高地址）。

3．有定义：double var;那么，
　a) 使指针p可以指向double型变量的定义语句是什么？
　b) 使指针p指向变量var的赋值语句是什么？
　c) 通过指针p给变量var读入数据的scanf函数调用语句是什么？

4．写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

5．编程实现：从键盘输入一任意字符串，然后，输入所要查找字符。存在则返回它第一次在字符串中出现的位置；否则，输出"在字符串中查找不到！" 。并实现对同一字符串，能连续输入所要查找的字符。

6．编程实现：从字符串中删除子字符串。从键盘输入一字符串，然后，输入要删除的子字符串。最后输出删除子串后的新字符串。

答案:

三、问答和编程题

　1．本例定义了两个变量，int型的变量ab和指向int型的指针变量var；语句var=&ab;是将ab的地址赋给了var,在下一条语句中，*var 表示var所指单元的内容，即100。然后，将*var+10赋给了变量ab；那么，这时ab的值应该是110。
　2．根据运算符的优先级，表达式*--p=*(--p)。所以，先执行--p操作，使指针p向低地址方向移动一个存储单元，指向a[1]。然后用运算符"*"取得该地址所存储的数据，即20。

　3．（1）要求把p定义成指向double型的指针变量即可，所以定义语句是：double *p;
　　（2）要使p指向变量var，即将var的地址赋给指针p，赋值语句为：p=&var;
　　（3）用scanf函数把读入的数据赋给变量var的语句是：scanf("%lf",&var);由于（2）中已将var的地址赋给了p，所以该语句等价于scanf("%lf",p);

　4．程序为：
　#include <stdio.h>
　int length(char* a);
　void main( )
　{
　　int len;
　　char str[20];
　　printf("请输入一个字符串：");
　　scanf("%s",str);
　　len=length(str);
　　printf("字符串长度为%d",len);
　　return;
　}
　int length(char* a)/*求字符串长度函数*/
　{
　　char *p;
　　p=a;
　　int n;
　　n=0;

　　while(*p!='\0')
　　{
　　　n++;
　　　p++;
　　}
　　return(n);
　}

　5．程序为：
　#include<iostream.h>
　char *strchr( char *string,int letter)
　{
　　while((*string!=letter)&&(*string))
　　　string++;
　　return string;
　}
　void main()
　{
　　int tt=1;
　　while(tt){
　　　char title[64];
　　　cout<<"请输入一字符串：";
　　　cin>>title;
　　　char *p;
　　　cout<<"请输入你想查找的字符: ";
　　　char ch;
　　　cin>>ch;
　　　p=strchr(title,ch);
　　　if(*p)
　　　　cout<<"所查字符在字符串中第一次出现的位置为: "<<p-title<<endl;
　　　else
　　　　cout<<"在字符串中没有所查字符！"<<endl;
　　　　cout<<"do u cunteue!1--counte,0--exit"<<endl;
　　　　cin>>tt;
　　　}
　}

　6．程序为：
　#include<string.h>
　#include<iostream.h>
　char* strstr_rep(char *source,char *old)
　{
　　int i,j,k,loc=-1;
　　for(i=0;source&&(loc==-1);i++)
　　　for(j=i,k=0;source[j]==old[k];j++,k++)
　　　　if(!old[k+1])
　　　　　loc=i;
　　　　if(loc!=-1)
　　　　{
　　　　　for(k=0;old[k];k++);
　　　　　for(j=loc,i=loc+k;source;j++,i++)
　　　　　　source[j]=source;
　　　　　　source=NULL;
　　　　}
　　　　return(source);
　}
　void main()
　{
　　char a[50];
　　cout<<"请输入一字符串：";
　　cin>>a;
　　char b[30];
　　cout<<"请输入上字符串的一个子串：";
　　cin>>b;
　　cout<<strstr_rep(a,b)<<endl;
　}

第8张结构与链表

一：选择题
1．当说明一个结构变量时，系统分配给它的内存是（）
a. 各成语所需内存量的总和
b. 结构中第一个成员所需内存量
c. 成员中占内存量最大的成员所需的容量
d. 结构中最后一个成员所需内存量

2．下面四个运算符中，优先级最低的是（）
a. ()
b. ．
c. ->
d. ++

3．选择下面程序的运行结果。（）
　#include <stdio.h>
　struct cmplx
　{
　　int x;
　　int y;
　}cnum[2]={1,3,2,7};
　int main( )
　{
　　printf("%d\n",cnum[0].y*cnum[1].x);
　　return 0;
　}
a. 0
b. 1
c. 3
d. 6

4．已知：
　struct sk
　{ int a;
　　float b;
　}data,*p;
　若有p=&data，则对data中的成员a的正确引用是（）
a. (*p).data.a
b. (*p).a
c. p->data.a
d. p.data.a

5．设有以下定义和语句，
　struct student
　{ int num,age;
　};
　struct student stu[3]={{2001,20},{2001,21},{2001,19}};
　struct studeng *p=stu;
　则以下错误的引用是（）
a．(p++)->num
b．p++
c．(*p).num
d．p=&stu.age

6．设有以下说明语句，
　stuct ex
　{ int x; float y; char z;}example;
　则下面的叙述中不正确的是（）
a.struct是结构类型的关键字
b.example是用户定义的结构类型名
c.x,y,z都是结构成员名
d.struct ex是用户定义的结构类型

7．有以下定义和语句，则以下引用形式非法的是（）
　struct s
　{ int i1;
　　s *i2,*i0;
　};
　static s a[3]={2,&a[1],NULL,4,&a[2],&a[0],6,NULL,&a[1]};
　static s *ptr;
　ptr=a;
a.ptr->i1++
b.*ptr->i2
c.++ptr->i0
d.*ptr->i1

8．设有以下语句：
　struct st
　{ int n;
　　st *next;
　};
　static st a[3]={5,&a[1],7,&a[2],9,NULL},*p;
　p=&a[0];
　则以下表达式值为6的是（）
a.p++->n
b.++p->n
c.(*p).n++
d.p->n++

9．在对typedef的叙述中错误的是( )
a.用typedef可以定义各种类型名，但不能用来定义变量
b.用typedef可以增加新类型
c.用typedef只是将已存在的类型用一个新的标识符来代表
d.使用typedef有利于程序的通用和移植

10．选择下面程序的运行结果是（）
　#include <iostream.h>
　struct stu
　{ int num;
　　char name[10];
　　int age;
　};
　void fun(stu *p)
　{ cout<<(*p).name<<endl; }
　main()
　{ stu students[3]={{9801,"Zhang",20},
　　{9802,"Long",21},
　　{9803,"Xue",19}};
　　fun(students+2);
　}
a.Zhang
b.Xue
c.Long
d.18

答案:

一：选择题：

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

二：填空题
1、有以下说明和定义语句，请给结构变量w赋初值，使w.a的值为7，w.b指向a数组的首地址。
　　double a[5];
　　struct exp{ int a; double *b;}w={  ,  };
2、下面程序的输出是  .
　struct two
　{ int x, *y ; }*p;
　　int a[8]={1,2,3,4,5,6,7,8};
　　two b[4]={100,&a[1],200,&a[3],10,&a[5],20,&a[7]};
　main()
　{ p=b;
　　printf("%d\n",++(p->x));
　}
3、有以下定义和语句，则表达式++ptr->i的值为  .
　struct s
　{ int i;
　　int *j;
　};
　int a[]={1,2,3,4,5,6};
　s a[3]={5,&a[1],7,&a[2],9,'\0'},*ptr;
　void main()
　{ …
　　ptr=&a[0];
　　…
　}
4、以下程序用以输出结构变量ex所占存储单元的字节数，请填空。
　#include<stdio.h>
　struct st
　{ char name[20]; double score; };
　void main()
　{ st ex;
　　printf("ex size:%d\n",  );
　}
5、已知：
　struct
　{
　　int x,y;
　}s[2]={ {1,2},{3,4} },*p=s;
　则表达式++p->x的值为  ，表达式（++p）->x的值为
6、为了建立如下结点的链表，结点的正确描述形式是：

　struct node
　{ int data;
　  ;
　}
7、用typedef定义整型一维数组：
　　typedef int ARRAY[10];
　　则对整型数组a[10]、b[10]、c[10]可以定义为  .
8、下面程序的执行结果是  .
　#include <stdio.h>
　struct n_c
　{
　　int x;
　　char c;
　};
　main( )
　{
　　struct n_c a={10,'x'};
　　func(a);
　　printf("%d%c",a.x,a.c);
　　return 0;
　}
　void func(struct n_c b)
　{
　　b.x=20;
　　b.c='y';
　}

二：填空题
　1. (1) 7 (2) a
　2. 101
　3. 6
　4. sizeof(struct st)
　5. (1) 2 (2) 3
　6. node *next
　7. ARRAY a,b,c;
　8. 10 x

1

三：简答和编程题
1．结构类型数据有什么特性，在什么场合下使用结构处理数据？

2．定义结构变量和对结构变量进行初始化的时候应该注意些什么问题？

3．链表是怎样的一种数据结构，它与数组有什么不同？链表的插入和删除是怎样实现的？

4．阅读下面的程序，分析结构在其中的定义，使用，思考程序的输出结果。
　#include <iostream.h>

2 　struct clock

3 　{

4 　　int hour;

5 　　int minute;

6 　　int second;

7 　}aClock;

8 　void updata()

9 　{

10 　　aClock.second++;

11 　　if(aClock.second==60)

12 　　{

13 　　　aClock.second=0;

14 　　　aClock.minute++;

15 　　}

16 　　if(aClock.minute==60)

17 　　{

18 　　　aClock.minute=0;

19 　　　aClock.hour++;

20 　　}

21 　　if(aClock.hour==24)

22 　　　aClock.hour=0;

23 　}

24 　void display()

25 　{

26 　　cout<<aClock.hour<<":"<<aClock.minute<<":"<<aClock.second<<endl;

27 　}

28 　void main()

29 　{

30 　　aClock.hour=aClock.minute=aClock.second=0;

31 　　for(int i=0;i<10000;i++)

32 　　{

33 　　　updata();

34 　　　display();

35 　　}

36 　}

5．编写一个函数day，该函数使用data结构作为参数，函数返回某日是这年的第几天。

6．有4个学生，每个学生包括学号，姓名，成绩。要求找出成绩最高者的姓名和成绩。

三、简答与编程题

　1．结构类型是将一组数据类型定义为一个新的数据类型，常常有特殊的含义，用于在程序中表示和处理类似于学生纪录，日期等复杂的数据。因此，结构类型数据与一般的基本数据类型相比，它更加能够满足程序对处理复杂数据的需要。当程序中需要对一组不同类型的数据作为整体进行处理的时候，就要用到结构类型了。

　2．结构类型在使用之前必须先进行定义，所以，定义结构变量必须出现在结构定义之后。可以在定义结构变量的时候初始化，也可以在后面的程序中通过整体赋值或对成员赋值进行初始化。对结构变量初始化的时候必须要符合结构类型定义的成员顺序及其类型。另外，如果一个结构类型内又嵌套了另一个结构类型，那么在初始化的时候，要依次对内部的结构变量各成员进行赋值。

　3．链表是一种重要的数据结构，是一种动态分配内存的结构。相对来说，用数组不能实现动态存储。当用数组来进行数据存储时，必须事先确定固定的长度；而链表是一组结点的序列，每个结点是由系统存储到不同的地址空间的。它们之间的连接是由指针实现的。插入和删除一个结点是非常容易的，而且链表比数组能表示更复杂的数据类型。
插入和删除一个结点的基本方法就是，首先对链表进行遍历，找到需要插入的地方或需要删除的结点，然后改变相邻结点指针的连接关系就可以了。

　4．该程序实现了一个时钟的显示。首先定义了一个结构clock，包括三个整形成员hour,minute,second来表示时间，并且定义了clock型的变量aClock。在主程序中，首先对aClock各成员赋值，然后循环10000次，每次循环调用一次子函数updata()和display()，用来计时和显示时间。
　　程序的输出结果是：
　　0：0：1
　　0：0：2
　　0：0：3
　　0：0：4
　　.
　　.
　　.
　　0：0：59
　　0：1：0
　　0：1：1
　　.
　　.
　　.
　　0：59：59
　　1：0：0
　　.
　　.
　　.
　　2：46：40

　5．答：

37 　#include <iostream.h>

38 　struct data

39 　{

40 　　int maths;

41 　　int days;

42 　}

43 　void day(data dd)

44 　{

45 　　int dayth;

46 　　switch(dd.maths)

47 　　{

48 　　　case 1:

49 　　　　dayth=31;

50 　　　　break;

51 　　　case 2:

52 　　　　dayth=31+28;

53 　　　　break;

54 　　　case 3:

55 　　　　dayth=31+28+31;

56 　　　　break;

57 　　　case 4:

58 　　　　dayth=31+28+31+30;

59 　　　　break;

60 　　　case 5:

61 　　　　dayth=31+28+31+30+31;

62 　　　　break;

63 　　　case 6:

64 　　　　dayth=31+28+31+30+31+30;

65 　　　　break;

66 　　　case 7:

67 　　　　dayth=31+28+31+30+31+30+31;

68 　　　　break;

69 　　　case 8:

70 　　　　dayth=31+28+31+30+31+30+31+31;

71 　　　　break;

72 　　　case 9:

73 　　　　dayth=31+28+31+30+31+30+31+31+30;

74 　　　　break;

75 　　　case 10:

76 　　　　dayth=31+28+31+30+31+30+31+31+30+31;

77 　　　　break;

78 　　　case 11:

79 　　　　dayth=31+28+31+30+31+30+31+31+30+31+30;

80 　　　　break;

81 　　　case 12:

82 　　　　dayth=31+28+31+30+31+30+31+31+30+31+30+31;

83 　　　　break;

84 　　}

85 　　dayth=dayth+dd.days;

86 　　cout<<"the day of the date is:"<<dayth;

87 　}

88 　int main()

89 　{

90 　　data d;

91 　　cout<<"input the maths:"<<endl;

92 　　cin<<d.maths;

93 　　cout<<"input the date:"<<endl;

94 　　cin<<d.days;

95 　　day(d);

96 　　return 0;

97 　}

6. 分析：可以把学生定义为结构类型，包括学号，姓名和成绩等成员。
　程序为：

98 　#include <stdio.h>

99 　int main( )

100 　{

101 　　struct student

102 　　{

103 　　　int num;

104 　　　char name[20];

105 　　　float score;

106 　　};

107 　　struct student stu[4];

108 　　struct student *p;

109 　　int i,temp=0;

110 　　float max;

111 　　for(i=0;i<4;i++)

112 　　　scanf("%d%s%f",&stu.num,&stu.name,&stu.score);

113 　　for(max=stu[0].score,i=1;i<4;i++)

114 　　　if (stu.score>max)

115 　　　{ max=stu.score; temp=i; }

116 　　　p=stu+temp;

117 　　printf("\n The maximum score:\n");

118 　　printf("No.:%d\n name:%s\n score:%4.1f\n",p->num, p->name, p->score);

119 　　return 0;

120 　}

第9章编译预处理

一：选择题

1．从下面的选项中选出正确的答案在宏定义：#define MAXINT 324中，宏名MAXINT代替的是：
a. 实型数
b. 整型数
c. 常量
d. 一串字符
2．分析下列叙述是正确的：
a. 在带参的宏定义中，形式参数是变量。
b. 在带参的宏定义中，形式参数是变量。
c. 宏替换不占用运行时间。
d. 在带参的宏定义中，要定义其形式参数的类型。
3．一个C++程序开始执行的位置是：
a. 程序开头
b. 预编译
c. main函数
d. 以上答案都不正确
4．下列叙述正确的是：
a．一个程序中可以有多个#include命令行
b．在#include命令行中，用双引号和用尖括号将被包含的文件名括起来没有区别
c． #include命令行只能放在程序开始位置
d． #include命令后也必须以分号结束
5．以下叙述不正确的是：
a． C++语言中，编译预处理命令行总以"#"开头
b．编译预处理命令行可以根据需要出现在程序的任何一行的开始位置
c． C++编译中的编译预处理可以看作一行C++语句
d． C++中的预处理是在程序运行之前进行的
6．预处理命令在程序中都是以以下哪个符号开头的。
a.*
b.#
c.：
d./
7．文件包含中被包含的文件的扩展名。
a.必须为 .h
b.不能用 .h
c.必须是 .c
d.不一定是 .h
8．带参数的宏定义中,程序中引用宏定义的参数是。
a.只能是常量
b.只能是整型量
c.只能是整型表达式
d.可以是任意表达式
9．在宏定义＃define PI 3.1415926中，用宏名PI代替是一个。
a.单精度数
b.双精度数
c.常量
d.字符串
10．以下对头文件叙述不正确的是。
a. 头文件可以自己编写。
b. 头文件可以系统提供。
c. 既可以自己编写，也可以系统提供。
d. 以上都不对。

答案:

一：选择题：

　(1) d
　(2) c
　(3) c
　(4) a
　(5) c
　(6) b
　(7) d
　(8) d
　(9) d
　(10) d

二、简答与编程题：

1．写出下面程序的输出结果：
　　#include "iostream.h"
　　#define PR(a) cout<<a
　　#define PRINT1(a) PR(a);cout<<endl
　　#define PRINT2(a,b) PR(a);PRINT1(b)
　　void main()
　　{
　　　int k;
　　　for(k=0;k<=100;k+=50)
　　　　PRINT2(k,k+12.4);
　　}

2．写出下面程序的输出结果：
　　#include<iostream.h>
　　#define CIR(r) r*r
　　void main()
　　{
　　　int x=1;
　　　int y=2;
　　　int z;
　　　z=CIR(x+y);
　　　cout<<z<<endl;
　　}

3．写出下面程序的输出结果：
　　#include <iostream.h>
　　#define TEST
　　void main()
　　{
　　　int x=0;
　　　int y=1;
　　　int z=1;
　　　#ifdef TEST
　　　cout<<x<<y;
　　　#endif
　　　cout<<z;
　　}

4．下列程序执行时输入5，给出运行结果。
　　#include<iostream.h>
　　#define N -2
　　void main()
　　{
　　　int n;
　　　cin>>n;
　　　#if N>0
　　　cout<<"1"<<endl;
　　　#else
　　　cout<<"-1"<<endl;
　　　#endif
　　　#ifdef EOF
　　　cout<<EOF<<endl;
　　　#endif
　　}

5．设有宏定义如下：
　#define N 3
　#define Y(n) ((N+1)*n)
　则执行语句：z=2*(N+Y(5+1));后，z的值是多少?

6．编写一个宏定义DIGIT(c)，用来判断c是不是数字字符，如果是得1，不是得0。

二、简答与编程题：
　1、答：在本题中，程序中共定义了三个带参数的宏，且后两个宏定义的替换文本中又包含前面定义过的宏；程序中的输出语句不仅是用宏名表示的，而且还放在了循环语句中。事实上，只要按照宏替换的原则将宏名一步步展开，分析出结果并不困难。下面依次给出语句PRINT2(k,k+12.4);的宏替换结果：
　　首先将宏PRINT2用对应的"替换文本"替换，并用实参k替换形参a，用实参k+12.4替换形参b，得到
　　PR(k);PRINT1(k+12.4);
　　替换后的语句中又出现了两个宏PR和PRINT1。若先将PRINT1展开，以上语句变为：
　　PR(k);PR(k+12.4);cout<<endl;
　　最后将PR宏展开，得到：
　　cout<<k;cout<<k+12.4;cout<<endl;
　　这时可以清楚的看出：原本一条语句PRINT2(k,k+12.4);经宏替换后变成了三条语句。由于for循环中没有使用复合语句，所以只有第一条语句cout<<k;属于for循环体，后两条语句要等执行完循环体后才执行。
　　根据for语句中的条件可知，循环体将执行3次，k的取值依次为0、50、100，每输出完一项并不换行，而是用一个逗号分隔。退出for循环后，k的值为150。执行语句cout<<k+12.4;时，输出162.4，然后执行语句cout<<endl;实现换行，因此本题的答案应该是：
　　050100162.4

　2、答：本题输出的结果是变量z的值，也就是要求出对CIR(x+y)进行宏替换后表达式的值。按照宏定义应该用替换文本r*r代替宏，并用实参x+y代替形参r，从而替换为：x+y*x+y。再将x=1,y=2代入表达式得到1+2*1+2，计算所得的结果为5，显然变量z的值，也就是本程序输出的结果为5。
　　通过本题我们应该体会到：宏替换是纯粹的文本串的替换。在定义替换文本时，形参r两侧没有加括号，替换后实参x+y两侧也不能有括号。从而先进行y*x的运算，而不是(1+2)*(1+2)的求(x+y)的平方的运算。因此，在进行宏定义的时候要注意括号的使用。

　3、答：输出结果为"011"

　4、答：
　　－1
　　－1

　5、答：赋值语句z=2*(N+Y(5+1));中引用了两个宏名。为了求得z的值，必须分析宏替换后的结果。按照宏替换的原则，首先将带参的宏Y(5+1)展开：用"替换文本"来替换宏，用实参5+1代替宏定义中的形参n(注意区分大小写字母)。从而有语句：
　　z=2*(3+((3+1)*5+1));
　　赋值号右侧的表达式计算结果为48，即z的值为48。

　6、答：判断是不是字符可以用ASCII码值进行关系比较，并且数字字符'0'-'9'的ASCII是有序排列的，因此判断是不是数字字符可以转化为判断是否在'0'到'9'的区间内。
　　定义如下：
　　#define DIGIT(c) (((c)>='0')&&((c)<='9')?1:0

第10章类与对象

一：选择题
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．如果编程者没有显式定义构造函数（包括复制构造函数），C++编译器就___。
a.出现编译错误
b.没有构造函数
c.必须显示定义
d.隐式定义缺省的构造函数
8．静态成员函数仅能访问___。
a.静态的数据成员
b.非静态的成员函数
c.非静态的数据成员
d.以上都不对
9．静态数据成员的初始化必须在___。
a.类内
b.类外
c.在构造函数内
d.静态成员函数内
10．友元作用___。
a.提高程序的运用效率
b.加强类的封装性
c.实现数据的隐藏性
d.增加成员函数的种类

答案：

一：选择题：

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

二：判断题
1．使用关键字class定义的类中缺省的访问权限是私有（private）的。
2．构造函数和析构函数都不能重载。
3．说明或定义对象时，类名前不需加class关键字。
4．可以在类的构造函数中对静态数据成员进行初始化。
5． rotected和private区别在于：protected成员可以被派生类访问，而private成员则不能被派生类访问。

二：判断题
　1. 对
　2. 错
　3. 对
　4. 错
　5. 对

三、编程实现
1．创建一个类，具有public、private和protected数据成员和函数成员。创建该类的一个对象，看看试图存取所有的类成员时会得到一些什么信息。编写一个全局friend函数来访问该类的私有数据成员。

2．创建一个没有任何构造函数的类，显示可以用缺省的构造函数创建对象。然后为该类创建一个非缺省的构造函数（带一个参数），试着在编译一次，解释发生的现象。

3．建立一个类，该类包含const成员函数和非const成员函数，然后建立这个类的const和非const对象。分别为这两种类型的对象调用两种成员函数，解释发生的现象。

4．利用静态数据成员的概念，编写一个类，可以统计目前存在多少个该类的对象。

5．列举调用复制构造函数的三种情况。

6．编写几何点（二维平面上）的类Point，包括位置属性（二维坐标x，y），成员函数包括点的位置获取函数GetX（）和GetY（），点的位置设置函数SetX（）和SetY（），和点的位置移动函数MoveTo（）以及点的信息打印函数Display（）。

7．编写几何图形圆的类Circle，包括两个属性：圆心O（用上题中的Point类实现）和半径R。成员函数包括：圆心位置获取函数GetO（）和半径获取函数GetR（）；半径位置设置函数SetR（）；圆的位置移动函数MoveTo（）；圆的半径设置函数SetR（）；以及圆的信息打印函数Display（）。

8．编写复数类Complex。实现各种常用构造函数，实现整数、实数向复数的转化函数，实现整数、实数和复数以及复数之间的加、减、乘、除各种运算，实现＝＝、！＝等逻辑运算。

1 三、编程实现

3 　1. 参考程序如下：

4 　#include <iostream.h>

5 　class C

6 　{

7 　private:

8 　　int private_data;

9 　　void private_method()

10 　　{

11 　　　cout<<"I am private method"<<endl;

12 　　}

13 　protected:

14 　　int protected_data;

15 　　void protected_method()

16 　　{

17 　　　cout<<"I am protected method"<<endl;

18 　　}

19 　public:

20 　　int public_data;

21 　　void public_method()

22 　　{

23 　　　cout<<"I am public method"<<endl;

24 　　}

25 　C()

26 　{

27 　　private_data = 0;

28 　　protected_data = 1;

29 　　public_data = 2;

30 　}

32 　friend void friendFunction(C c);

33 　};

34 　void friendFunction(C c)

35 　{

36 　　c.private_method();

37 　　c.protected_method();

38 　　cout<<"c.private_data = "<<c.private_data<<endl;

39 　　cout<<"c.protected_data = "<<c.protected_data<<endl;

40 　}

41 　void main()

42 　{

43 　　C c;

44 　　// Error: c.private_method();

45 　　// Error: c.protected_method;

46 　　// Error: cout<<c.private_data<<endl;

47 　　// Error: cout<<c.protected_data<<endl;

48 　　friendFunction(c);

49 　}

51 　　说明：上述main（）函数中注释起来的语句是普通函数访问对象c的private成员和proctected成员，它们，不能通过编译器。例如，Visual C＋＋6.0 编译器将产生这样的出错信息：

52 　　cannot access private member declared in class 'C'

53 或者

54 　　cannot access protected member declared in class 'C'

55 然而，利用声明为类C的友元的friendFunction()函数，就可以实现对于私有成员的访问。

56 　　程序输出结果如下：

57 　　I am private method

58 　　I am protected method

59 　　c.private_data = 0

60 　　c.protected_data = 1

62 　2．参考程序如下：

63 　#include <iostream.h>

64 　class C

65 　{

66 　public:

67 　　//C(char a){}

68 　　void Display()

69 　　{

70 　　　cout<<"hello world!"<<endl;

71 　　}

72 　};

74 　void main()

75 　{

76 　　C c;

77 　　c.Display();

78 　}

79 　　说明：上述程序可以编译通过，程序输出结果如下：

80 　　hello world!

81 　　说明main（）函数中C c;代码行调用了类C的缺省调用函数。

82 　　但是，如果我们将注释行的注释去掉，实际上就是给类C加入一个带有一个参数的构造函数，则编译不能通过，Visual C＋＋ 6.0编译器显示下列出错信息：

83 　　no appropriate default constructor available

84 　　因为我们已经建立了一个构造函数，所以编译器不再建立缺省的构造函数，C c;代码行也就不能再通过编译了。

86 3．参考程序如下：

87 　#include <iostream.h>

89 　class C

90 　{

91 　private:

92 　　int i;

93 　public:

95 　　C():i(0){}

96 　　~C(){}

98 　　int getI()const

99 　　{

100 　　　return this->i;

101 　　}

102

103 　　void setI(int i)

104 　　{

105 　　　this->i = i;

106 　　}

107 　};

108

109 　void main()

110 　{

111 　　C noConstC;

112 　　const C constC;

113

114 　　cout<<noConstC.getI()<<endl;

115 　　noConstC.setI(1);

116 　　cout<<noConstC.getI()<<endl;

117

118 　　cout<<constC.getI()<<endl;

119 　　// Error: constC.setI(1);

120 　　cout<<constC.getI()<<endl;

121 　}

122 　　说明：上述代码编译可以通过，如果加入注释行，则程序不能编译通过， Visual C＋＋ 6.0编译器显示下面的信息：

123 　　cannot convert 'this' pointer from 'const class C' to 'class C &'

124 　　这是由于新加入的代码涉及到常量对象调用非cosnt成员函数引起的。

125 　　下表显示了变量和函数的调用关系： const成员函数非const成员函数

126 const对象可以调用不可以调用

127 非const对象可以调用可以调用

128

129

130 　4．参考程序如下：

131 　#include <iostream.h>

132

133 　class ObjectCounter

134 　{

135 　public:

136 　　ObjectCounter(char ch)

137 　　{

138 　　　counter++;

139 　　　name = ch;

140 　　　cout<<"Object "<<name<<" comes into being"<<endl;

141 　　}

142 　　~ObjectCounter()

143 　　{

144 　　　counter--;

145 　　　cout<<"Object "<<name<<" dies out"<<endl;

146 　　}

147 　　static int counter;

148 　　void printCounter()

149 　　{

150 　　　cout<<name<<" say: Now CLASS ObjectCounter has "<<counter<<" objects altogether!"<<endl;

151 　　}

152 　private:

153 　char name;

154 　};

155 　int ObjectCounter::counter = 0;

156 　void main()

157 　{

158 　　ObjectCounter* oc1;

159 　　ObjectCounter* oc2;

160 　　ObjectCounter* oc3;

161

162 　　oc1 = new ObjectCounter('1');

163 　　oc1->printCounter();

164 　　oc2 = new ObjectCounter('2');

165 　　oc1->printCounter();

166 　　oc2->printCounter();

167 　　oc3 = new ObjectCounter('3');

168 　　oc1->printCounter();

169 　　oc2->printCounter();

170 　　oc3->printCounter();

171

172 　　delete oc3;

173 　　oc1->printCounter();

174 　　oc2->printCounter();

175 　　delete oc2;

176 　　oc1->printCounter();

177 　　delete oc1;

178 　}

179 　说明：程序输出结果如下：

180 　Object 1 comes into being

181 　1 say: Now CLASS ObjectCounter has 1 objects altogether!

182 　Object 2 comes into being

183 　1 say: Now CLASS ObjectCounter has 2 objects altogether!

184 　2 say: Now CLASS ObjectCounter has 2 objects altogether!

185 　Object 3 comes into being

186 　1 say: Now CLASS ObjectCounter has 3 objects altogether!

187 　2 say: Now CLASS ObjectCounter has 3 objects altogether!

188 　3 say: Now CLASS ObjectCounter has 3 objects altogether!

189 　Object 3 dies out

190 　1 say: Now CLASS ObjectCounter has 2 objects altogether!

191 　2 say: Now CLASS ObjectCounter has 2 objects altogether!

192 　Object 2 dies out

193 　1 say: Now CLASS ObjectCounter has 1 objects altogether!

194 　Object 1 dies out

195

196 　5．解答：

197 　构造函数被调用通常发生在以下三种情况，第一种情况就是用一个对象初始化另一个对象时，比如c2 = c1；第二种情况是当对象作函数参数，实参传给形参时；第三种情况是程序运行过程中创建其它临时对象时。

198

199 　6．参考程序如下：

200 　#include <iostream.h>

201

202 　class Point

203 　{

204 　private:

205 　　int X;

206 　　int Y;

207 　public:

208 　　Point(int X, int Y)

209 　　{

210 　　　this->X = X;

211 　　　this->Y = Y;

212 　　}

213 　　Point()

214 　　{

215 　　　this->X = 0;

216 　　　this->Y = 0;

217 　　}

218 　　~Point(){}

219

220 　　int GetX()const

221 　　{

222 　　　return this->X;

223 　　}

224 　　int GetY()const

225 　　{

226 　　　return this->Y;

227 　　}

228

229 　　void SetX(int X)

230 　　{

231 　　　this->X = X;

232 　　}

233 　　void SetY(int Y)

234 　　{

235 　　　this->Y = Y;

236 　　}

237

238 　　void MoveTo(int X, int Y)

239 　　{

240 　　　SetX(X);

241 　　　SetY(Y);

242 　　}

243 　　void Display()const

244 　　{

245 　　　cout<<"X: "<<GetX()<<endl;

246 　　　cout<<"Y: "<<GetY()<<endl;

247 　　}

248 　};

249

250 　void main()

251 　{

252 　　Point p(100,100);

253

254 　　p.Display();

255

256 　　p.MoveTo(200,200);

257

258 　　cout<<"after moving"<<endl;

259

260 　　p.Display();

261 　}

262

263 　程序输出结果如下：

264 　X: 100

265 　Y: 100

266 　after moving

267 　X: 200

268 　Y: 200

269

270 　7．参考程序如下：

271 　#include <iostream.h>

272

273 　class Point

274 　{

275 　private:

276 　　int X;

277 　　int Y;

278 　public:

279 　　Point(int X, int Y)

280 　　{

281 　　　this->X = X;

282 　　　this->Y = Y;

283 　　}

284 　　Point()

285 　　{

286 　　　this->X = 0;

287 　　　this->Y = 0;

288 　　}

289 　　~Point(){}

290

291 　　int GetX()const

292 　　{

293 　　　return this->X;

294 　　}

295 　　int GetY()const

296 　　{

297 　　　return this->Y;

298 　　}

299

300 　　void SetX(int X)

301 　　{

302 　　　this->X = X;

303 　　}

304 　　void SetY(int Y)

305 　　{

306 　　　this->Y = Y;

307 　　}

308

309 　　void MoveTo(int X, int Y)

310 　　{

311 　　　SetX(X);

312 　　　SetY(Y);

313 　　}

314 　　void Display()const

315 　　{

316 　　　cout<<"X: "<<GetX()<<endl;

317 　　　cout<<"Y: "<<GetY()<<endl;

318 　　}

319 　};

320

321 　class Circle

322 　{

323 　private:

324 　　Point O;

325 　　int R;

326 　public:

327 　　Circle(Point& p, int R)

328 　　{

329 　　　O.MoveTo(p.GetX(),p.GetY());

330

331 　　　this->R = R;

332 　　}

333 　　~Circle(){}

334

335 　　Point GetO()const

336 　　{

337 　　　return this->O;

338 　　}

339 　　int GetR()const

340 　　{

341 　　　return this->R;

342 　　}

343

344 　　void MoveTo(Point& p)

345 　　{

346 　　　O.MoveTo(p.GetX(), p.GetY());

347 　　}

348 　　void SetR(int R)

349 　　{

350 　　　this->R = R;

351 　　}

352

353 　　void Display()

354 　　{

355 　　　cout<<"Circle: ("<<O.GetX()<<","<<O.GetY()<<"),"<<R<<endl;

356 　　}

357 　};

358

359 　void main()

360 　{

361 　　Point p(100,100);

362 　　Point p2(200,200);

363 　　Circle c(p, 100);

364 　　c.Display();

365

366 　　c.MoveTo(p2);

367 　　cout<<"after moving"<<endl;

368 　　c.Display();

369

370 　　c.SetR(200);

371 　　cout<<"after altering r"<<endl;

372 　　c.Display();

373 　}

374 　程序输出结果如下：

375 　Circle: (100,100),100

376 　after moving

377 　Circle: (200,200),100

378 　after altering r

379 　Circle: (200,200),200

380

381 　8．参考程序如下：

382 　#include <iostream.h>

383

384 　class Complex

385 　{

386 　　double R;

387 　　double I;

388 　public:

389 　　Complex(double R = 0.0, double I = 0.0)

390 　　{

391 　　　this->R = R;

392 　　　this->I = I;

393 　　}

394 　　~Complex(){}

395

396 　　/* copy constructor function */

397 　　Complex(const Complex& c)

398 　　{

399 　　　this->R = c.R;

400 　　　this->I = c.I;

401 　　}

402

403 　　/* (+ - * /) */

404 　　friend const Complex operator+(const Complex& a, const Complex& b);

405 　　friend const Complex operator-(const Complex& a, const Complex& b);

406 　　friend const Complex operator*(const Complex& a, const Complex& b);

407 　　friend const Complex operator/(const Complex& a, const Complex& b);

408

409 　　/* - */

410 　　friend const Complex operator-(const Complex& a);

411

412 　　/* == != */

413 　　friend bool operator==(const Complex& a, const Complex& b);

414 　　friend bool operator!=(const Complex& a, const Complex& b);

415

416 　　friend ostream& operator<<(ostream& out, const Complex& c);

417 　};

418

419 　/* + overloading */

420 　const Complex operator +(const Complex& a, const Complex& b)

421 　{

422 　　Complex c;

423

424 　　c.R = a.R + b.R;

425 　　c.I = a.I + b.I;

426

427 　　return c;

428 　}

429

430 　/* - overloading */

431 　const Complex operator -(const Complex& a, const Complex& b)

432 　{

433 　　Complex c;

434

435 　　c.R = a.R - b.R;

436 　　c.I = a.I - b.I;

437

438 　　return c;

439 　}

440 　/* * overloading */

441 　const Complex operator *(const Complex& a, const Complex& b)

442 　{

443 　　Complex c;

444

445 　　c.R = (a.R * b.R) - (a.I * b.I);

446 　　c.I = (a.R * b.I) + (a.I * b.R);

447

448 　　return c;

449 　}

450 　/* / overloading */

451 　const Complex operator /(const Complex& a, const Complex& b)

452 　{

453 　　Complex c;

454 　　double temp;

455

456 　　temp = b.R*b.R + b.I*b.I;

457

458 　　if(temp == 0)

459 　　{

460 　　　c.R = 0; c.I = 0;

461 　　　return c;

462 　　}

463

464 　　c.R = (a.R*b.R + a.I*b.I) / temp;

465 　　c.I = (a.I*b.R - a.R*b.I) / temp;

466

467 　　return c;

468 　}

469

470 　/* - overloading */

471 　const Complex operator -(const Complex& a)

472 　{

473 　　Complex c;

474

475 　　c.R = - a.R;

476 　　c.I = - a.I;

477

478 　　return c;

479 　}

480

481 　/* == overloading */

482 　bool operator==(const Complex& a, const Complex& b)

483 　{

484 　　if((a.I == b.I) && (a.R == b.R))

485 　　{

486 　　　return true;

487 　　}else

488 　　{

489 　　　return false;

490 　　}

491 　}

492

493 　/* != overloading */

494 　bool operator!=(const Complex& a, const Complex& b)

495 　{

496 　　if((a.I == b.I) && (a.R == b.R))

497 　　{

498 　　　return false;

499 　　}else

500 　　{

501 　　　return true;

502 　　}

503 　}

504

505 　/* ostream overloading */

506 　ostream& operator<<(ostream& out, const Complex& c)

507 　{

508 　　out<<"("<<c.R<<")"<<"+"<<"("<<c.I<<")"<<"i";

509

510 　　return out;

511 　}

512

513 　void main()

514 　{

515 　　Complex a(1);

516 　　Complex b(1, 2);

517 　　Complex c;

518 　　double da = 100.0;

519 　　int ia = 99;

520

521 　　cout<<"a = "<<a<<endl;

522 　　cout<<"b = "<<b<<endl;

523 　　cout<<"da = "<<da<<endl;

524 　　cout<<"ia = "<<ia<<endl;

525

526 　　c = a + b;

527 　　cout<<"c = a + b = "<<c<<endl;

528

529 　　c = a - b;

530 　　cout<<"c = a - b = "<<c<<endl;

531

532 　　c = a * b;

533 　　cout<<"c = a * b = "<<c<<endl;

534

535 　　c = a / b;

536 　　cout<<"c = a / b = "<<c<<endl;

537

538 　　c = -a;

539 　　cout<<"c = -a = "<<c<<endl;

540

541 　　c = da;

542 　　cout<<"c = da = "<<c<<endl;

543

544 　　c = ia;

545 　　cout<<"c = ia = "<<c<<endl;

546

547 　　c = a * da;

548 　　cout<<"c = a * da = "<<c<<endl;

549

550 　　c = a * ia;

551 　　cout<<"c = a * ia = "<<c<<endl;

552

553 　　c = a / da;

554 　　cout<<"c = a / da = "<<c<<endl;

555

556 　　c = a / ia;

557 　　cout<<"c = a / ia = "<<c<<endl;

558

559 　　c = a + da;

560 　　cout<<"c = a + da = "<<c<<endl;

561

562 　　c = a + ia;

563 　　cout<<"c = a + ia = "<<c<<endl;

564

565 　　c = a - da;

566 　　cout<<"c = a - da = "<<c<<endl;

567

568 　　c = a - ia;

569 　　cout<<"c = a - ia = "<<c<<endl;

570

571 　　if(c == a)

572 　　{

573 　　　cout<<"c == a"<<endl;

574 　　}

575 　　if(c != a)

576 　　{

577 　　　cout<<"c != a"<<endl;

578 　　}

579

580 　　if(c == da)

581 　　{

582 　　　cout<<"c == da"<<endl;

583 　　}

584 　　if(c != da)

585 　　{

586 　　　cout<<"c != da"<<endl;

587 　　}

588

589 　　c = ia;

590 　　cout<<"c = ia = "<<c<<endl;

591 　　if(c == ia)

592 　　{

593 　　　cout<<"c == ia"<<endl;

594 　　}

595 　　if(c != ia)

596 　　{

597 　　　cout<<"c != ia"<<endl;

598 　　}

599 　}

第11章   继承与多态

一：填空题
1. 类A继承类B，则A称为B的  ，B称为A的  。
2. 一个派生类继承多个基类称为  。
3. 三种继承访问说明符是：  、  、  ，如果基类的公有函数到继承类中仍是公有函数，应该使用  继承方式。
4.  、  和  是不能被派生类继承的。
5. 派生类中对基类的成员函数f进行覆盖，如果调用基类的成员f应该使用  。
6. 多态也称为  或  ，在C＋＋中是通过  实现的。
7. 通过在虚函数参数表后加  ，我们可以定义纯虚函数。含有纯虚函数的类我们称为  。
8. 在C++中，构造函数和析构函数，  不能定义为虚函数，  可以定义为虚函数。
9. 要达到动态联编的效果，基类和派生类的对应函数不仅名字相同，而且返回类型、参数  和  也必须相同。
10.C++编译器不允许用抽象类创造对象，它只能被其它类  。

答案:

一. 填空题

　1. 派生类基类
　2. 多继承
　3. public private protected public
　4. 构造函数、析构函数、operator＝
　5. 域运算符
　6. 动态联编或迟后联编、虚函数
　7. ＝0、抽象类
　8. 构造函数析构函数
　9. 个数类型
　10. 继承

二、判断题
1. 创建派生类对象时，先调用基类的构造函数，再调用派生类的构造函数，当销毁这个对象时顺序正好相反，先调用派生类的析构函数，再调用基类的析构函数。
2. 无论何时编译器都为类构造一个无参数的缺省的构造函数。
3. 无论什么方式的继承，基类的私有成员都不能被派生类访问。
4. 基类中定义了虚函数，在派生类中相应函数会自动变成虚函数。
5. 要达到动态联编的效果，基类和派生类的对应函数不仅名字相同，而且返回类型、参数个数和类型也必须相同。
6. 如果派生类没有实现虚函数，那么它将使用他的基类的虚函数。
7. 如果抽象类的虚函数在基类中被实现，我们就可以用它创建对象。
8. 我们不能用抽象类定义对象，但可以定义对象的指针。
9. 构造函数和析构函数可以是虚函数。
10. 虚析构函数的工作过程与普通虚函数不同，普通虚函数只是调用相应层上的函数，而虚析构函数是先调用相应层上的析构函数，然后逐层向上调用基类的析构函数。

答案:

二. 判断题

　1. 对
　2. 错
　3. 对
　4. 对
　5. 对
　6. 对
　7. 错
　8. 对
　9. 错
　10. 对

三、简答题
1．实现一个类A，在A中有两个私有的整型变量a和b，定义构造函数对a和b进行初始化，并实现成员函数geta（）取得a的值和getb（）取b的值。实现类B从A继承，覆盖geta（），使其返回a的2倍。

2．在上题中类A和B的构造函数和析构函数中加入输出语句，观察构造函数和析构函数的调用顺序。

3．在上题中定义一个基类A的指针，使他指向派生类B的对象，使用A的指针调用geta（）函数，观察结果。

4．将类A的geta（）定义为虚函数，重复第五题，观察结果。

5．生成一个Object抽象类，在其中声明CalArea（）、IsIn（）纯虚函数，从Object派生出Rect类、Circle类，实现这些函数。

三、简答题

　1．源程序
　class A
　{
　　int a;
　　int b;
　public:
　　A(int m,int n):a(m),b(n) {}
　　int geta() {return a; }
　　int getb() {return b; }
　};
　class B :public A
　{
　public:
　　B(int m,int n):A(m,n) {}
　　int geta() {return A::geta()*2; }
　};

　void main()
　{
　　B b(2,2);
　　b.geta();
　}

　2、源程序
　#include "iostream.h"
　class A
　{
　　int a;
　　int b;
　public:
　　A(int m,int n):a(m),b(n) { cout<<"A created"<<endl; }
　　int geta() {return a; }
　　int getb() {return b; }
　　~A() {cout<<"A destroyed"<<endl; }
　};

　class B :public A
　{
　public:
　　B(int m,int n):A(m,n) { cout<<"B created"<<endl;}
　　int geta() {return A::geta()*2; }
　　~B() {cout<<"B destroyed"<<endl; }
　};

　void main()
　{
　　B b(2,2);
　　b.geta();
　}

　3. 源程序
　#include "iostream.h"
　class A
　{
　　int a;
　　int b;
　public:
　　A(int m,int n):a(m),b(n) { cout<<"A created"<<endl; }
　　int geta() {return a; }
　　int getb() {return b; }
　　~A() {cout<<"A destroyed"<<endl; }
　};

　class B :public A
　{
　public:
　　B(int m,int n):A(m,n) { cout<<"B created"<<endl;}
　　int geta() {return A::geta()*2; }
　　~B() {cout<<"B destroyed"<<endl; }
　};

　void main()
　{
　　B b(2,2);
　　A* pa=&b;
　　b.geta();
　　pa->geta();
　}

　4. 源程序
　#include "iostream.h"
　class A
　{
　　int a;
　　int b;
　public:
　　A(int m,int n):a(m),b(n) { cout<<"A created"<<endl; }
　　virtual int geta() {return a; }
　　virtual int getb() {return b; }
　　~A() {cout<<"A destroyed"<<endl; }
　};

　class B :public A
　{
　public:
　　B(int m,int n):A(m,n) { cout<<"B created"<<endl;}
　　int geta() {return A::geta()*2; }
　　~B() {cout<<"B destroyed"<<endl; }
　};

　void main()
　{
　　B b(2,2);
　　A* pa=&b;
　　b.geta();
　　pa->geta();
　}

　5. 源程序
　#include<iostream.h>
　#include<math.h>
　#define pi 3.1416
　class Point{
　public:
　　Point(int a,int b)
　　{
　　　x=a;
　　　y=b;
　　}

　　int x;
　　int y;
　};
　class Object {

　public:
　　virtual double calarea()=0;
　　virtual int IsIn(Point p)=0;
　};

　class Rect :public Object {
　Point topleft;
　Point bottomright;
　public:
　　Rect(Point p1,Point p2): topleft(p1),bottomright(p2) {}
　　double calarea() {
　　return fabs((topleft.x-bottomright.x)* (topleft.y-bottomright.y));
　}
　int IsIn(Point p) {
　　if ((p.x>=topleft.x&&p.x<=bottomright.x)&&(p.y>=topleft.y&&p.y<=bottomright.y) )
　　　return 1;
　　else return 0;
　　}
　};

　class Circle :public Object {
　　Point cc;
　　double radius;
　public:
　　Circle(Point p,double r):cc(p),radius(r) {}
　double calarea() {
　　return pi*radius*radius;
　}
　int IsIn(Point p) {
　　if ((p.x-cc.x)*(p.x-cc.x)+ (p.y-cc.y)* (p.y-cc.y)<radius*radius)
　　　return 1;
　　else return 0;
　　}
　};

　void main()
　{
　　Object *obj[2];
　　obj[0]=new Rect(Point(0,0),Point(100,200));
　　obj[1]=new Circle(Point(100,200),100.0);
　　int i;
　　for (i=0;i<2;i++) {
　　　cout<<"the area is "<<obj->calarea()<<endl;
　　}
　}

posted on 2013-02-19 20:31 呈现2014年中国男性魅力PUA风采阅读(953) 评论(0) 收藏举报

刷新页面返回顶部

C++试题

导航

公告