《面向对象程序设计》第3章类与对象(判断、选择、填空)-练习

1-1

常量对象可以使用常量成员函数。

| 参考答案

答案

2分

1-2

在定义常量成员函数和声明常量成员函数时都应该使用const关键字。

| 参考答案

答案

2分

1-3

对象间赋值将调用拷贝构造函数。

| 参考答案

答案

2分

1-4

对象数组生命期结束时,对象数组的每个元素的析构函数并不会都被调用。

| 参考答案

答案

2分

1-5

构造函数可以通过对象多次调用。

| 参考答案

答案

2分

1-6

有下面两种定义：

struct stu{char name[8];        int age;    char sex;        double height;    
};

class stu{
public:char name[8];int age;char sex;double height;
};

它们的含义是完全等价的，都包含了相同的数据项，只不过是两种不同的类型。

| 参考答案

答案

2分

1-7

如果只定义对象数组不进行初始化，此时调用的是有参构造函数。

| 参考答案

答案

2分

1-8

对象引用作为函数参数比用对象指针更方便些。

| 参考答案

答案

2分

1-9

指向对象数组的指针不一定必须指向数组的首元素。

| 参考答案

答案

2分

1-10

对静态数据成员初始化可以在类内进行。

| 参考答案

答案

2分

1-11

静态成员函数属于类而不是类的对象，没有this指针，静态成员函数中不能使用thiss指针。

| 参考答案

答案

2分

1-12

友元函数或友元类，虽然能够提高的运行效率和编程便捷性，但会对类的封装造成一定程度上的破坏，因此，在使用时应慎重。答案为T，分值为2分。

| 参考答案

答案

2分

1-13

对于类A，若其中的构造函数有A( )和A(int i=0,int y=0)，则在主程序中语句 “A a;”不会出现调用构造函数的二义性，可以正常运行。答案为F，分值为2分。

| 参考答案

答案

2分

1-14

当将一个类S定义为另一个类A的友元类时，类S的所有成员函数都可以直接访问类A的所有成员。

| 参考答案

答案

2分

1-15

内部静态类变量与自动类变量作用域不同，但是生存期相同。

| 参考答案

答案

2分

1-16

C++运算符new自动建立一个大小合适的对象并返回一个具有正确类型的指针。

| 参考答案

答案

2分

1-17

每个对象都有一个指向自身的指针，称为 this 指针，通过使用它来确定其自身的地址。

| 参考答案

答案

2分

1-18

类中的构造函数是一个特殊的成员函数，它由类的对象自动调用，它的作用是为对象分配内存空间，初始化类的数据成员并进行一些其它类的内部操作。

| 参考答案

答案

2分

1-19

当一个类对象的成员函数被调用时，该成员函数的 this指针指向调用它的对象。

| 参考答案

答案

2分

1-20

C++程序中，类的构造函数名与类名相同。

| 参考答案

答案

2分

1-21

已知class A中有数据成员int a，如果定义了A的两个对象a1，a2，它们各自的数据成员a的值可以不同.

| 参考答案

答案

5分

1-22

一个类的友元函数是这个类的成员。

| 参考答案

答案

2分

1-23

C++程序中，一个类的构造函数可以被重载。

| 参考答案

答案

2分

1-24

C++程序中，一个类的析构函数可以被重载。

| 参考答案

答案

2分

1-25

析构函数的作用主要是释放对象占用的资源。

| 参考答案

答案

2分

1-26

友元函数不是类的成员函数，只是独立于该类的一般函数。

| 参考答案

答案

2分

1-27

可以将一个类的成员函数(包括构造和析构函数)说明为另一个类的友元。

| 参考答案

答案

2分

1-28

如果A是B的友元类,那么B的成员函数可以访问A的私有成员。

| 参考答案

答案

2分

1-29

如果不希望某个对象的值被改变,则定义该对象的时候可以在前面加上const关键字。

| 参考答案

答案

2分

1-30

在类的成员函数说明后可以加const关键字,则该成员函数成为常成员函数。

| 参考答案

答案

2分

1-31

