【期末不挂科-C++考前速过系列P2】大二C++第2次过程考核（20道选择题＆10道判断题＆3道代码题）【解析，注释】

前言

大家好吖，欢迎来到 YY 滴C++前速过系列 ，热烈欢迎！ 本章主要内容面向接触过C++的老铁

主要内容含：

一.单选题（20）

1.下列虚类的声明中正确的是（ ）D

A.class virtual B:public A

B.virtual class B:public A

C.class B:public A virtual

D.class B:virtual public A

2.基类中的（ ）不允许外界访问，但允许派生类的成员访问，这样既有一定的隐藏能力，又提供了开放的接口。D

A.共有成员

B.私有成员

C.私有成员函数

D.保护成员

3.设置虚基类的目的是()。B

A.简化程序

B.消除二义性

C.提高运行效率

D.减少目标代码

解析：

• 在多继承中，如果在多条继承路径上，有公共基类，这个公共基类便会产生多个副本。为了解决二义性问题，把公共基类定义为虚基类

4.如果try中不抛出异常，那么try块执行完后控制权会转向何处？A

A.catch后第一条语句

B.catch语句块第一条语句

C.throw语句

D.退出程序

解析：

如果try块中的代码没有抛出异常，则立即跳过try块后面的所有catch异常处理程序，执行catch后面的第一条语句

5.下列描述中，（ ）是抽象类的特征

A.可以说明虚函数

B.可以进行构造函数重载

C.可以定义友元

D.不能定义其对象

解析：D

6.C++中类的用途有两种：一种是类的实例化，即生成类的对象；另一种是通过（ ）派生出新类。B

A.复用

B.继承

C.封装

D.引用

7.继承具有（ ），即当基类本身也是某一类的派生类时，底层的派生类也会自动继承间接基类的成员。B

A.规律性

B.传递性

C.多样性

D.重复性

8.下面的4个关键字中，（ ）是用来说明虚函数的。A

A.virtual

B.public

C.protected

D.private

9.如果一个类至少有一个纯虚函数，那么该类称为（ ）。C

A.虚基类

B.派生类

C.抽象类

D.组合类

10.设有基类定义：

class Base

{

private:int a;

protected: int b;

public: int c;

};

派生类采用（ ）继承方式可以使成员变量b成为自己的私有成员。C

A.公有继承

B.保护继承

C.私有继承

D.私有，保护，共有，均可

11.类模板的模板参数（ ）D

A.只可作为数据成员的类型

B.只可作为成员的返回值类型

C.只可作为成员函数的参数类型

D.可作为数据成员的类型、成员的返回值类型或成员函数的参数类型

12.多态调用是指（ ）。D

A.以任何方式调用一个虚函数

B.以任何方式调用一个纯虚函数

C.借助于指向对象的基类指针或引用调用一个虚函数

D.借助于指向对象的基类指针或引用调用一个纯虚函数

13.在公有public派生情况下,有关派生类对象和基类对象的关系,不正确的叙述是( )。C

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

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

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

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

解析：

友元对象可以做到直接访问基类中成员；基类中的成员有各自作用域，private明显不行

14.继承与派生可以给软件开发带来很多好处,下述中不正确的是:D

A.避免公用代码的重复开发，提高了程序开发的效率和指令

B.可以减少代码和数据的冗余

C.通过层次关系组织对象，给编码与代码重用带来了方便

D.软件的执行效率大大提高

解析：

继承其是增加了复杂性，提高可重用率

15.实现运行时的多态性要使用（ ）。D

A.重载函数

B.构造函数

C.析构函数

D.虚函数

16.虚函数必须是类的（ ）。D

A.友元函数

B.构造函数

C.析构函数

D.成员函数

解析：

虚函数必须是类的成员函数。在C++中，虚函数是通过在基类中声明为虚函数，然后在派生类中进行重写来实现多态性的机制。因此，虚函数必须是类的成员函数，而不能是全局函数或静态函数。

17.当保护继承时,基类的( )在派生类中成为保护成员,不能通过派生类的对象来直接访问。B

