面向对象方法学试题及答案

C++程序设计试题（下）样卷（卷面50分）

（考试用时100分钟）

一、选择题（每题1分，共5分）

1．设计一个自定义类时，需要在屏幕上显示或向文件写入类对象的数据，最佳选择方法是 。

A．为屏幕显示和文件写入各自设计一个成员函数。 B．为屏幕显示和文件写入统一设计一个成员函数。 C．重载插入运算符（<<）。 D．重载提取运算符（>>）。

2．关于异常处理，那些说法是错误的 。

A．在C++程序中，由throw表达式抛出异常，而该表达式应直接或间接地被包

含在try块中。

B．当抛出异常后，寻找匹配的catch子句有固定的过程：逆着程序函数的调用

链返回，称为栈展开（Stack Unwinding）。

C．当某条语句抛出异常时，跟在其后的语句将被跳过，但析构函数仍然执行，

所以应该在析构函数中释放资源。 D．catch子句实际是一个特殊的函数。

3．下列关于动态资源分配的说法中错误的是 。 A．动态分配的资源不仅包括内存，还包括文件。

B．动态内存分配的优点在于可以随时给数组分配所需的内存而不会失败。 C．动态分配的资源通常要求在析构函数中释放。

D．对含有动态分配的数据成员的类对象应该采用深复制。

4．下列有关模板的描述那些是错误的 。

A．模板把数据类型作为一个设计参数，称为参数化程序设计。 B．模板参数除模板类型参数外，还有非类型参数。 C．类模板与模板类是同一概念。

D．使用时，模板参数与函数参数相同，是按位置而不是名称对应的。

5．关于多态，下面那些说法是正确的 。 A．多态分静态的（编译时）和动态的（运行时）。 B．运行时的多态与类的层次结构有关。

C．在基类定义了虚函数后，在派生类中重新定义时可以不加关键字virtual。 D．仅使用虚函数并不能实现运行时的多态性，还必须采用指针或引用来调用才

能真正实现运行时的多态性。

二、填空题（每空0.5分，共5分）

1．有标准字符串类string对象str，str1，str2。对其字符元素的访问可用两种方

式：str[i]和str.at(i)。两者的区别是 （1） 。str1+=str2 实现的运算是 （2） 。str.substr(pos,length1) 实现的运算是 （3） 。

1

2．C/C++中的多维数组用的是一个 （4） 的定义，即多维数组的基本定义是

（5） 构成的数组，三维数组的元素是 （6） 。 3．单链表的结点包含两个域： （7） 和 （8） 。使用链表的最大的优点是 （9） ，即使是动态数组也做不到这一点。

4．纯虚函数定义时在函数参数表后加=0，它表明程序员对函数体不定义，其本

质是将指向函数体的指针定为 （10） 。

三、阅读程序段（每题4分，共16分）

