c++期末考试试卷

一个选项是符合题目要求的，请将其代码填在题后的括号内。错选或未选均无分。

1.在C++中，函数原型不能标识( )

A.函数的返回类型B.函数参数的个数

C.函数参数类型D.函数的功能

2.在C++程序中，对象之间的相互通信通过( )

A.继承实现B.调用成员函数实现

C.封装实现D.函数重载实现

3.对于任意一个类，析构函数的个数最多为( )

A.0 B.1 C.2 D.3

4.下面函数模板定义中不正确的是（ ）

A.template B.template

QF(Qx){ QF(Qx){

return Q+x; return x+x;

} }

C.template D.template

TF(Tx){ TF(Tx){

return x*x; return x>1;

} }

5.友元关系不能( )

A.继承

B.是类与类的关系

C.是一个类的成员函数与另一个类的关系

D.提高程序的运行效率

6.语句ofstream f(″SALARY.DAT″,ios::app｜ios::binary);的功能是建立流对象f，试图打开文

件SALARY.DAT 并与之连接，并且( )

A.若文件存在，将文件写指针定位于文件尾；若文件不存在，建立一个新文件

B.若文件存在，将其置为空文件；若文件不存在，打开失败

C.若文件存在，将文件写指针定位于文件首；若文件不存在，建立一个新文件

D.若文件存在，打开失败；若文件不存在，建立一个新文件

7.下面说法正确的是( )

A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方

B.内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方

C.类的内联函数必须在类体内定义

D.类的内联函数必须在类体外通过加关键字inline 定义

8.可以用p.a 的形式访问派生类对象p 的基类成员a，其中a 是( )

A.私有继承的公有成员B.公有继承的私有成员

C.公有继承的保护成员D.公有继承的公有成员

9.在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是( )

A.派生类的对象可以赋给基类的对象

B.派生类的对象可以初始化基类的引用

C.派生类的对象可以直接访问基类中的成员

D.派生类的对象的地址可以赋给指向基类的指针

10.对于类定义

class A{

public:virtual void func1( ){ }

void func2( ){ }

};

