长安大学期末考试C++样题

样题1试题

一. 单选题（所选字母填写在（）内；每1小题分，共10分）

1. 已知: int x, y;下列表达式中，非法的是( ) 。

A. x%y

B. y=-x

C. --(x*y)

D. x+=y

2. 已知: int x, y;下列循环的执行次数是( ) 。

for(x(0),y(0);!y&&x<=5;x++,y++)

{ … }

A．1 B. 2 C. 5 D. 无限

3. 己知: int a ,*p; 下列操作中，非法的是( ) 。

A. p=a

B. p=&a

C. *p=9

D. p!=a;

4．下列有关语句的描述中，错误的是（）。

A．条件语句中，else子句可以有0个或1个

B．Continue语句只能出现在循环体内

C．Switch语句不能出现在循环体内

D．循环语句可以自身嵌套，也可以相互嵌套

5．下列关于构造函数的描述中，错误的是（）。

A．构造函数是没有名字的 B．构造函数是可以重载的

C．构造函数是系统自动调用的 D．构造函数是可以没有参数的

6．下列关于运算符new的描述中，错误的是（）。

A．new运算符用来创建动态对象

B．new运算符用来创建堆对象时可进行初始化

C．用new运算符创建的对象可用delete运算符释放

D．用new运算符可创建对象数据，并可同时进行初始化

7．下列关于公有继承方式下基类成员在派生类中访问性的描述，其中错误的是（）。

A．基类中私有成员在派生类中为私有成员

B．基类中公有成员在派生类中为公有成员

C．基类中保护成员在派生类中为保护成员

D．派生类中成员函数不能访问基类私有成员

8．类的构造函数的成员初始化列表中，不可以包含（）。

A．基类构造函数 B．子对象类的构造函数

C．静态数据成员初始化 D．常数据成员的初始

9．已知：B类是A类的公有继承的派生类，下列描述中，错误的是

（）。

A．A类的对象就是B类的对象

B．B类对象可以给A类对象赋值

C．B类对象的地址值可以给A类对象指针赋值

D．B类对象可以给A类对象引用赋值

10．下列关于派生类定义格式的描述中，错误的是（）。

A．定义派生类可用关键字class或struct

B．定义派生类时要指出派生类的类名和基类的类名

C．定义派生类时一定要给出继承方式，不能默认

D．定义派生类时，类体中给出派生类的成员

二. 判断题(对者茌题号前划∨，错者划茌题号前×；每小题0.5分，共10分)

1．函数体和循环语句的循环体都可为空。

2．数组下标只能是常量，不能是表达式。

3．使用delete运算符释放一个用new创建的数组时，每次只能释放一个元素。

4．设置函数参数默认值只能用常量，不能用表达式。

5. 一个类的对象可以是该类的成员。

6. 内部静态对象是全局对象，因为它的寿命是长的。

7. 引用是一种可做函数参数的变量。

8．只有运算符++,--，才具有副作用。

9. 构造函数与拷贝构造函数的名字都与类名相同。

10 友元函数只能访问类中的私有成员。

11．单继承中，一个派生类只有一个基类，而一个基类可以生成多个派生类。

12．派生类对基类成员的可访问性与派生类对象对基类成员的可访问性是相同的。

13．保护继承方式下，基类中公有成员和保护成员在派生类中都是保护成员。

14．在公有继承和保护继承方式下，基类中的公有成员在直接派生类和间接派生类中都是可访问的，而直接派生类和间接派生类的对象也可访问。

15．静态数据成员应该在构造函数的成员初始化列表中进行初始化。

16．友元函数是说明在类体内的成员函数，它的定义应在类体外。

17．用new创建的堆对象，在使用delete释放时必须是先创建的后释放，后创建的先释放。

18．在C++程序中，创建一个对象时系统自动调用构造函数进行初始化，如果一个类中没有定义构造函数，则无法创建对象。

19．友元类中的所有成员函数只能访问友元类所在类中的私有成员。

20．所有的成员函数都可以重载。

三.填空题（将适当的内容填写在下划线上面，每个空1分，共10分）

1．定义类A中有两个公有的成员函数，其中一个是构造函数，另一个是静态成员函数f1( )，还有两个私有的数据成员，一个是静态数据成员a，另一个类B的对象b。类B中有两个私有的数据成员。为满足上述要求，请填写下列程序的空白处。

……

A

{

int a；

b；

public：

（int i, int j）：

{ }

void f1（）

}；

……

2．P类公有继承Q类，P和Q类中都仅有一个私有的数据成员，P类中两个成员函数，一