两个函数,名字和参数表都一样,但是一个带const,一个不带,不算重载。

| 参考答案

答案

2分

1-32

当用一个对象去初始化同类的另一个对象时,要调用拷贝构造函数。

| 参考答案

答案

2分

1-33

若new一个对象数组,那么用delete释放时应该写[]，否则只delete一个对象(调用一次析构函数)。

| 参考答案

答案

2分

1-34

当一个对象调用其成员函数时,编译器先将该对象的地址赋给 this 指针,然后调用成员函数,这样成员函数对对象的数据成员进行操作时,就隐含使用了 this 指针。

| 参考答案

答案

2分

1-35

静态成员用以解决同一个类的不同对象之间成员，包括数据成员和函数成员的共享问题。

| 参考答案

答案

2分

1-36

静态成员的特点是不管这个类创建了多少个对象,其静态成员在内存中只保留一份副本,这个副本为该类的所有对象共享,或者说静态成员为类所有。

| 参考答案

答案

2分

1-37

已知类 A 是类 B 的友元，类 B 是类 C 的友元，则类 A 一定是类 C 的友元。

| 参考答案

答案

2分

1-38

某类的友元类的所有成员函数可以存取或修改该类中的私有成员。

| 参考答案

答案

2分

1-39

对象数组的元素可以是不同类的对象。

| 参考答案

答案

2分

1-40

在生成对象数组时，将针对每个数组元素按其下标的排列顺序依次调用一次构造函数，调用的次数等于数组元素的个数。

| 参考答案

答案

2分

1-41

在定义对象数组时，可以直接进行初始化，也可以通过赋值语句实现赋值。

| 参考答案

答案

2分

1-42

对象数组在定义过程中进行元素的初始化时，调用无参构造函数。

| 参考答案

答案

2分

1-43

程序执行结束前，调用析构函数将数组中各个对象元素释放，释放顺序与创建对象的顺序相反。

| 参考答案

答案

2分

1-44

point （*p)[3];point是类名，p为对象指针数组。

| 参考答案

答案

2分

1-45

静态数据成员不属于某个对象，在给对象分配存储空间时，不包括静态数据成员所占的空间。

| 参考答案

答案

2分

1-46

静态成员函数的实现必须在类体外实现，不能在类体内实现。

| 参考答案

答案

2分

1-47

由于静态成员函数不属于某个特定的对象，因此。不能像一般的成员函数那样随意的访问对象中的非静态数据成员。只能引用类中声明的静态数据成员。如果要引用非静态数据成员，可通过对象引用。

| 参考答案

答案

2分

1-48

常数据成员的值必须初始化，且不能改变。

| 参考答案

答案

2分

1-49

在类中声明常数据成员时，只能通过构造函数成员初始化列表的方式来实现。

| 参考答案

答案

2分

1-50

常成员函数可以引用对象的数据成员，但是不能更新数据成员，也不能调用该类中非常成员函数。

| 参考答案

答案

2分

单选题80 分

2-1

设类AA已定义，假设以下语句全部合法，哪些语句会触发调用构造函数（）。

AA a; //1
AA b(12, 10); //2
AA c(b); //3
a.SetX(32); //4

1 和 2

1、2 和 3

全班

| 参考答案

答案

2分

2-2

关于存储类别的关键字

在声明类的数据成员时，可以使用 ▁▁▁▁▁ 关键字。

auto

extern

static

| 参考答案

答案

2分

2-3

下列关于this指针的叙述中，正确的是（）

任何与类相关的函数都有this指针

类的成员函数都有this指针

类的友元函数都有this指针

类非静态成员函数才有this指针

| 参考答案

答案

2分

2-4

对类的构造函数和析构函数描述正确的是（）

构造函数可以重载，析构函数不能重载

构造函数不能重载，析构函数可以重载

构造函数可以重载，析构函数也可以重载

构造函数不能重载，析构函数也不能重载

| 参考答案

答案

2分

2-5

假定MyClass为一个类，则该类的复制构造函数的声明语句为（）

MyClass(int x)

MyClass(MyClass x)

MyClass(const MyClass& x)；

MyClass(MyClass *x)