A.任何成员

B.公有成员和保护成员

C.公有成员和私有成员

D.私有成员

解析

基类的保护成员在派生类中仍然是保护成员，也无法通过派生类的对象来直接访问。

积累的私有成员，保护继承后仍然是私有继承，也无法访问

18.派生类的对象可以直接访问的基类成员是( )。A

A.公有继承的公有成员

B.保护继承的公有成员

C.私有继承的公有成员

D.公有继承的保护成员

19.下列描述中,错误的是( )。

A.基类的protected成员在public派生类中仍是protected成员

B.基类的private成员在public派生类中是不可访问的

C.基类public成员在private派生类中是private成员

D.基类public成员在protected派生类中仍是public成员

相关博客链接：传送门

• 解析：
  

20.当运行程序时实际上是将类模板实例化为一个具体的（ ）。D

A.类

B.对象

C.函数

D.模板类

二.判断题（10）

• 答案与解析在下面

1. 派生类的对象和派生类的成员 对派生类成员的访问权限是一样的。×
2. 派生类还可以作基类派生出新的派生类。√
3. 私有继承中基类的私有成员在派生类中还是私有的。√
4. 继承反映了类之间“是”的关系,组合反映了类之间“有”的关系。√
5. 一个模板声明了多个形参，则每个参数都必须用关键字typename或class。√
6. 派生类的默认构造函数不包含有直接基类的构造函数。×
7. 多重继承派生类的构造函数中应包含所有直接基类的构造函数。√
8. 单重继承是指派生类只有一个基类的情况。√
9. 派生类中成员的访问权限与基类的继承方式有关。√
10. 函数模板使一个函数可以定义为对许多数据类型完成同一任务。对

• 答案与解析：

1. 派生类中的成员函数：可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员； 通过派生类的对象：不能直接访问从基类继承的任何成员。
2. 任何一个类都可以派生出一个新类，派生类也可以再派生出新类，因此，基类和派生类是相对而言的
3. 在私有继承中，基类的所有成员（无论是私有的、保护的还是公有的）在派生类中都会变成私有的。这意味着即使基类中有公有或保护成员，它们在派生类中也会变成私有的，因此无法直接访问。
4. 略
5. 如果函数模板有多个模板参数，则每个模板参数前都必须使用关键字 class 或 typename 修饰

> template<typename T, typename U>  //两个关键字可以混用
void func(T t, U u)
{}
template<typename T, U>   //错误，每一个模板参数前都必须有关键字修饰
void func(T t, U u) 
{}

6. 派生类的默认构造函数包含对直接基类的构造函数的调用，即使没有显式地包含在派生类的构造函数中。
7. 是的，在C++中，如果一个派生类有多个直接基类，那么派生类的构造函数应该包含对所有直接基类构造函数的显式调用。这是因为每个基类都需要在派生类对象的构造过程中进行初始化。
8. 单重继承是指派生类只有一个直接基类的情况
9. 略
10. 是的，函数模板可以使一个函数定义为对许多数据类型完成同一任务。函数模板是C++中的一种特性，它允许我们编写一个通用的函数，可以在编译时根据需要使用不同的数据类型进行实例化。

三.代码题（3）

计算正方体、球体、圆柱体的体积。要求：定义基类shape，在其中定义求体积的纯虚函数volume，并定义一个数据成员r，它可作为球体的半径、正方体的边长以及圆柱体的底面圆半径。由shape类派生出3个类，分别是正方体类、球体类和圆柱体类，在这3个类中都具有求体积的重定义版本。在主函数中统一求3种对象的体积，实现多态性。

这段代码创建了一个基类Shape，其中包含了一个纯虚函数volume。然后从Shape类派生出Cube、Sphere和Cylinder三个类，它们都重定义了volume函数。在主函数中，创建了一个Shape指针数组，分别指向Cube、Sphere和Cylinder对象，然后通过循环调用各个对象的volume函数，实现了多态性。

#include <iostream>
using namespace std;

class Shape {
public:
    virtual double volume() const = 0;
};