class B:public A{

public:void func1( ){cout<<″class B func 1″<virtual void func2( ){cout<<″class B func 2″<};

下面正确的叙述是( )

A. A::func2( )和B::func1( )都是虚函数

B. A::func2( )和B::func1( )都不是虚函数

C. B::func1( )是虚函数，而A::func2( )不是虚函数

D. B::func1( )不是虚函数，而A::func2( )是虚函数

第二部分非选择题(共80 分)

二、填空题(本大题共10 小题，每小题2 分，共20 分)不写解答过程，将正确的答案写在每

小题的横线处。错填或不填均无分。

11.定义类的动态对象数组时，系统只能够自动调用该类的_________构造函数对其进行初始

化。

12.在C++程序设计中，建立继承关系倒挂的树应使用_________继承。

13.表达式cout<14.基类的公有成员在派生类中的访问权限由_________决定。

15.C++支持的两种多态性分别是_________多态性和_________多态性。

16.C++中语句const char * const p=″hello″；所定义的指针p 和它所指的内容都不能被

_________。

17.假定AB 为一个类，则语句AB(AB&x)；为该类_________构造函数的原型说明。

18.将关键字const 写在成员函数的_________和_________之间时，所修饰的是this 指针。

19.在C++中，访问一个对象的成员所用的运算符是_________，访问一个指针所指向的对象

的成员所用的运算符是_________。

20.派生类从一个或多个以前定义的该类的____

一、单项选择题(本大题共10 小题，每小题2 分，共20 分)

1.D 2.B 3.B 4.A 5.A

6.A 7.B 8.D 9.C 10.C

第二部分非选择题(共80 分)

二、填空题(本大题共10 小题，每小题2 分，共20 分)

11.无参

12.单一(或单)

13.cout<<′\\n′(或cout<<′\\12′,或cout<<′\\xA′,或其它等价形式)

14.访问控制(或其它等价形式)

15.编译时的(或静态，或操作重载)

运行时的(或动态，或虚函数)

16.改变(或重新赋值)

17.复制初始化(或拷贝)

18.函数头(或参数表) 函数体

19.成员选择运算符(或“.”) 成员访问运算符(或“>”)

20.基类

一、单项选择题（每题2分，共20分）

1. 派生类对象可访问基类中的什么成员(          )? 

A.公有继承的公有成员          B.公有继承的私有成员    

C.公有继承的保护成员          D.私有继承的公有成员

2. 定义析构函数时，应该注意(       )。   

A.其名与类名完全相同          B.返回类型是void类型    

C.无形参，也不可重载          D.函数体中必须有delete语句

3. 如果类A被说明成类B的友元，则(       )。   

A.类A的成员即类B的成员    

B.类B的成员即类A的成员    

C.类A的成员函数不得访问类B的成员    D.类B不一定是类A的友元  

4. 应在下列程序划线处填入的正确语句是（          ） 

#include 

class Base 

{ 　public: 

void fun(){cout<<"Base::fun"<}; 

class Derived:public Base 

{ 　void fun() 

{_____________ // 显示调用基类的函数fun() 

cout<<"Derived::fun"<} 

}; 

A．fun();           B. Base.fun();          C. Base::fun();        D. Base->fun();

5. 面向对象程序设计将数据与(          )放在一起，做为一个相互依存、不可分割的整体来处理。

   A. 对数据的操作       B. 信息         C. 数据隐藏        D. 数据抽象

6. 在类中声明转换函数时不能指定(      )。

   A. 参数          B. 访问权限    

C. 操作          D. 标识符  

7. 在派生类中重新定义虚函数时必须在(        )方面与基类保持一致。    

A. 参数类型          B. 参数名字 

C. 操作内容          D. 赋值

8. 下面关于C++中类的继承与派生的说法错误的是（            ）。

A．基类的protected成员在公有派生类的成员函数中可以直接使用

B．基类的protected成员在私有派生类的成员函数中可以直接使用

C．公有派生时，基类的所有成员访问权限在派生类中保持不变

D．基类的protected成员在保护派生类的成员函数中可以直接使用

9. 重载赋值操作符时，应声明为(       )函数。    

A. 友元          B. 虚           C. 成员          D. 多态

10. 语句 ofstream f(″SALARY.DAT″,ios::app｜ios::binary); 的功能是建立流对象 f，试图打开文件 SALARY.DAT 并与之连接，并且 (         )  

   A. 若文件存在，将文件写指针定位于文件尾；若文件不存在，建立一个新文件  

   B. 若文件存在，将其置为空文件；若文件不存在，打开失败 

   C. 若文件存在，将文件写指针定位于文件首；若文件不存在，建立一个新文件

   D. 若文件存在，打开失败；若文件不存在，建立一个新文件 

二、填空题（每空2分，共30分）

1. 假定 AB 为一个类，则语句 AB(AB&x) ；为该类 _________ 构造函数的原型说明。

2. C++ 支持的两种多态性分别是 _________ 多态性和 _________ 多态性。

3. 定义类的动态对象数组时，系统只能够自动调用该类的 _________ 构造函数对其进行初始化。

4. 运算符重载时，其函数名由               构成。成员函数重载双目运算符时，左操作数是               ，右操作数是                        。

5.C++标准库中的异常层次的根类为              类；MFC类库中绝大多数类都源自根类           类。

6.在下面横线处填上适当字句，完成类中成员函数的定义。  

class A{  

int * a;  

public:  

A(int aa=0) {  

a=_________; // 用 aa 初始化 a 所指向的动态对象  

}  

～ A(){_________;}// 释放动态存储空间  

};  

7．C++支持面向对象程序设计的四个要素是：封装性、继承性、             和                。

8．模板分为        模板和           模板。

一、单项选择题（每题2分，共20分）

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

二、填空题（每空2分，共30分）

1.拷贝或复制

2.运行(时)    编译(时)（二者位置可互换）（或改为静态和动态也可）

3.无参（缺省或默认均可）

4.operator运算符（运算符可写为@，若没写扣1分）  （当前）对象   函数的形参（参数）

5.exception（若e写为大写字母则扣0.5分，单词稍微写错扣0.5分）    CObject（字母CO为大写字母，写为小写各扣0.5分）

6.new int(aa)        delete a（有new、delete各给1分，int给0.5分）

7.抽象性        多态性（二者位置可互换）

8.类        函数（二者位置可互换）

一、单项选择题（每题2分，共20分）

1. 在下面选项中，对类的拷贝构造函数的声明形式是（  ）

A. A::A(&)    B. A::A(constA&)    C. A::A(A)    D. void A::A(A&a)

2. 下面关于成员函数特征的描述中，错误的是（   ）

A．成员函数不可以设置参数的默认值       B．成员函数可以重载

C．成员函数可以是内联函数               D．成员函数可以是静态的

3. 下面关于类模板叙述不正确的是（   ） 

A．可以有多个构造函数                   B. 类模板是模板类的实例

C. 一个类模板可以用来实例化多个模板类   D. 类模板可以有多个参数

4. 要使一个类成为抽象类，这个类应具有的条件是（     ）

A．至少有一个纯虚函数           B. 至少有一个虚函数

C. 只含有一个纯虚函数           D. 只含有一个虚函数

5. 有关运算符重载正确的描述是（  ）

A. C++语言允许在重载运算符时改变运算符的操作个数

B. C++语言允许在重载运算符时改变运算符的优先级

C. C++语言允许在重载运算符时改变运算符的结合性

D. C++语言允许在重载运算符时改变运算符的原来的功能

6. 下列说法正确的是（     ）。

A. 一个类的对象可以是另一个类的成员

B. 一个类可以作为另一个类的派生类

C. 一个类可以在另一个类定义体进行定义

D. 以上说法均正确

7. 有如下程序： 

#include

class BASE{

char c; 

public:

    BASE(char n):c(n){} 

virtual~BASE(){cout<}; 

class DERIVED:public BASE

{   

    char c; 

public: 

    DERIVED(char n):BASE(n+1),c(n){} 

~DERIVED(){cout<}; 

int main() 

{

    DERIVED('X'); 

    return 0; 

}

执行上面的程序将输出（         ）。

A)X          B)YX         C)XY             D)Y

8. 类MyClass的定义如下：

class MyClass

{ public:

MyClass(){value=0;}

SetValue(int i){value=i;}