| 参考答案

答案

2分

2-6

假定MyClass为一个类,则执行MyClass a,b(3),*p；语句时,自动调用该类构造函数()次。

| 参考答案

答案

2分

2-7

下面对于友元函数描述正确的是()

友元函数的实现必须在类的内部定义

友元函数是类的成员函数

友元函数破坏了类的封装性和隐藏性

友元函数不能访问类的私有成员

| 参考答案

答案

2分

2-8

下面对静态数据成员的描述中，正确的是（）

静态数据成员是类的所有对象共享的数据

类的每个对象都有自己的静态数据成员

类的不同对象有不同的静态数据成员值

静态数据成员不能通过类的对象调用

| 参考答案

答案

2分

2-9

假设A 是一个类的名字，下面哪段程序不会调用A的复制构造函数？

A a1,a2; a1 = a2;

void func( A a) { cout << "good" << endl; }

A func( ) { A tmp; return tmp; }

A a1; A a2(a1);

| 参考答案

答案

2分

2-10

在类体内说明友元使用的关键字是?

virtual

friend

inline

static

| 参考答案

答案

2分

2-11

关于友元函数的描述中，错误的是?

友元函数不是成员函数

友元函数必须在类体内定义

友元函数可以访问类的私有数据成员

友元函数破坏了类的封装

| 参考答案

答案

2分

2-12

已知类 A 是类 B 的友元，类 B 是类 C 的友元，下列说法正确的是？

类A的成员函数能访问类C的私有成员

C 一定是类 A 的友元

C 的成员函数可以访问类 B 的对象的任何成员

A 的成员函数可以访问类 B 的对象的任何成员

| 参考答案

答案

2分

2-13

关于友元函数的描述中，错误的是?

友元函数不是成员函数

友元函数只可访问类的私有成员

友元函数的调用方法同一般函数

友元函数可以是另一类中的成员函数

| 参考答案

答案

2分

2-14

友元的作用是？

提高程序的运用效率

加强类的封装性

实现数据的隐藏性

增加成员函数的种类

| 参考答案

答案

2分

2-15

有如下类的定义：

class Sample
{
public:Sample( );Sample(int x );......
};

动态申请对象存储单元，调用一个带参构造函数，初值为2的语句是（）。

Sample *a=new Sample(2);

Sample a=new Sample(2);

Sample *a=new Sample[2];

Sample a=new Sample[2];

| 参考答案

答案

2分

2-16

有如下定义：

class Sample
{
public:Sample( );Sample(int x );......
};

如果用new创建对象数组，该数组中包含10个对象，则正确的语句为（）。

Sample *a=new Sample[10];

Sample *a=new Sample(10);

Sample *a=new Sample[ ];

Sample *a=new Sample;

| 参考答案

答案

2分

2-17

句“void Set(A &a);”是类A中的一个成员函数的声明，其中A &a的含义是（）。

类A的对象引用a作该函数的参数

类A的对象a的地址值做函数的参数

表达式变量A与变量a按位与作函数参数

指向类A对象指针a作函数参数

| 参考答案

答案

2分

2-18

对于常数据成员，下面描述正确的是（）。

常数据成员可以不初始化，并且不能更新

常数据成员必须被初始化，并且不能更新

常数据成员可以不初始化，并且可以被更新

常数据成员必须被初始化，并且可以被更新

| 参考答案

答案

2分

2-19

在下面有关静态成员函数的描述中，正确的是（）。

在建立对象前，就可以为静态数据成员赋值

静态成员函数在类外定义时要用static前缀

静态成员函数只能在类外定义

在静态成员函数中可以使用this指针

| 参考答案

答案

2分

2-20

下列选项中，静态成员函数不能直接访问的是（）。

静态数据成员

静态成员函数

类以外的函数和数据

非静态数据成员

| 参考答案

答案

2分

2-21

对于常成员函数，下面描述正确的是（）

常成员函数不能修改任何数据成员

常成员函数只能修改一般数据成员

常成员函数只能修改常数据成员

常成员函数只能修改常对象的数据成员

| 参考答案

答案

2分