class Cube : public Shape {
private:
    double sideLength;

public:
    Cube(double side) : sideLength(side) {}

    double volume() const override {
        return sideLength * sideLength * sideLength;
    }
};

class Sphere : public Shape {
private:
    double radius;

public:
    Sphere(double r) : radius(r) {}

    double volume() const override {
        return (4.0 / 3.0) * 3.14159 * radius * radius * radius;
    }
};

class Cylinder : public Shape {
private:
    double radius;

public:
    Cylinder(double r) : radius(r) {}

    double volume() const override {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Cube cube(3.0);
    Sphere sphere(2.0);
    Cylinder cylinder(1.5);

    Shape* shapes[] = {&cube, &sphere, &cylinder};

    for (int i = 0; i < 3; i++) {
        cout << "Volume of shape " << i+1 << ": " << shapes[i]->volume() << endl;
    }

    return 0;
}

2. 编写一个函数模板，求数组中的最小元素，并写出调用此函数模板的完整程序，使得函数调用时，数组的类型可以是整型，也可以是双精度类型

在这个示例中，我们定义了一个模板函数findMin，它接受一个数组和数组的大小作为参数，并返回数组中的最小元素。在主函数中，我们分别定义了一个整型数组intArr和一个双精度数组doubleArr，并分别调用了findMin函数来找到它们的最小元素。由于findMin是一个函数模板，它可以接受不同类型的数组作为参数。

#include <iostream>
using namespace std;

template <typename T>
T findMin(const T arr[], int size) {
    T min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

int main() {
    int intArr[] = {3, 5, 2, 8, 1};
    double doubleArr[] = {3.4, 5.6, 2.1, 8.9, 1.2};

    int intMin = findMin(intArr, 5);
    double doubleMin = findMin(doubleArr, 5);

    cout << "Minimum of intArr: " << intMin << endl;
    cout << "Minimum of doubleArr: " << doubleMin << endl;

    return 0;
}

3. 设计以下两个类：Cpoint类和CRectangle类。对这两个类的描述如下：

l Cpoint类：成员变量x、y表示点的坐标，成员函数Getx()返回该点横坐标，Gety()返回该点纵坐标。

l 在Cpoint类的基础上，派生出CRectangle类，继承方式为public。CReactangle类应满足如下要求：

（1）矩形水平放置，继承的x,y是矩形中心坐标；

（2）Length、width表示矩形的长和宽；

（3）成员函数Perimeter()计算矩形的周长；

（4）成员函数Area()计算矩形的周长；

（5）成员函数Area()计算矩形的面积。

假设一个矩形中心坐标为（5,5.5），矩形的长为5，宽为4，编写主函数代码，建立CReactangle类对象，输出矩形的中心坐标、周长及面积。

在这个示例中，Cpoint类表示一个点，包含坐标x和y，并提供了Getx()和Gety()函数来获取横纵坐标。CRectangle类继承自Cpoint，表示一个矩形，包含矩形的中心坐标、长和宽，并提供了Perimeter()和Area()函数来计算矩形的周长和面积。

在主函数中，我们创建了一个CRectangle对象rect，并输出了矩形的中心坐标、周长和面积。

#include <iostream>
using namespace std;

class Cpoint {
protected:
    double x, y;

public:
    Cpoint(double x, double y) : x(x), y(y) {}

    double Getx() const {
        return x;
    }

    double Gety() const {
        return y;
    }
};

class CRectangle : public Cpoint {
private:
    double Length, Width;

public:
    CRectangle(double x, double y, double length, double width) : Cpoint(x, y), Length(length), Width(width) {}

    double Perimeter() const {
        return 2 * (Length + Width);
    }

    double Area() const {
        return Length * Width;
    }
};

int main() {
    CRectangle rect(5, 5.5, 5, 4);

    cout << "Center coordinate of the rectangle: (" << rect.Getx() << ", " << rect.Gety() << ")" << endl;
    cout << "Perimeter of the rectangle: " << rect.Perimeter() << endl;
    cout << "Area of the rectangle: " << rect.Area() << endl;

    return 0;
}