PTA 友元、静态和常类型（一）（选择题解析）

 

2-1

下列函数中，（ ）不能重载。 (2分)

1. 成员函数
2. 非成员函数
3. 析构函数
4. 构造函数

正确答案：C

解析：

析构函数不可以被重载，因为析构函数只能有一个，且不能带参数。

2-2

下列对重载函数的描述中，（ ）是错误的。 (2分)

1. 重载函数中不允许使用默认参数
2. 重载函数中编译根据参数表进行选择
3. 不要使用重载函数来描述毫无相干的函数
4. 构造函数重载将会给初始化带来多种方式

正确答案：A

解析：

重载函数可以使用默认参数。

2-3

在下列关键字中,用以说明类中公有成员的是（ ）。 (2分)

1. public
2. private
3. protected
4. friend

正确答案：A

2-4

设A为自定义类，现有普通函数int fun(A& x)。则在该函数被调用]时： (2分)

1. 将执行复制构造函数来初始化形参x
2. 仅在实参为常量时，才会执行复制构造函数以初始化形参x
3. 无需初始化形参x
4. 仅在该函数为A类的友元函数时，无需初始化形参x

正确答案：C

解析：引用仅是变量的别名，而不是实实在在地定义了一个变量，因此引用本身并不占用内存，而是和目标变量共同指向目标变量的内存地址.引用仅是变量的别名，而不是实实在在地定义了一个变量，因此引用本身并不占用内存，而是和目标变量共同指向目标变量的内存地址.

 

 

 

 

2-5

以下哪一个不是正确的成员访问属性。 (2分)

1. protected
2. private
3. hidden
4. public

正确答案：C

2-6

所有类都应该有： (2分)

1. 构造函数
2. 析构函数
3. 构造函数和析构函数
4. 以上答案都不对

正确答案：C

解析:

当用户没有定义构造函数和析构函数时编译器会自动添加默认的构造函数和析构函数。但是某些情况下，由于成员的特殊性，需要自己进行构造函数与析构函数的编写。

2-7

析构函数可以返回： (2分)

1. 指向某个类的指针
2. 某个类的对象
3. 状态信息表明对象是否被正确地析构
4. 不可返回任何值

正确答案：D

2-8

对于以下关于友元的说法 (2分)

1. 如果函数fun被声明为类A的友元函数，则该函数成为A的成员函数
2. 如果函数fun被声明为类A的友元函数，则该函数能访问A的保护成员，但不能访问私有成员
3. 如果函数fun被声明为类A的友元函数，则fun的形参类型不能是A。
4. 以上答案都不对

正确答案：D

解析：

A.友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。

B.类授予它的友元特别的访问权，这样该友元函数就能访问到类中的所有成员。

C.如果函数fun被声明为类A的友元函数，则fun的形参类型可以是A。

2-9

对于类之间的友元关系： (2分)

1. 如果类A是类B的友元，则B的成员函数可以访问A的私有成员
2. 如果类A是类B的友元，则B也是A的友元。
3. 如果类A是类B的友元，并且类B是类C的友元，则类A也是类C的友元。
4. 以上答案都不对。

正确答案：D

解析：

A.友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。
B.友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
C.友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。

2-10

友元的作用是 (2分)

1. 提高程序的运用效率
2. 加强类的封装性
3. 实现数据的隐藏性
4. 增加成员函数的种类

正确答案：A

2-11

给定以下类声明，哪个成员函数可能改变成员变量data? (2分)

class A {

public:

 void f1 (int d);

 void f2 (const int &d);

 void f3 (int d) const;

private:

   int data;

};

1. f1
2. f2
3. f3
4. f1和f2

正确答案：B

解析：

f2函数中使用了引用，对形参d的改变，就是对实参的改变。

2-12

假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（） (2分)

1. x.a
2. x.a()
3. x->a()
4. (*x).a()

正确答案：B

解析：

x.a( )或（&x)->a( )。

2-13

静态成员函数没有： (2分)

1. 返回值
2. this指针
3. 指针参数
4. 返回类型

正确答案：B

解析：

类的静态成员变量是直接与类联系，属于类的成员而不是对象，供所有对象共享，存放于全局区，因而不计入类的内存计算。静态成员函数类似于静态成员变量都属于类而不是对象，不具有this指针。

2-14

下面关于友元的描述中，错误的是： (2分)

1. 友元函数可以访问该类的私有数据成员
2. 一个类的友元类中的成员函数都是这个类的友元函数
3. 友元可以提高程序的运行效率
4. 类与类之间的友元关系可以继承

正确答案：D

解析：

友元关系不能被继承。

2-15

已知类A是类B的友元，类B是类C的友元，则： (2分)

1. 类A一定是类C的友元
2. 类C一定是类A的友元
3. 类C的成员函数可以访问类B的对象的任何成员
4. 类A的成员函数可以访问类B的对象的任何成员

正确答案：D

解析：

A.B友元关系不具有传递性。若类A是类B的友元，类B是C的友元，类A不一定是类C的友元，同样要看类中是否有相应的申明。

C.D友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。

2-16

某类中有一个无参且无返回值的常成员函数 Show，则正确的 Show 函数原型是 (2分)

1. const void Show();
2. void const Show();
3. void Show() const;
4. void Show(const);

正确答案：C

解析：

类的常成员函数声明样式为：返回类型 <类标识符::>函数名称(参数表) const

2-17

下列属于类的析构函数特征的是 (2分)