1．写出下面的程序输出的数据，这是什么图形？ int main(){

int a[10][11]={0,1},i,j; for(i=1;i<10;i++) for(j=1;j<=i+1;j++) a[i][j]=a[i-1][j-1]+a[i-1][j]; for(i=0;i<10;i++){ for(j=1;j<=i+1;j++) cout<

return 0; }

2．写出下列程序的输出结果，并做简单的说明。 class Student{

string coursename; //课程名 int classhour; //学时 int credit; //学分 public:

Student(){coursename=\ virtual void Calculate(){credit=classhour/16;} void SetCourse(string str,int hour){ coursename=str; classhour=hour; }

int GetHour(){return classhour;}

void Print(){cout<

<<\学分\

};

class GradeStudent:public Student{ public:

GradeStudent(){};

void Calculate(){SetCredit(GetHour()/20);} };

2

int main(){

Student s,*ps; GradeStudent g;

s.SetCourse(\英语\ g.SetCourse(\英语\ ps=&s;

ps->Calculate(); ps->Print(); ps=&g;

ps->Calculate(); ps->Print(); return 0; }

3．写出该程序的输出结果，并说明该类的定义中top和maxSize的意义。templateclass Stack{ int top; T *elements; int maxSize; public: Stack(int=30); ~Stack(){delete[] elements;} void Push(const T &data); T Pop(); };

template Stack::Stack(int maxs){ maxSize=maxs; top=-1; elements=new T [maxSize]; }

template void Stack::Push(const T &data){ elements[++top]=data; }

template T Stack::Pop(){ return elements[top--]; }

int main(){ int i; char a[5]={'k','c','a','t','s'}; Stackcstack(); for(i=0;i<5;i++) cstack.Push(a[i]); for(i=0;i<5;i++) cstack.Pop()); return 0; }

3

4．写出下列程序的输出结果，指出错误所在；将A的析构函数改为虚函数结果又如何？

class A{ int *p; public: A(){ p=new int[3];

cout<<”A().”; } ~A(){ delete[]p; cout<<”~A().\\n”; } }

class B:public A{

int *q; public: B(){ q=new int[256];

cout<<”B(). ”; } ~B(){ delete[]q; cout<<”~B().”; } }

int main(){ int i;

for(i=0;i<3;i++){ A*r=new B; //重复创建动态对象 delete r； //重复释放动态对象 } }

四、填空，完善程序（每空1.5分，共24分）

1．对半查找递归算法，x为定值，算法作为升序有序表（ordered list）模板类的成员函数。其中T为模板类型参数，sixe代表有序表中数组slist元素的个数。小于比较运算符(<)在具体的类中重载。

template int Orderedlist::Binarysearch(T & x,const int low,const int high){ int mid=-1; if (low<=high){ mid=(low+high)/2;

4

if(slist[mid]

return (3) ; } 2．冒泡排序算法，作为Orderedlist类的成员函数。last是有序表元素个数。 template void Orderedlist::BubbleSort(){ bool noswap; //交换标志 int i,j; T temp;

for (i=0;i

3．用虚函数来实现辛普生法求函数的定积分。在梯形法中是用直线来代替曲边梯形的曲边，在辛普生法中是用抛物线来代替，得出的公式为（区间必须为偶数n个相等区间）。

b?af(x)dx?13?x[y0?yn?4(y1?y3???yn?1)?2(y2?y4???yn?2)]

class Simpson{

double Intevalue,a,b; //Intevalue积分值，a积分下限，b积分上限 public:

virtual double fun(double x)=0; //被积函数声明为纯虚函数 Simpson(double ra=0,double rb=0){ a=ra; b=rb; Intevalue=0; }

void Integrate(){ double dx; int i; dx=(b-a)/2000;

5

Intevalue= (9) ; for(i=1;i<2000;i+=2) Intevalue+=4*fun( (10) ); for(i=2;i<2000;i+=2) Intevalue+=2*fun( (10) ); Intevalue*=dx/3; }

void Print(){cout<<\积分值=\};

class A:public Simpson{ public:

A(double ra,double rb):Simpson(ra,rb){};

double fun(double x){ (11) ;} //以sin(x)作为被积函数 };

int main(){

A a1(0.0,3.1415926535/2.0); Simpson *s=&a1;

s->Integrate(); //动态 s->Print(); return 0; }

4．单链表的结点采用类Node，以链表类List为友元类，List可直接访问Node的私有成员。对链表整体的操作则作为链表类的成员函数，这里列出向前生成链表、向后生成链表、创建结点等等。 templateclass Node{

T info; //数据域 Node *link; //指针域 public: ……

friend class List; };

templateclass List{

Node *head,*tail; //链表头指针和尾指针 public: ……

void InsertFront(Node* p); //可用来向前生成链表，在表头插入一个结点 void InsertRear(Node* p); //可用来向后生成链表，在表尾添加一个结点 Node*CreatNode(T data); //创建一个结点(孤立结点) };

templatevoid List::InsertFront(Node *p){ //链头插入 p->link= (12) ; (13) =p; if(tail==head) tail=p; }

templatevoid List::InsertRear(Node *p){ //链尾插入

6

p->link= (14) ; (15) =p; tail=p; }

templateNode* List::CreatNode(T data){//建立新节点 Node*tempP=new Node(data); return tempP; }

5．为学生类重载插入、提取和小于运算符。

class student{ int key; string name; public: bool operator<(student); friend ostream & operator<<(ostream & s,const student & k); friend istream & operator>>(istream & s,student & k); };

ostream & operator<<(ostream & s,const student & k){ （16） ; return s; }

istream & operator>>(istream & s,student & k){ （17） ; return s; }

bool student::operator<(student st){return （18） ;}

答案：

一、选择题（每题1分，共5分）：

1．C． 2．D． 3．B． 4．C． 5．全部 二、填空题（每空0.5分，共5分）：

（1）前者不查是否出界，后者查是否出界（2）str2的字符数据连接到str1的尾部 （3）返回对象的一个子串，从pos位置起，长length1个字符（4）递归 （5）数组 （6）二维数组 （7）数据域 （8）指针域 （9）用多少就开多少空间 （10）空指针 三、阅读程序段（每题4分，共16分） 1．输出如下： 1

1 1

1 2 1

1 3 3 1 1 4 6 4 1

7

1 5 10 10 5 1 1 6 15 20 15 6 1

1 7 21 35 35 21 7 1 1 8 28 56 70 56 28 8 1

1 9 36 84 126 126 84 36 9 1 这是杨辉三角形。 2．输出如下：

英语80学时5学分 英语80学时4学分

这是使用虚函数实现运行时的多态。第一行是本科生，第二行是研究生。 3．输出为：stack

该类是栈，top是指向栈顶的指针，maxSize是栈的容量。 4．输出为

A().B().~A(). A().B().~A(). A().B().~A().

因为r是指向A类对象的指针，所以B类对象动态分配的空间未释放，出现内存泄漏。A类的析构函数改为虚函数后没有内存泄漏，输出为： A().B().~B().~A(). A().B().~B().~A(). A().B().~B().~A().

四、填空，完善程序（每空1.5分，共24分） 1．（1）mid+1,high （2）low,mid-1 （3）mid 2．（4）true （5）last （6）j>i （7）j-- （8）false 3．（9）fun(a)+fun(b) （10）a+i*dx

（11）return sin(x) 4．（12）head->link （13）head->link （14）tail->link （15）tail->link 5．（16）s<>k.key>>k.name; （18）key

五、

#include #include #include

8

using namespace std; class shape{ public:

virtual float area( )=0; };

float total(shape *s[ ],int n) { float sum=0.0; for(int i=0;iarea(); return sum; }

class triangle:public shape {

public:

triangle(float i,float j,float k):a(i),b(j),c(k){} float area(){ float p;p=0.5*(a+b+c); return sqrt(p*(p-a)*(p-b)*(p-c));} private: float a; float b; float c; };

class rectangle:public shape {

public:

rectangle(float l,float w):length(l),width(w){} float area(){ return width*length;} private: float length; float width; };

int main(int argc, char *argv[]) { shape *pt[2]; triangle s1(3,4,5); rectangle s2(2,3); pt[0]=&s1; pt[1]=&s2;

cout<<\三角形的面积为：\cout<<\矩形的面积为：\cout<<\总面积为： \system(\return 0; } 六、

9

#include

class Vector {

int x,y; public:

Vector(){}

Vector(int i,int j){x=i;y=j;} void disp() {

cout<<\ }

friend Vector add(Vector &v1,Vector &v2) {

Vector v;

v.x=v1.x+v2.x; v.y=v1.y+v2.y; return v; }

friend Vector sub(Vector &v1,Vector &v2) {

Vector v;

v.x=v1.x-v2.x; v.y=v1.y-v2.y; return v; } };

void main() {

Vector v1(10,20),v2(4,5),v3; v3=add(v1,v2);

cout<<\输出结果：\

cout<<\ cout<<\ v3=sub(v1,v2);

cout<<\ cout<<\}

10

本文来源：https://www.bwwdw.com/article/4sfa.html