2-22

类成员默认的访问属性

类成员默认的访问属性为 ▁▁▁▁▁。

private

protected

public

friend

| 参考答案

答案

2分

2-23

下列特性中，C与C++共有的是（）

继承

封装

多态性

函数定义不能嵌套

| 参考答案

答案

2分

2-24

C++提供的可有效分配对象空间的运算符是（）

delete

new

pos

auto

| 参考答案

答案

2分

2-25

为类提供对外接口的是（）

公有成员函数

私有成员函数

保护成员函数

友元函数

| 参考答案

答案

2分

2-26

若类A的构造函数定义为
A(int aa=1, int bb=0) { a = aa; b = bb; }
则执行：A x(4);后，x.a和x.b的值分别是（）

1,0

1,4

4,0

4,1

| 参考答案

答案

2分

2-27

若类A被说明成类B的友元，则（）。

类A的成员即类B的成员

类B的成员即类A的成员

类A的成员函数不能访问类B的成员

类B不一定是类A的友元

| 参考答案

答案

2分

2-28

下列哪一种情况下，类的复制构造函数不会被调用

用类的一个对象赋值给另一个对象时

当用类的一个对象去初始化该类的另一个对象时

如果函数的形参是类的对象，调动函数时，进行形参和实参结合时

如果函数的返回值是类的对象，函数执行完成返回调用者时

| 参考答案

答案

2分

2-29

下列关于类和对象的描述正确的是( )。

类和对象没有区别

系统要为类和对象分配存储空间

对象是类的实例,系统为对象分配存储空间而不为类分配存储空间

类是对象的实例,系统为类分配存储空间而不为对象分配存储空间

| 参考答案

答案

2分

2-30

关于类的析构函数描述正确的是。

析构函数可以有参数

析构函数可以重载

析构函数可以省略

析构函数有返回值类型

| 参考答案

答案

2分

2-31

关于常成员的描述中,哪个是错误的?

常成员是用关键字const说明的

常成员有常数据成员和常成员函数两种

常数据成员的初始化是在类体内定义它时进行的

常数据成员的值是不可以改变的

| 参考答案

答案

2分

2-32

关于常对象的描述正确的是( ).

常对象可以调用所有的成员函数

常对象只能调用常成员函数

常对象的值可以在程序执行过程中发生改变

常对象在定义时可以不初始化

| 参考答案

答案

2分

2-33

子对象的初始化是通过( )来实现的.

构造函数

成员函数

构造函数的成员初始化列表

友元函数

| 参考答案

答案

2分

2-34

关于运算符delete的描述中,错误的是( ).

使用该运算符可以释放用new运算符创建的对象或对象数组

使用该运算符可以释放所有对象

使用delete运算符时会自动调用析构函数

用它释放对象数组时,它作用的指针名前要加运算符[ ]

| 参考答案

答案

2分

2-35

关于运算符new的描述中,错误的是( )。

它可以创建对象或变量

它可以创建对象数组或一般类型数组

用它创建对象或对象数组时要调用相应的构造函数

用它创建的对象可以不用delete运算符释放

| 参考答案

答案

2分

2-36

如果某函数的返回值是个对象，则该函数被调用时，返回的对象？

是通过拷贝构造函数初始化的

是通过无参数的构造函数初始化的

用哪个构造函数初始化，取决于函数中return 语句是怎么写的

不需要初始化

| 参考答案

答案

2分

2-37

关于成员函数特征的描述中，（）是错误的。

成员函数可以重载

成员函数一定是内联函数

一个类可以没有成员函数

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

| 参考答案

答案

2分

2-38

类的析构函数是在什么时候调用的？

类创建时

创建对象时

删除对象时

不自动调用

| 参考答案

答案

2分

2-39

C＋＋函数的声明和定义可以分开。函数声明不需要( )。

返回类型

函数名

参数表

函数体

| 参考答案

答案

2分

2-40

引入友元的主要目的是为了

增强数据安全性

提高程序的可靠性

提高程序的效率和灵活性

保证类的封装性

| 参考答案

答案

2分

填空题74 分

4-1