个是构造函数，另一个友元函数fun( )。下列一段程序实现上述要求，请将空白处填上适当的内容。

……

class P

{

public：

P (int i, int j)

{ p=i; }

void fun();

private：

；

}；

……

四. 分析下列程序的输出结果（分析结果写在该程序左边或右边的空白处；

每小题5分，共30分）

1.

#include

void main()

{

int a=40;

while(--a)

{

if(a==20)

break;

if(a%2==0||a%3==0||a%5)

continue;

cout<

}

}

2．

#include

void main()

{

int x(5);

int & fun(int &);

int y=fun(x)--;

cout<

}

int w;

int & fun(int &i)

{

w=i*i;

return w;

}

3．

#include

int y=3;

int fun(int,int =2,int &c=y); void main()

{

int a(2),b(3),c(4);

int x=fun(a);

int y=fun(a,b);

int z=fun(a,b,c);

cout<

}

int fun(int a,int b,int &c) {

a=b; b=c; c=a;

cout<

return a+b+c;

}

4．

#include

class AB

{

public:

AB(int i,int j):b(j)

{ ab=i+2; cout<<"AB\n"; }

~AB()

{ cout<

friend int fun(AB &a);

private:

static int a;

int ab;

const int b;

};

int fun(AB &a)

{ return AB::a+a.b+a.ab; }

int AB::a(0);

void main()

{

AB a(2,3),b(4,5);

cout<

5．

#include

class PQ

{

public:

PQ(int i=0)

{ p=i; }

void print()

{ cout<

~PQ()

{ cout<<"PQ"<

int p;

};

PQ a(8);

void main()

{

PQ *p1,*p2;

p1=new PQ(7);

p2=new PQ[2];

p2[0]=a;

p2[1]=*p1;

(*p1).print();

p2[0].print();

p2[1].print();

delete p1;

delete [] p2;

}

6．

#include

class M

{

public:

M(int i)

{ a=i; }

void f1()

{ cout<

~M()

{ cout<<'M'<

protected:

};

class N:public M

{

public:

N(int i,int j,int k):M(i),aa(j)

{ b=k; }

void f1()

{

cout<

aa.f1();

cout<

}

~N()

{ cout<<'N'<

private:

M aa;

int b;

};

void fun(M a)

{

a.f1();

}

void main()

{

M a1(15);

N b1(13,15,17);

a1.f1();

b1.f1();

fun(b1);

}

五. 分析程序回答问题（共10分）#include class A

{

public:

A()

{ a1=a2=0; }

A(int i,int j)

{ a1=i; a2=j; }

~A()

{

cout<<"A\n"; }

{

a1=a.a1+2;a2=a.a2+2;

cout<<"C\n";

}

void print()

{ cout<

private:

int a1,a2;

};

void fun(A &a)

{

A b;

b=a;

b.print();

}

void main()

{ A x(4,8),y;

A p(x);

y=x;

fun(p);

y.print();

}

1.该程序调用了几次构造函数(全部)？（3分）

2.函数fun()中，b. print()输出值是多少？（3分）

3.该程序调用了几次拷贝构造函数？（4分）

六．简单回答问题（每小题回答结果写在该题下面空白处；每小题2分，共10分）

1.己知：int a=10,*pa=&a; 定义一个指针pa的引用ref，并计算表达式*ref*8的值。

2.．已知：A类中有一个成员函数说明如下：

int fun (int)；

请将该成员函数fun( )说明常成员函数，其格式如何？该函数的功能是返回该参数的平方，写出在类体外定义该函数的语句。

3．使用指针作函数参数和使用引用作函数参数有何不同？

4．在两个不同的类中，A类对象可以赋值给类B的对象，要求A类和B类有什么关系？

5．C++语言中有关函数定义方面与C语言有何不同？

样题1参考答案

一. 单选题（每1小题分，共10分）

1. C

2. A

3. B

4. C

5. A

6. D

7. A

8. C 8. A 10. B

二. 判断题(每小题0.5分，共10分)

对的有：2, 5, 8, 9, 11, 13, 14, 16, 20

三. 填空题（每个空1分，共10分）

1．

class A

{

static int a；

B b；

public：

A （int i, int j）：B(i,j)

{ }

static void f1（）

}；

2．

class P:public Q

{

public：

P (int i, int j) :Q(j)

{ p=i; }

friend void fun();

private：

int p ；

}；

四. 分析下列程序的输出结果（部分答对酌情给分；每小题全对5分，共30分）

1. 34

24

2.

25

3.

7

8

10

25

4.

AB

AB

7,11

6

4

5.

7

8

7

PQ7

PQ7

PQ8

PQ8

6.

15M

13

15M

17M

13M

M

M

N

M

M

五. 分析程序回答问题（共10分）

1.该程序调用了几次构造函数(全部)？（2分）

答：4次

2.函数fun ()中，b. print()输出值是多少？（2分）

答：12

3.该程序调用了几次拷贝构造函数？（2分）

答：1次

六．简单回答问题（每小题回答结果写在该题下面空白处；每小题2分，共10分）

1.己知：int a=10,*pa=&a; 定义一个指针pa的引用ref，并计算表达式*ref*8的值。

答：指针pa的引用ref定义如下： int *&ref=pa;

表达式*ref*8的值: 80

2.．已知：A类中有一个成员函数说明如下：

int fun(int)；

请将该成员函数fun( )说明常成员函数，其格式如何？该函数的功能是返回该参数的平方，写出在类体外定义该函数的语句。

答：常成员函数fun( )说明如下：

int fun(int) const;

在类体外该函数定义如下：

int A::fun(int a) const

{

return a*a;

}

3．使用指针作函数参数和使用引用作函数参数有何不同？

答：使用指针作函数形参时对应实参使用变量或对象的地址值，而使用引用作函数形参时对应实参使用变量或对象值。

4．在两个不同的类中，A类对象可以赋值给B类的对象，要求A类和B类有什么关系？

答：A类公有继承B类

5．C++语言中有关函数定义方面与C语言有何不同？

答：C++语言中函数定义肘时，不可缺省函数类型；函数体内说明语句位置不受限制函；数说明使用原型说明；可以定义重载函数；可以定义内联函数；可以设置函教参数的默认值。

样题2试题

一、判断题（对者在题号前划√，错者在题号前划×）(20分)

1.构造函数可以重载。

2.类的数据成员不一定都是私有的。

3.对象数组的元素应是同类的对象。

4.任意一种构造函数都具有转换类型功能。

5.在私有继承中，基类中只有公有成员对派生类是可见的。

6.引用可以作函数参数，不能作函数的返回值。

7.抽象类是不能创建对象的。

8.析构函数是不能被定义为虚函数的。

9.C++语言既支持单继承，又支持多继承。

10.put()函数只能从标准流对象cin中提取字符。

11．引用的值是不可以被改变的，它的值永远是被引用的变量的值。

12．定义一个对象时，系统总会对该对象进行初始化。

13．没有参数的构造函数称为默认构造函数，该构造函数一定是系统自动生成的。

14．在用一个对象给同类的另一个对象赋值时，调用拷贝初始化构造函数。

15．静态对象的成员称为静态成员。

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

17．this指针是指向对象的指针，是系统自动生成的。

18．运算符new可以创建对象，也可创建对象数组。

19．定义派生类时必须指出基类名和继承方式，二者都不可默认。

20．C++语言对标准文件的读写函数与对磁盘文件的读写函数是一致的。

二、填空题(20分)

1C++语言中，类的继承方式有三种，分别是____________、____________、_________________。

2定义静态成员使用______________关键字，静态成员是属于_______________的。

3堆对象的创建使用__________运算符，删除使用__________运算符。

4运算符重载的两种方式是___________ 和____________。

5含有___________的类称为抽象类。

三、单选填空题(20分)

1.关于new运算符的下列描述中，____是错误的。

A. 创建对象时必须指定初始值

B. 用它创建的对象应用delete来删除

C.可用它来创建动态对象

D. 创建对象时要调用构造函数

2.派生类的对它基类中____成员不可以访问。

A. 公有继承的公有

B. 公有继承的私有

C. 公有继承的保护

D. 私有继承的公有

3.关于派生类的下列描述中_____是错误的。

A. 派生类中继承基类成员的访问权限不变

B. 派生类至少有一个基类

C. 派生类还可作另一个派生类的基类

D. 派生类中包含它基类中的成员

4.下列对重载函数的描述中_____是正确的。

A. 运算符重载可以改变结合性

B. 运算符重载可以改变优先级

C. 运算符重载可以改变操作数的个数

D. 运算符重载不可以改变语法结构

5.在类体内说明虚函数使用的关键字是____。

A. virtual

B. friend

C. inline

D. static

6.下列关于构造函数的特征中，____是正确的。

A. 不可以重载

B. 不可以设置缺省参数

C. 与类名不同

D. 不说明其类型

7.己知：类Point中有一个成员函数说明如下

Point & Set(Point a);

下面对返回值的描述由_____是正确的。

A. 该函数无返回值

B. 该函数返回值是类Point对象

C.该函数返回值是类Point的对象的引用

D.该函数返回值是指向类Point的对象的地址

8.关于动态联编的下列描述中_____是错误的。

A.动态联编是以公有继承为基础的

B.动态联编是在运行中确定所选函数代码的

C.动态联编是在编译时确定所选函数代码的

D.动态联编要有虚函数

9.下列输出字符串”MN”的方法中，_____是正确的。

A. cout<

B. cout<<”MN”;

C. cout.put(“MN”);

D. cout<

10.下列打开磁盘文件的访问方式常量中，____是以读方式打开文件的。

A. out

B. in

C. ate

D. app

四、分析下列程序的输出结果(30分)

1.

#include

class M

{

int a;

public:

M(int i=15) {a=i; cout<<"in M\n";}

int geta() {return a;}

};

void main()

{

M r1,r2(18);

cout<

cout<

}

2.

#include

class A

{

double x;

public:

A(double i) { x=i; }

A operator +(A c)

{ return A(x*c.x); }

double Getx() { return x;}

};

void main()

{

A a(0);

a=A(3)+A(4);

cout<

}

3.

#include

class P1

{

public:

P1(int i) { p1=i; }

virtual int fun() { return p1;}

private:

int p1;

};

class P2:public P1

{

public:

P2(int i,int j):P1(i),p2(j) { }

int fun() { return p2;} private:

int p2;

};

void main()

{

P1 *pf=new P1(10);

P2 *pd=new P2(8,18);

P1 &b=*pd;

cout<fun()<

cout<

cout<<(*pd).fun()<

delete pf;

delete pd;

}

4.

#include

class A

{

tatic int N;

int *a;

public:

A(int k)

{

a=new int[N];

for(int j=0;j

a[j]=j+k;

}

int geta(int i)

{ return *(a+i);}

static int getN()

{ return N;}

~A()

{ cout<<"D\n"; delete [] a;} };

void main()

{

A x(6),y(9);

for(int i=0;i

cout<

}

int A::N=3;

5.

#include

class R

{

public:

R()

{ cout<<"in R\n"; }

virtual void fun(int i)

{ cout<<"R:"<

char *gun()

{ return "HELLO\n";}

};

class T:public R

{

public:

void fun(int i)

{ cout<<"T:"<

};

void f1(R &a)

{

a.fun(88);

cout<

}

void f2(R a)

{

a.fun(99);

cout<

}

void main()

{

T b1,b2;

f1(b1);

f2(b2);

}

五、简单回答下列问题(10分)

1.什么是友元函数？它有什么作用？

2.一个类的派生类是否还可以生成新的派生类？派生类的构造函数是否必须有成员

初始化列表？

3.静态数据成员有什么特点？如何引用静态数据成员？

4.静态联编与动态联编的主要区别是什么？虚函数是否是动态联编的唯一条件？

5.使用ifstream input; 写出以读方式打开一个磁盘文件abc.txt的语句。

样题2参考答案

一. 判断题(每小题1分，共20分)

对的有：1，2, 3, 7, 9, 12, 14, 16, 17, 18，20

二. 填空题（每个空2分，共20分）

1. public(公有方式),private(私有方式),protected(保护方式)

2. static,类

3. new,delete

4. 成员函数方式，友元函数方式

5. 纯虚函数

三. 单选题（每小题2分，共20分）

1. A

2. B

3. A

4. D

5. A

6. D

7. C

8. C

9. A 10. B

四. 分析下列程序的输出结果（部分答对酌情给分；每小题全对6分，共30分）

1.

in M

in M

17

18

2.

20

3.

10

18

18

4.

15

17

19

D

D

5.

in R

in R

T:88

HELLO

R:99

HELLO

五. 简单回答问题（每小题2分，共10分）

1.答：友元函数是说明在类体内的非成员函数。说明时前边加关键字friend。

友元函数可以访问该类中的所有成员，包括私有成员。说明友元函数就是为方便地访问类中私有成员。

2.答：一个派生类可以作为基类生成新的派生类。

派生类的构造函数通常为了对直接基类数据成员初始化而带有成员初始化列表。当直接基类中没有带参数的构造函数时，派生类的构造函数可以不带成员初始化列表，它隐含了基类的默认构造函数。

3.答：静态数据成员是属于类的，不是仅属于某个对象的。

静态数据成员可以使用对象名来引用，也可以使用类名加作用域的方法引用。

4.答：静态联编和动态联编的主要区别在于前者是在编译时进行联编，而后者是在运行时进行联编。

虚函数是动态联编的重要条件，但它不是唯一条件。动态联编还有其他不可缺少的条件，如公有继承等。

5.答： ifstream input;

input.open(“abc.txt”);