北京化工大学《面向对象程序设计》期末考试试题&解析 (上)

Selwyn NG

已于 2024-05-19 15:18:55 修改

阅读量1.9k

点赞数 34

文章标签： c++

于 2024-05-19 15:12:14 首次发布

本文链接：https://blog.csdn.net/weixin_74822933/article/details/139033031

版权

一、判断题

返回值类型、参数个数和类型都相同的函数也可以重载。

答案：×
解析：函数重载要求函数有不同的参数类型或参数个数。仅返回值不同无法构成重载。

例子：
int func(int a);
double func(int a); // 这是非法的重载，因为参数相同，仅返回类型不同

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

答案：×
解析：友元函数虽然可以访问类的私有成员，但它不是类的成员函数。

例子：
class MyClass {
    friend void friendFunction(MyClass &obj); // friendFunction 是友元函数
    private:
        int privateData;
};

void friendFunction(MyClass &obj) {
    obj.privateData = 10; // 可以访问私有成员
}

在同一个类中，可以定义重载的成员函数 void f(int); 和 virtual void f(int);

答案：×
解析：virtual 关键字并不会改变函数签名，因此无法通过这种方式实现函数重载。

例子：
class MyClass {
    void f(int); // 成员函数
    virtual void f(int); // 错误：无法重载
};

多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生类构造函数中所定义的成员初始化列表的各项顺序无关。

答案：√
解析：构造函数的执行顺序由基类在派生类中的声明顺序决定。

例子：
class Base1 {};
class Base2 {};
class Derived : public Base1, public Base2 {
    Derived() : Base2(), Base1() {} // 基类的构造顺序是先Base1再Base2
};

代码语句 A a1 = a2;触发的是类 A 的拷贝构造函数而非赋值运算符函数。

答案：√
解析：在对象声明时用另一个对象初始化，会调用拷贝构造函数。

例子：
class A {
    A(const A&); // 拷贝构造函数
};
A a1;
A a2 = a1; // 调用拷贝构造函数

如果类 A 的声明代码中未定义构造函数，则代码语句 A a; 一定会报错。

答案：×
解析：如果没有定义构造函数，编译器会生成一个默认的无参构造函数，因此不会报错。

例子：
class A {};
A a; // 不会报错，使用编译器生成的默认构造函数

抽象类指的是包含纯虚函数的类，抽象类无法用于实例化对象。

答案：√
解析：抽象类包含纯虚函数，不能直接实例化。

例子：
class AbstractClass {
    virtual void pureVirtualFunction() = 0; // 纯虚函数
};
AbstractClass obj; // 错误：不能实例化抽象类

C++语言程序代码是由函数和类构成的，其中类是对象的抽象、函数是过程的抽象，所以 C++语言是不完全的面向对象程序设计语言。

答案：√
解析：C++既支持面向对象编程，也支持面向过程编程。

例子：
class MyClass {
    void memberFunction() {} // 类和成员函数表示面向对象
};

void globalFunction() {} // 全局函数表示面向过程

一个类可以定义多个构造函数，但只能定义一个析构函数。

答案：√
解析：构造函数可以重载，但析构函数不允许重载，每个类只能有一个析构函数。

例子：
class MyClass {
    MyClass() {} // 构造函数
    MyClass(int a) {} // 重载的构造函数
    ~MyClass() {} // 析构函数
};

在保护继承方式下，基类中保护成员在派生类中转为公有成员。

答案：×
解析：在保护继承下，基类的保护成员在派生类中仍然是保护成员。

例子：
class Base {
    protected:
        int protectedData;
};
class Derived : protected Base {
    void access() {
        int data = protectedData; // 仍然是保护成员
    }
};

二、单项选择题

1.下面关于 return 语句的描述中，错误的是（D）：

A、被调用的函数可以不使用 return 语句
B、被调用函数可以使用多个 return 语句
C、被调用函数中，如果有返回值就一定要使用 return 语句

D、被调用函数可以使用 return 语句返回多个值给调用函数

答案：D
解析：C++函数不能通过 return 语句返回多个值。

例子：
int func() {
    return 1; // 返回单个值
}

2.下列哪一项具有对当前类私有成员的访问权限（C）：

A、当前类的对象
B、派生类对象引用
C、当前类的成员函数

D、基类指针

答案：C
解析：只有当前类的成员函数可以访问私有成员。

例子：
class MyClass {
    private:
        int privateData;
    public:
        void memberFunction() {
            privateData = 10; // 访问私有成员
        }
};

3.副本（拷贝）构造函数的形参原则上要求是（D）：

A、对象名
B、对象的成员名
C、对象的指针

D、对象的引用

答案：D
解析：拷贝构造函数的参数应该是对象的引用，以避免递归调用构造函数。

例子：
class MyClass {
    MyClass(const MyClass& other); // 拷贝构造函数
};

4.(A)是拥有属性和行为或方法的实体：

A、对象
B、类
C、方法

D、构造方法

答案：A
解析：对象是类的实例，拥有属性和方法。

例子：
class MyClass {
    int attribute; // 属性
    void method() {} // 方法
};

MyClass obj; // 对象

5.当在类中定义两个及以上方法，这些方法有相同的名称但参数列表不同时，这称为（D）：

A、继承
B、多态性
C、构造方法

D、函数重载

答案：D
解析：这被称为函数重载。

例子：
class MyClass {
    void method(int a) {}
    void method(double b) {} // 函数重载
};

6.（B）修饰符允许对类成员的访问不依赖于该类的任何对象：

A、protected
B、static
C、return

D、public

答案：B
解析：static 修饰符使成员独立于任何对象。

例子：
class MyClass {
    static int staticData;
};
int MyClass::staticData = 0; // 静态成员独立于对象

7.用 static 修饰符描述的数据成员，其初始化必须在（B）：

A、类内
B、类外
C、在构造函数内

D、静态成员函数内

答案：B
解析：静态成员变量的初始化必须在类外。

例子：
class MyClass {
    static int staticData;
};
int MyClass::staticData = 0; // 类外初始化

8.针对 C++语言多态性，以下选项中，实现多态性方式与其他选项不同的是（C）：

A、函数重载
B、模板
C、虚函数

D、运算符重载

答案：C
解析：虚函数实现的是运行时多态性，而其他选项实现的是编译时多态性。

9.以下情形中，不会出现二义性问题的是（B）：

A、多个函数具有相同函数名，但返回值类型不同
B、多个函数具有相同函数名，但形参类型不同
C、继承多个基类，不同基类中具有相同成员名

D、继承多个基类，而基类中有多个基类由同一个类派生而来

答案：B
解析：多个函数具有相同函数名但形参类型不同，不会导致二义性。

例子：
class MyClass {
    void method(int a) {}
    void method(double b) {} // 不会产生二义性
};

10.关于虚函数描述不正确的是（D）：

A、虚函数是用 Virtual 关键字修饰的
B、对虚函数的调用都是动态联编
C、Virtual 关键字提示编译器该函数进行动态联编

D、只有当访问虚函数是通过基类指针（或引用）时才可获得运行时的多态性

答案：D
解析：虚函数的动态联编需要通过基类指针或引用来实现多态性。

例子：
class Base {
    virtual void virtualFunction() {}
};
class Derived : public Base {
    void virtualFunction() override {}
};
Base *ptr = new Derived();
ptr->virtualFunction(); // 动态联编