1. 一个类中只能定义一个析构函数
2. 析构函数名与类名不同
3. 析构函数的定义只能在类体内
4. 析构函数可以有一个或多个参数

正确答案：A

解析：

B.析构函数名与类名相同。

C.析构函数的定义可以在类外，但是声明要在类内。

D.析构函数无参数。

2-18

建立一个类对象时，系统自动调用 (2分)

1. 构造函数
2. 析构函数
3. 友元函数
4. 成员函数

正确答案：A

2-19

下列各类函数中，不是类的成员函数的是 (2分)

1. 构造函数
2. 析构函数
3. 友元函数
4. 拷贝构造函数

正确答案：C

2-20

下面对静态数据成员的描述中，正确的是 (2分)

1. 静态数据成员是类的所有对象共享的数据
2. 类的每个对象都有自己的静态数据成员
3. 类的不同对象有不同的静态数据成员
4. 静态数据成员不能通过类的对象调用，只能通过“类名::标识符”调用

正确答案：A

解析：

B.类的所有对象共用静态数据成员

C.类的不同对象的静态数据成员相同。

D.静态数据成员可以通过类的对象调用，也可以通过“类名::标识符”调用

2-21

下列关于this指针的叙述中，正确的是 (2分)

1. 任何与类相关的函数都有this指针
2. 类的成员函数都有this指针
3. 类的友元函数都有this指针
4. 类的非静态成员函数才有this指针

正确答案：D

解析：

this只能在成员函数中使用。全局函数，静态函数都不能使用this。友元函数不是成员函数。

2-22

下面程序的输出结果是 (4分)

#include <iostream>

using namespace std;

 

class MyClass {

public:

    MyClass() {

        ++count;

    }

    ~MyClass() {

        --count;

    }

    static int getCount() {

        return count;

    }

private:

    static int count;

};

int MyClass::count = 0;

int main() {

    MyClass obj;

    cout << obj.getCount();

    MyClass obj2;

    cout << MyClass::getCount();

    cout << obj2.getCount();

    return 0;

}

1. 121
2. 232
3. 221
4. 122

正确答案：D

2-23

下列关于类定义的说法中，正确的是 (2分)

1. 类定义中包括数据成员和函数成员的声明
2. 类成员的缺省访问权限是保护的
3. 数据成员必须被声明为私有的
4. 成员函数只能在类体外进行定义

正确答案：A

解析：

B.类成员的缺省访问权限是私有的。

C.数据成员可以被声明为任何访问属性。

D.成员函数可以在类体外进行定义，也可以在类内定义。

2-24

下列关于类和对象的叙述中，错误的是 (2分)

1. 一个类只能有一个对象
2. 对象是类的具体实例
3. 类是对某一类对象的抽象
4. 类和对象的关系是一种数据类型与变量的关系

正确答案：A

解析：

一个类有多个对象

2-25

下面关于成员函数和常成员函数的程序，输出结果是 (4分)

#include<iostream>

using namespace std;

class MyClass {

public:

    MyClass(int x): val(x) {}

    void Print() const {cout << "const:val=" << val << '\t';}

    void Print() {cout << "val=" << val << '\t';}

private:

    int val;

};

int main() {

    const MyClass obj1(10);

    MyClass obj2(20);

    obj1.Print();

    obj2.Print();

    return 0;

}

1. val=10 const:val=20
2. const:val=10 const:val=20
3. const:val=10 val=20
4. val=10 val=20

正确答案：C

2-26

以下说法中正确的是。 (3分)

1. static数据成员存在于类类型的每个对象中
2. 每个static数据成员既可以与类相关联，也可以与类的对象相关联
3. static成员函数可以直接访问所属类的static成员，也可以直接使用非static成员
4. 成员函数无法拥有this形参

正确答案：D

解析：

A.static数据成员存在于类类型的每个对象中。

B. 对多个对象来说，静态数据成员只存储一处，供所有对象共用。所以，static成员是与特定类关联的，并不与类的对象关联。

C.static成员函数可以直接访问所属类的static成员，不可以使用非static成员。

D.static成员函数无法拥有this形参。

2-27

类的析构函数的作用是____。 (2分)

1. 一般成员函数
2. 类的初始化
3. 对象的初始化
4. 资源清理

正确答案：D

2-28

以下说法正确的是（）。 (2分)

1. 每个对象内部都有成员函数的实现代码
2. 一个类的私有成员函数内部不能访问本类的私有成员函数
3. 类的成员函数之间可以相互调用
4. 编写一个类时，至少要写一个成员函数

正确答案：C

解析：

A.成员函数的实现代码可以写在类外。

B.一个类的私有成员函数内部可以访问本类的私有成员函数。

D.一个类可以没有成员函数和属性。

2-29

以下对类A的定义中正确的是（） (2分)

1. class A{private：int v;public : void Func(){}}
2. class A{private : int v;A *next;};
3. class A{int v;public:void Func();};A::void Func(){}
4. class A{int v;public: A next;void Func(){ }};

正确答案：

A.class A{private：int v;public : void Func(){}};

C.class A{int v;public:void Func();};void A::Func(){}

D.class A{int v;public: A *next;void Func(){ }};

2-30

假如有以下类A：

classA{

     public：

 int func（int a){return a*a;）

};

以下程序片段中不正确的是（ ）(2分)

1. A a;a.func(5);
2. A*p=new A; p->func(5);
3. A a; A& r=a;r.func(5);
4. A a,b; if(a!=b) a.func(5);

正确答案：D

解析：

a,b为类A的两个对象。a与b比较，“！=”要重载。