写出下面程序的执行结果。

#include <iostream>
using namespace std;
class CSample {int x;public: CSample() { cout<<"C1"<<endl;}CSample(int n ) {x = n;cout<<"C2,x="<<x<<endl;}
};
int main()
{
CSample array1[2];
CSample array2[2] = {6,8};
CSample array3[2] = {12};
return 0;
}

(2分)

| 参考答案

填空#1

填空#2

填空#3

C2,x=6

填空#4

C2,x=8

填空#5

C2,x=12

填空#6

12分

4-2

下面程序的运行结果。

#include <iostream>
using namespace std;
class B
{public:B(){cout<<++b<<endl;}~B(){cout<<--b<<endl;}static int Getb(){return b;}private:static int b;
};
int B::b=10;
int main()
{B b1,b2,b3;cout<<B::Getb()<<endl;return 0;
}

程序结果为：

(2分)

(2分) 。

| 参考答案

填空#1

填空#2

填空#3

填空#4

填空#5

填空#6

填空#7

14分

4-3

写出下面程序的运行结果。

#include<iostream>
using namespace std;
class A
{public:A(int i){a=i;}void print(){    cout<<"a="<<a<<endl;cout<<"this->a="<<this->a<<endl;}private:int a;
};
int main()
{A x(55);x.print();return 0;
}

运行结果为：

a=(2分)

this->a=(2分)

| 参考答案

填空#1

填空#2

4分

4-4

有如下程序：请写出程序输出结果。

class Test
{
public:Test(){cout<<"构造函数"<<endl;}        ~Test(){cout<<"析构函数"<<endl;}    
};
void myfunc(){static Test obj;
}
int main()
{cout<<"main开始"<<endl;myfunc();cout<<"main结束"<<endl;return 0；
}

(2分)

| 参考答案

填空#1

main开始

填空#2

构造函数

填空#3

main结束

填空#4

析构函数

8分

4-5

写出下面程序的执行结果。

#include<iostream> 
using namespace std;
class Cla 
{static int n;
public:Cla(){n++;}        ~Cla(){n--;}    static int get_n(){        return n;    }
};
int Cla::n=0;int main( )
{Cla *p=new Cla;delete p;cout<<"n="<<Cla::get_n()<<endl;return 0;
}

(2分)

| 参考答案

填空#1

n=0

2分

4-6

阅读分析下列程序的运行结果？

(1分)
(1分)
(1分)
(1分)
(1分)
(1分)

| 参考答案

填空#1

x=1

填空#2

x=10

填空#3

x=20

填空#4

x=30

填空#5

x=20

填空#6

x=30

6分

4-7

阅读分析下列程序的运行结果?

(1分)
(1分)
(1分)
(1分)
(1分)
(1分)

| 参考答案

填空#1

10 20

填空#2

100 2

填空#3

1000 2

填空#4

2 2

填空#5

abc

填空#6

abc abc abc

6分

4-8

阅读分析下列程序的运行结果？

(1分)
(1分)
(1分)
(1分)
(1分)
(1分)

| 参考答案

填空#1

Label:apple constructor!

填空#2

Box width:3,height:4 constructor!

填空#3

Label:no name constructor!

填空#4

Box width:10,height:10 constructor!

填空#5

Box(10,10) destructor!Label(no name) destructor!

填空#6

Box(3,4) destructor!Label(apple) destructor!

6分

4-9

阅读分析下列程序的运行结果？

吧.png

(2分)
(2分)
(2分)
(2分)
(2分)
(2分)
(2分)

| 参考答案

填空#1

构建日期:2023年1月1日

填空#2

拷贝日期:2023年1月1日

填空#3

拷贝日期:2023年1月1日

填空#4

2023年1月1日结束

填空#5

计算机年会:2023年1月1日

填空#6

2023年1月1日结束

填空#7

2023年1月1日结束

14分

4-10

write the output of the code below.

#include <iostream>  
using namespace std;
class MYCLASS{
public:MYCLASS(int x):val(x){}void print() const{cout << val << endl;}void print(){cout << val << endl;}
private:int val;
}; 
int main()
{MYCLASS ob1(1);const MYCLASS ob2(2);ob2.print();ob1.print();return 0;
}

