OOP技术：面向对象程序设计期末复习指导.doc

OOP技术：面向对象程序设计期末复习指导

面向对象程序设计课程系中央电大开放教育本科计算机科学与技术专业统设必修课程，本课程的期末复习以中央电大下发的资料和网上复习指导为准。为了加强期末复习，下面市电大给出一套综合练习题，仅作参考。

综合练习题

一、单选题
1、 C++源程序文件的默认扩展名为( )。
A:cpp B:exe C:obj D:lik
2、 用new运算符创建一个含10个元素的一维整型数组的正确语句是( )。
A: int *p=new a[10];
B: int *p=new float[10];

C: int *p=new int[10];
D: int *p=new int[10]={1,2,3,4,5}
3、 假定有“struct BOOK{char title[40]; float price;}; BOOK *book=new BOOK;”，则正确的语句为（ ）。
A: strcpy((*book)->title,”Wang Tao”);
B: strcpy(*book.title,”Wang Tao”);
C: strcpy(book->title,”Wang Tao”);
D: strcpy(book.title,”Wang Tao”);
4 假定指针变量p定义为“int *p=new int[30];”，要释放p所指向的动态内存，应使用语句（ ）。
A: delete p;
B: delete *p;
C: delete &p;
D: delete []p;
5、 关于消息，下列说法中不正确的是（ ）。
A: 发送消息的对象请求服务，接受消息的对象提供服务
B: 消息的发送者必须了解消息的接收者如何相应消息
C: 在C++中，消息的发送具体体现为对接收消息的对象的某个函数的调用
D: 每个对象只能接收某些特定格式的消息
6、 对于任一个类，用户所能定义的析构函数的个数至多为( )。
A: 0 B: 1 C: 2 D: 任意个
7、 do语句能够改写为（ ）语句。
A: 复合 B: if C: switch D: while
8、 假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（ ）。
A: x(a) B: x[a] C: x->a D: x.a
9、 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ ）。
A: x.a B: x.a() C: x->GetValue() D: x.GetValue()
10、 假定AB为一个类，则( )为该类的拷贝构造函数的原型说明。
A: AB(AB x); B: AB(AB& x); C: void AB(AB& x); D: AB(int x);
11、 关于运算符重载，下列说法正确的是（ ）。
A: 重载时，运算符的优先级可以改变。
B: 重载时，运算符的结合性可以改变。
C: 重载时，运算符的功能可以改变。
D: 重载时，运算符的操作数个数可以改变。
12、 下列对派生类的描述中错误的说法是：（ ）。
A: 派生类至少有一个基类
B: 派生类可作为另一个派生类的基类
C: 派生类除了包含它直接定义的成员外，还包含其基类的成员
D: 派生类所继承的基类成员的访问权限保持不变
13、 C++程序的基本模块为（ ）。
A: 语句 B: 函数 C: 表达式 D: 标识符
14、 以下叙述中不正确的是（ ）。
A: 在一个函数中，可以有多条return语句
B: 函数的定义不能嵌套，但函数的调用可以嵌套
C: 函数必须有返回值
D: 不同的函数中可以使用相同名字的变量
15、 文件包含命令中被包含的文件的扩展名（ ）。
A: 必须是.h B: 不能是.h C: 可以是.h或.cpp D: 必须是.cpp
16、 软件产品可被全部或部分地再用于新的应用的能力叫做软件的（ ）。
A: 可维护性 B: 可复用性 C: 兼容性 D: 正确性
17、 假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A x(4,5);”语句后，x.a和x.b的值分别为( )。
A: 4和5 B: 5和4 C: 4和20 D: 20和5
18、 派生类的对象对其基类中（ ）可直接访问。
A: 公有继承的公有成员
B: 公有继承的私有成员
C: 公有继承的保护成员
D: 私有继承的公有成员
19、 程序运行中需要从键盘上输入多于一个数据时，各数据之间应使用( )符号作为分隔符。
A: 空格或逗号 B: 逗号或回车
C: 逗号或分号 D: 空格或回车
20、 假定有定义“int b[10]; int *pb;”，则不正确的赋值语句为（ ）。
A: pb=b[5]; B: *pb=new int;
C: pb=&b[0]; D: pb=b;
21、 假定变量a和pa定义为“double a[10], *pa=a;”，要将12.35赋值给a中的下标为5的元素，不正确的语句是（ ）。
A: pa[5]=12.35; B: a[5]=12.35;
C: *(pa+5)=12.35; D: *(a[0]+5)=12.35;
22、 关于面向对象系统分析，下列说法中不正确的是（ ）。
A: 术语“面向对象分析”可以用缩写OOA表示
B: 面向对象分析阶段对问题域的描述比实现阶段更详细
C: 面向对象分析包括问题域分析和应用分析两个步骤
D: 面向对象分析需要识别对象的内部和外部特征
23、 在C++程序中使用的cin标识符是系统类库中定义的（ ）类中的一个对象。
A: istream B: ostream
C: iostream D: fstream
24、 假定AB为一个类，则执行 “AB *px=new AB[n];”语句时将( )。
A: 动态分配一个数组
B: 动态分配一个对象
C: 静态分配一个数组
D: 静态分配一个对象
25、在下面循环语句中循环体执行的次数为（ ）。
int i=0,s=0; while(s<20) {i++; s+=i;}
A: 4 B: 5 C: 6 D: 7
26、 以下叙述不正确的是( )。
A: 宏替换不占用运行时间
B: 宏名无类型
C: 宏替换只是字符替换
D: 宏名必须用大写字母表示
27、 假定一条定义语句为“int a[10], x, *pa=a;”，若要把数组a中下标为3的元素值赋给x，则不正确的语句为（ ）。
A: x=a[3]; B: x=*(a+3); C: x=pa[3]; D: x=*pa+3;
28、 如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（ ）。
A: a.operator++(1)
B: operator++(a)
C: operator++(a,1)
D: a.operator++()
29、 设”int a=12;”，则执行完语句”a+=a*a;”后，a的值是( )。
A: 144 B: 156 C: 288 D: 12
30、 在一个用链表实现的队列类中，假定每个结点包含的值域用elem表示，包含的指针域用next表示，链队的队首指针用elemHead表示，队尾指针用elemTail表示，若链队为空，则进行插入时必须把新结点的地址赋给( )。
A: elemHead
B: elemTail
C: elemHead和elemTail
D: elemHead或elemTail
31、 类的析构函数可以带有( )个参数。
A: 0 B: 1 C: 2 D: 任意
32、 下面是重载双目运算符-的成员函数原形，其中最符合-原来含义的是（ ）。
A: Value Value::operator-(Value);
B: Value Value::operator-(int);
C: Value& Value::operator-(Value);
D: Value& Value::operator-(Value&);
33、 在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（ ）。
A: 该运算符是一个单目运算符。
B: 该运算符函数有一个隐含的参数this。
C 该运算符函数是类的成员函数。
D: 该运算符函数是类的友元函数。