  private:

        int value;

};

则对语句：MyClass *p,my;p=&my;正确的描述是（      ）。

A. 语句p=&my;是把对象my赋值给指针变量p；

B. 语句MyClass *p,my;会调用两次类MyClass的构造函数

C. 对语句*p.SetValue(5)的调用是正确的

D. 语句p->SetValue(5)与my.SetValue(5)等价

9. 下列各类函数中，      不是类的成员函数。

A. 构造函数      B. 析构函数    C. 友元函数   D. 拷贝构造函数

10. 派生类的对象对它的基类成员中       是可以访问的。

A. 公有继承的公有成员     B. 公有继承的私有成员  

C. 公有继承的保护成员     D. 私有继承的公有成员

二、填空题（每空2分，共30分）

1. 定义内联函数所用的关键字            ，定义友元所用的关键字为            。

2. 当一个派生类具有多个基类时，这种继承方式称为_       __。

3. 通过一个构造函数调用虚函数时，C++系统对该调用采用           联编。

4. 任何类中允许有           、           、            三种访问控制类型的成员，数据成员和成员函数的默认类型为                。

5. 只有在          继承的情况下，基类和派生类之间才有赋值兼容性规则。

6. C++标准库中的异常层次的根类定义在库的头文件                          中。

7. 运算符重载使用的两种方式是                和                  。

8. C++支持面向对象程序设计的四个要素是：抽象性、            、            和           。

一、单项选择题（每题2分，共20分）

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

二、填空题（每空2分，共30分）

9.inline    friend

10.多重继承

11.静态

12.private        protected        public（三者位置可以互换）        private

13.公有

14.exception.h

15.成员函数        友元函数（二者位置可互换）

多态性        继承性        封装性（三者位置可互换）

一、单项选择题（每题2分，共20分）

1. 下面有关构造函数和new运算符关系正确的说法是（  ）

A．new运算符不调用构造函数        B. 构造函数一定调用new运算符

C．当生成新类的实例时，先调用new运算符，然后调用构造函数进行初始化

D. 当new运算符动态产生类的对象时，new运算符也自动调用构造函数

2. 下面有关类性质的说法错误的是（   ） 

A.一个类可以有多个构造函数，但只有一个析构函数

B.析构函数和构造函数都不能有返回类型

C.不能给析构函数指定参数

D.一个类中不可以声明具有类类型的数据成员

3. 下面关于友元函数描述正确的是（   ）

A．友元函数是类的成员

B．友元函数在类的外部声明

C．友元函数在类中声明

D. 友元函数能够派生

4. 下面叙述正确的是（   ） 

A. 派生类不可以使用私用派生

B. 保护派生时，基类的保护成员在派生类中是公有的

C. 对基类成员的访问允许二义性

D. 赋值兼容规则也适用于多重继承的组合

5. 有关运算符重载正确的描述是（  ）

A. C++语言允许在重载运算符时改变运算符的操作个数

B. C++语言允许在重载运算符时改变运算符的优先级

C. C++语言允许在重载运算符时改变运算符的结合性

D. C++语言允许在重载运算符时改变运算符的原来的功能

6. 下面描述中，表达错误的是（  ） 

A. 公有继承时基类中的public成员在派生类中仍是public的　　 

B. 公有继承是基类中的private成员在派生类中仍是private的　　 

C. 公有继承时基类中的protected成员在派生类中仍是protected的

D. 私有继承时基类中的public成员在派生类中是private的

7. 拷贝构造函数的参数是（  ）

A. 某个对象名        B. 某个对象的成员名 

C. 某个对象的引用名  D. 某个对象的指针名

8. 下列关于构造函数的描述中，错误的是（  ）

A．构造函数可以设置默认参数　   B.构造函数在定义类对象时自动执行

C．构造函数可以是内联函数　     D.构造函数不可以重载

9. 数组作为函数的形参时，把数组名作为实参，传递给函数的是（ ）

A．该数组的首地址               B．该数组的元素个数

C．该数组中的各元素值           D．该数组的大小

10. 通过一个析构函数调用虚函数时，C++系统对该调用采用(　)。

A. 动态联编  B. 静态联编  C. 不确定是哪种联编  D.函数重载

二、填空题（每空2分，共30分）

1．成员名限定的符号是          ，它可以在引用成员时避免          。

2．只有在          继承的情况下，基类和派生类之间才有赋值兼容性规则。

3. 模板分为        模板和        模板。

4. 在用class定义一个类时，数据成员和成员函数的默认访问权限是            。

5. 已知int DBL(int n){return n+n;}和long DBL(long n){return n+n;}是一个函数模板的两个实例，则该函数模板的定义是        。（要求写出函数模板的完整定义）

6. 静态数据成员必须在             进行初始化。

7. 含有纯虚函数的类称为             。

8. 若Queue是一个类，aQueue是它的一个对象，而且该类中定义了一个静态成员函数show()则在类外对该成员的函数进行调用的方式可以为           和          。

9. 定义内联函数所用的关键字为         ，定义友元所用的关键字为             。

10. 使用成员函数重载运算符时，若运算符是二元的，则参数表中有       个操作数，此时          作为此运算符的左操作数。

一、单项选择题（每题2分，共20分）

1．  D  2．   D   3．   C    4．  D     5．   D   

6．  B  7．   C    8．  D    9．  A     10．  B   

二、填空题（每空2分，共30分）

1.  ::      二义性   2.   公有    3.    类   函数   4.  private

5.  template T DBL(T n){return n+n;} 6.  类外     7.  抽象类    

8.  aQueue.show()      Queue::show() 9.  inline     friend  10．  1      当前对象  

一、单项选择题（每题2分，共20分）

1. 下面有关重载函数的说法中正确的是（  ） 

A．重载函数必须具有不同的返回值类型；　　

B．重载函数形参个数必须不同；　　 

C．重载函数必须有不同的形参列表　　

D．重载函数名可以不同； 

2. 使用string类建立对象的不正确方式是（）。

A. string str(“OK”)；   B. string str=”OK”； 

C. string str；           D. string str=’OK’;

3. 面关于C++中类的继承与派生的说法错误的是(   )

A．基类的protected成员在公有派生类的成员函数中可以直接使用

B．基类的protected成员在私有派生类的成员函数中可以直接使用

C．私有派生时，基类的所有成员访问权限在派生类中保持不变

D．继承可以分为单一继承与多重继承

4. 面向对象程序设计将数据与(      )放在一起，做为一个相互依存、不可分割的整体来处理。

A. 对数据的操作    B. 信息    C. 数据隐藏    D.数据抽象

5. 一个类的析构函数     。

A.唯一的       B.允许重载    C.至多可有两个    D.只能是缺省的

6. 下列各类函数中，(      )不是类的成员函数。

A. 构造函数      B. 析构函数   C.  友元函数   D. 拷贝构造函数

7. 在下面选项中，对类的拷贝构造函数的声明形式是（  ）

A．A::A(&)    B. A::A(constA&)    C. A::A(A)    D. void A::A(A&a)

8. 下面关于静态成员描述正确的是（  ）

A. 静态成员是对象的数据成员

B. 静态成员是对象的成员

C. 静态成员是对象的成员函数

D. 静态成员不是对象的成员

9. 下面关于关于成员函数特征的描述中，错误的是（   ）

A．成员函数不可以设置参数的默认值 

B．成员函数可以重载

C．成员函数可以是内联函数

D．成员函数可以是静态的

10. 下面叙述正确的是（   ）

A．基类的保护成员在派生类中仍然是保护的

B．基类的公有成员在派生类中仍然是公有的

C．基类的私有成员在派生类中是私有的

D．从基类派生时，可以有3种派生方法

一、单项选择题（每题2分，共20分）

1．  C  2．   D   3．   C    4．  A     5．   A   

6．  C  7．   B    8．  B    9．  A     10．  D   

1. class base { 

int a;

public:

int b;int f(int i,int j);

};

class derive:base{

int c;

public:

int base::b;           

base::f(int i,int j); 

}; 

[1]                        

[2]                        

2. #include

class A{

public:

    void A(int i=0){m=i;}

void show(){cout<    void ~A(){}

private:

    int m;  };

void main()

{

    A a(5);

    a.m+=10;

    a.show();

}

[3]                       

[4]                       

[5]                       

3. #include

using namespace std;

class base{

int a;

static int b;

public:

base(int m,int n):a(m),b(n){}

static int geta(){return a;}

static int getb(){return b;}

void show(){cout<};

base::int b=45;

void main(){}

[6]                       

[7]                       

[8]                       

[1] int base::b;           

[2] base::f(int i,int j);

[1]   base::b; （或访问声明仅仅调整名字的访问，不可为它说明任何类型）  

[2]   base::f;  （或访问声明不应说明函数参数）

[3] void A(int i=0){m=i;}

    [4] void ~A(){}

[5] a.m+=10;

[3]   构造函数去掉void（或构造函数不能指定返回值类型）

[4]    析构函数去掉void（或析构函数不能指定返回值类型）

[5]    对象不能访问私有成员 

[6] base(int m,int n):a(m),b(n){}

[7] static int geta(){return a;}

[8] base::int b=45;

[6]   不能通过构造函数初始化静态数据成员（只要把b(n)去掉即可） 

[7]   静态成员函数中不能引用非静态成员数据成员（或去掉static） 

[8]   int base::b = 45; 

1. Template

T fun(T x)

{

T  y;

y=T-2*x;

retrun y;

}

[1]                           

[2]                           

2. class base

{

public:

  f();

  f(int a);

  f(char *p);

};

class derive:base

{

public:

   void f(int s);

   base::f;

};

[3]                           

3. #include

class A

{ public:

       void setA(int);

       void showA();

    private:

       int a;

};

class B

{ public:

       void setB(int);

       void showB();

  private:

       int b;

};

class C : public A, private B

{   public:

       void setC(int, int, int);

       void showC();

    private:

       int c;

};

void  A::setA(int x)

{   a=x;  }

void B::setB(int x)

{   b=x;  }

void C::setC(int x, int y, int z)

{   

a=x;

     b=y;

     setA(x); 

     setB(y);  

     c=z;

}

[1] Template

[2] y=T-2*x;

[1]   改为template

[2]  T不能用作-的操作数  

[3] base::f;

[3]   派生类中具有与基类同名的函数，则基类中的此函数不能在派生类中进行访问声明

[4] a=x;

[5] b=y;

[6] obj.setB(6);

[7] obj.showB();

[8] return 0;

[4]    派生类不能访问基类A类的私有成员

[5]    派生类不能访问基类B类的私有成员

[6]   不能访问B类的公有成员setB     

[7]   不能访问B类的公有成员showB    

[8]   去掉此语句，或主函数的返回值void去掉或改为int