One for each line.

line 1: (1分)
line 2: (1分)

| 参考答案

填空#1

填空#2

2分

程序填空题53 分

5-1

将空白的地方填写完整，使程序完成指定的功能。

#include <iostream>
using namespace std;
class Student{public:(5分)//利用参数初始化表进行数据初始化void display();private:int num;float score;};void Student::display(){cout<<num<<" "<<score<<endl;}int main()
{Student stud[5]={Student(101,78.5),Student(102,85.5),Student(103,98.5),Student(104,100.0),Student(105,95.5)}; //定义对象数组(5分)//定义对象指针指向对象数组for((5分))//显示第1、3、5名学生信息p->display();return 0;}
}

| 参考答案

填空#1

Student(int n,float s):num(n),score(s){}

填空#2

Student *p=stud;

填空#3

int i=0;i<=2;p=p+2,i++

15分

5-2

填写程序中的空白，完成指定的功能。

#include<iostream>
using namespace std;
class R{int len,w;
public:R(int len,int w);int getArea();
};
R::R(int len,int w){(2分)(2分)
}
int R::getArea(){return (this->len)*(this->w);
}
int main(){R r1(2,5),r2(3,6);cout<<"First Area is "<<(2分)<<endl;cout<<"Second Area is "<<(2分)<<endl;return 0;
}

####输出数据如下：

First Area is 10
Second Area is 18

| 参考答案

填空#1

this->len=len;

填空#2

this->w=w;

填空#3

r1.getArea()

填空#4

r2.getArea()

8分

5-3

填充程序空白，完成指定的输出。

using namespace std;
class A{int i;
public:A(int k=0){i=k;}void display(){cout<<"i="<<i<<endl;}
};
int main()
{(2分)//动态创建对象pp->display();(2分)//删除对象pp=new A(8);p->display();delete p;(2分)//p指向对象数组A *q=p;for(int i=0;i<3;i++){(2分)//输出对象数组数据}(2分)//删除对象数组指针preturn 0;
}

###程序输出如下：

i=0
i=8
i=0
i=0
i=0

| 参考答案

填空#1

A *p=new A;

填空#2

delete p;

填空#3

p=new A[3];

填空#4

q++->display();

填空#5

delete []p;

10分

5-4

填写程序中的空白，完成指定的功能

#include<iostream>
using namespace std;
class Point{double x,y;(2分)//定义静态变量
public:Point(double a=0,double b=0):x(a),y(b){(2分)}~Point(){(2分)}void show(){cout<<"the number of Point is "<<(2分)<<endl;}
};
(2分)
int main(){Point p1;Point *p=new Point(1,2);p->show();delete p;p1.show();return 0;

####程序输出如下：

the number of Point is 2
the number of Point is 1

| 参考答案

填空#1

static int cnt;

填空#2

cnt++;

填空#3

cnt--;

填空#4

cnt

填空#5

int Point::cnt=0;

10分

5-5

下列程序接收若干用户的姓名和电话，然后进行输出。

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;
const int N=5; 
class CPerson
{char name[10];    char num[10];
public:void get_data((2分)){strcpy(name,na);strcpy(num,nu);}void put_data(CPerson pn[N]);
};
void CPerson::put_data(CPerson pn[N])
{    int i;for(i=0;i<N;i++){  cout.width(5); (2分);cout.width(5);(2分)}
}
int main()
{char *na[5]={"li","zh","wu","xie","liu"};char *nu[5]={"01","02","03","04","05"};CPerson obj[5];    //对象数组for(int i=0;i<5;i++)    obj[i].get_data(na[i],nu[i]);
(2分)  *pt=obj;    
(2分)  return 0;
}

输入样例：

无输入

输出样例：

   li   01zh   02wu   03xie   04liu   05

| 参考答案

填空#1

char* na,char* nu

填空#2

cout<<pn[i].name

填空#3

cout<<pn[i].num<<endl;

填空#4

CPerson

填空#5

pt->put_data(pt);

10分