二、编程综合题
1．
#include
void f4(int a[], int n, int& s)
{
s=0;
for(int i=0; i cout<
void main() {
int a[10]={76,83,54,62,40,75,90,92,77,84};
int b[4]={60,70,90,101};
int c[4]={0};
for(int i=0;i<10;i++) {
int j=0;
while(a[i]>=b[j]) j++;
c[j]++;
}
for(i=0;i<4;i++) cout<
class A {
int *a;
public:
A(int x=0):a(new int(x)){}
~A() {delete a;}
int getA) {return *a;}
void setA(int x) {*a=x;}
};
void main() {
A x1,x2(3);
A *p=&x2;
p->setA(x2.getA()+5);
x1.setA(15+x1.getA());
cout<
#include
class Point {
int x,y;
public:
Point(int x1=0, int y1=0) :x(x1), y(y1) {
cout<<"Point:"< public Point,public Text {
public:
CircleWithText(int cx,int cy, char *msg):
Point(cx,cy),Text(msg) {
cout<<"Point with Text con! ";
}
~CircleWithText() {cout<<"Point with Text des ";}
};

void main()
{
CircleWithText cm(3,4,"hello");
}

5、 #includetream.h>
        int a=5;
        void main() {
         int b=a+20;
      int a=10;
         cout<a<<' '<
int f1(int x, int y)
{
x=x+y; y=x+y;
cout<<"x="<tput();
         cout<<"d: "; d.FranOutput();
        }

8、
#include
class Point {
int x,y;
public:
Point(int x1=0, int y1=0) :x(x1), y(y1) {
cout<<"Point:"<心位置
int radius; //半径
public:
Circle(int cx,int cy, int r):center(cx,cy),radius(r) {
cout<<"Circle radius:"<
const int M=20;
void main()
{
int c2,c3,c5;
c2=c3=c5=0;
for(int i=1; i<=M; i++) {
if(i%2==0) c2++;
if(i%3==0) c3++;
if(i%5==0) c5++;
}
cout<
const int B=2;
void main()
{
int p=1,s=1;
while(s<50) {
p*=B;
s+=p;
}
cout<<"s="<
void main()
{
char s[3][5]={"1234","abcd","+-*/"};
char *p[3];
for(int I=0;I<3;I++) p[I]=s[I];
for(I=2;I>=0;I--) cout<
#include
class CD {
char* a;
int b;
public:
void Init(char* aa, int bb)
{
a=new char[strlen(aa)+1];
strcpy(a,aa);
b=bb;
}
char* Geta() {return a;}
int Getb() {return b;}
void Output() {cout<

}
13、
#include
class Date
{
public:
Date(int y=2001,int m=1,int d=1){Year=y; Month=m; Day=d;}
void PrintDate(){ cout<h; Minutes=m; Seconds=s;}
void PrintTime(){ cout< Date(y,mo,d), Time(h,mi,s){}
void PrintDate_Time(){PrintDate();PrintTime();}
};

void main( )
{
Date_Time a, b(2002,10,1,6,20,0), c(2003,3,8,6,7);
a.PrintDate_Time();
b.PrintDate_Time();
c.PrintDate_Time();
}
16、
//*********************test.h********************//
#include
class Base
{
public:
Base (int i,int j){ x0=i; y0=j;}
void Move(int x,int y){ x0+=x; y0+=y;}
void Show(){ cout<<"Base("<i,j){ x=m; y=n;}
void Show (){cout<<"Next("<erived d(3,4,10,15);
d.Move1();
d.Show();
d.Show1();
}

14、
#include
const int N=5;
void main()
{
int i,p=1,s=0;
for(i=1;i<
const int N=5;
void fun();
void main()
{
for(int i=1; i cout<<(a+=3,a+b)<<' ';
}
16、
#include
class A {
int a[10]; int n;
public:
A(int aa[], int nn): n(nn) {
for(int i=0; iurn s;
}
};
void main() {
int a[]={2,5,8,10,15,20};
A x(a,4);
A y(a,6);
int d=1;
for(int i=0; i<4; i++) d*=x.Get(i);
int f=y.SumA(5);
cout<<"d="<  for(int i=0; ilass Array {
 int *a;  //指向动态分配的整型数组空间
 int n;    //记录数组长度
public:
 Array(int aa[], int nn);  //构造函数，利用aa数组长度nn初始化n，
                     //利用aa数组初始化a所指向的数组空间
 Array(Array& aa);  //拷贝构造函数
 Array& Give(Array& aa);  //实现aa赋值给*this的功能并返回*this
    Array Uion(Array& aa);  //实现*this和aa中的数组合并的
                      //功能，把合并结果存入临时对象并返回
 int Lenth() {return n;}  //返回数组长度
 void Print() {       //输出数组
  for(int i=0; i case ’-’: return a-b;
case ’*’: return a*b;
case ’/’: if(b==0) {
cout<<"divided by 0!"<);
}
}

6、 根据下面类中Compare 函数成员的原型和注释写出它的类外定义。
class AA {
 int* a;
 int n;
 int MS;
public:
 void InitAA(int aa[], int nn, int ms) {
  if(nn>ms) {cout<<"Error!"< //比较*this与b的大小，若两者中
        //的n值相同，并且数组中前n个元素值对应
        //相同，则认为两者相等返回1，否则返回0。
};

7、
下面给出了矩阵类Matrix定义。为了求两个矩阵对象的乘积，需要定义一个Matrix的友元函数Multiply()。请按照友元函数Multiply（）的声明编写出该函数的定义。
class Matrix {
  public:
 Matrix(int row,int col);   //构造一个具有row行col列的矩阵
    ~Matrix() {delete []mem;}    //析构函数
friend bool Multiply(Matrix &m1, Matrix &m2, Matrix &m3);
           //定义Multiply()为友元函数，该函数把m1×m2的值赋给m3
//其他成员函数从略
  private:
 int *mem;                  //动态申请矩阵空间
 const int rows,cols;          //矩阵的行数和列数
};
Matrix::Matrix(int row,int col):rows(row),cols(col)
{
    mem = new int[row*col];
}
bool Multiply(Matrix &m1, Matrix &m2, Matrix &m3)
{
//确定矩阵是否能够进行相乘
  if(m1.rows != m3.rows ||m2.cols != m3.cols || m1.cols != m2.rows)   return false;
//定义sum变量，用于计算乘积矩阵m3中每个元素的值
  int sum;
//请在下面编写剩余部分

}
8、
指出程序或函数的功能
int fun6(int m, int n, int b=2)
{
if(mconst int c; //3行
public: //4行
A() {a=b=c=0;} //5行
A(int aa, int bb):c(aa+bb) {a=aa; b=bb;} //6行
}; //7行
A a,b(1,2,3);