OOP Midterm Review

Week1

Q1. （ ）不是面向对象程序设计的主要特征。

A. 封装

B. 继承

C. 多态

D. 结构

Q2. *ptr = new B(5); delete ptr;

假设上述语句中，new 申请的内存空间首地址为Addr , 存放ptr 指针变量值的内存空间首地址为 PAddr，则执行 delete ptr 语句后，Addr、PAddr 指向的内存区域均会被系统收回。(T/F)

Q3. 用 new 关键字动态申请一个三维数组，则下列语句正确的是（）

A. float *fp; fp = new float[10][25][10];

B. float (* fp)[25][10]; fp = new float[10][25][10];

C. float (* fp)[10]; fp = new float[10][25][10];

D. float *fp [25][10]; fp = new float[10][25][10];

Week2

Q1. this 指针是对象的非静态成员函数的隐含参数，其指向对象自己。(T/F)

Q2. Resolver :: is used to:

A. Define a member function outside class declaration

B. Access a member of a namespace

C. Access a static member of a class

D. All of the others

Q3. 在面向对象的程序设计中，首先需要在问题域中识别出若干个（ ）

A. 函数

B. 类

C. 文件

D. 过程

Week3

Q1. 给定以下类声明，哪个成员函数可能改变成员变量data ?

1
2
3
4
5
6
7
8

class A {
public:
    void f1 (int d);
    void f2 (const int &d);
    void f3 (int d) const;
private:
    int data;
};

A. f1

B. f2

C. f3

D. f1和 f2

Week4

Q1. 设有如下代码段 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

std::map<char *, int> m;
const int MAX_SIZE = 100;
int main() {
    char str[MAX_SIZE];
    for (int i = 0; i < 10; i++) {
        std::cin >> str;
        m[str] = i;
    }
    std::cout << m.size() << std::endl;
}

读入 10 个字符串，则输出的 m.size() 为

A. 0

B. 1

C. 10

Q2. 下列关于 STL 的描述中，错误的是。

A. STL 的内容从广义上讲分为容器、迭代器、算法三个主要部分

B. STL 的一个基本理念就是将数据和操作分离

C. STL 中的所有组件都由模板构成，其元素可以是任意类型

D. STL 的容器、迭代器、算法是三个完全独立的部分，彼此也无任何联系

Q3. 下列创建 vector 容器对象的方法中，错误的是。

A. vector<int> v(10);

B. vector<int> v(10, 1);

C. vector<int> v{10, 1};

D. vector<int> v = (10, 1);

Q4. 下列选项中，哪一项不是迭代器。

A. 输入迭代器

B. 前向迭代器

C. 双向迭代器

D. 删除迭代器

Week5

Q1. 主程序调用内联函数（ inline ）时，不发生控制转移，无需保存和恢复环境变量等，因此，节省了系统开销。内联函数的声明以及最终的生效，是由程序员决定的。(T/F)

Q2. 两个以上的函数，具有相同的函数名，且形参的个数或形参的类型不同，或返回的数据类型不同，则称之为函数的重载。(T/F)

Q3. 以下选项中，是正确的函数默认形参设置的是。

A. int fun(int a,int b,int c);

B. int fun(int a,int b,int c=1);

C. int fun(int a,int b=1,int c);

D. int fun(int a=1,int b,int c);

Week6

Q1. Order of initialization in the initial list is the order of their declaration in the list.(T/F)

Q2. 类的组合关系可以用“Has-A”描述；类间的继承与派生关系可以用“Is-A”描述。(T/F)

Q3. 对于类之间的友元关系：

A. 如果类 A 是类 B 的友元，则 B 的成员函数可以访问 A 的私有成员

B. 如果类 A 是类 B 的友元，则 B 也是 A 的友元。

C. 如果类 A 是类 B 的友元，并且类 B 是类 C 的友元，则类 A 也是类 C 的友元。

D. 以上答案都不对。

Q4. 友元的作用是

A. 提高程序的运用效率

B. 加强类的封装性

C. 实现数据的隐藏性

D. 增加成员函数的种类

Q5. 一个类的友元类中的成员函数都是这个类的友元函数 (T/F)

Q6. Suppose a class is defined without any keywords such as public, private and protected, all members default to

A. public

B. protected

C. private

D. static

Q7. Who can access a private member of a class?

A. Only member functions of that class.

B. Only member functions of that class and friend functions or member functions of friend classes

C. Only member functions of that class and derived classes

D. None of the others

Q8. 静态成员函数没有：

A. 返回值

B. this 指针

C. 指针参数

D. 返回类型

Q9. For the code below:

1
2
3
4

class A {
  static int i;
  //...
};

A. All objects of class A reserve a space for i

B. All objects of class A share the space of i

C. i is a member variable of class A

D. i is allocated in global data space

Week7

Q1. In C++, inheritance allows a derived class to directly access all of the functions and data of its base class. (T/F)

Q2. One class can have more than one super classes.(T/F)

Q3. 给出 //1, //2, //3, //4, //5 处产生的输出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
#include <string>
using namespace std ;

class Testing
{
private:
    string words; 
    int number ;
public:
    Testing(const string & s = "Testing")
    {
        words = s ;
        number = words.length();
        if (words.compare("Testing")==0)
            cout << 1;
        else if (words.compare("Heap1")==0)
            cout << 2;
        else
            cout << 3;
    }
    ~Testing()
    {
        cout << 0;
    }
    void show() const
    {
        cout << number;
    }
};
int main()
{
    Testing *pc1 , *pc2;
    pc1 = new Testing ;          //1
    pc2 = new Testing("Heap1");  //2
    pc1->show();   //3
    delete pc1 ;   //4
    delete pc2 ;   //5
    return 0;
}

Q4. 给出 //1, //2, //3, //4 处产生的输出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class A{
    int i;
public:
    A(int ii=0):i(ii) { cout << 1; }
    A(const A& a) {
        i = a.i;
        cout << 2;     
    }
    void print() const { cout << 3 << i; }
};

class B : public A {
    int i;
    A a;
public:
    B(int ii = 0) : i(ii) { cout << 4; }
    B(const B& b) {
        i = b.i;
        cout << 5;
    }
    void print() const {
        A::print();
        a.print();
        cout << 6 << i;    
    }
};

int main()
{
    B b(2);        //1
    b.print();    //2
    B c(b);        //3
    c.print();    //4
}

Week8

Q1. 虚函数是用 virtual 关键字说明的成员函数。(T/F)

Q2. 将构造函数说明为纯虚函数是没有意义的。(T/F)

Q3. 抽象类是指一些没有说明对象的类。(T/F)

Q4. 动态绑定是在运行时选定调用的成员函数的。(T/F)

Q5. 因为静态成员函数不能是虚函数，所以它们不能实现多态。(T/F)

Q6. 在多继承中，派生类的构造函数需要依次调用其基类的构造函数，调用顺序取决于定义派生类时所指定的各基类的顺序。

Q7. 虚函数具有继承性。(T/F)

Q8. 如果一个类的函数全部都是纯虚函数，则这个类不能有自己类的实现（包括引用和指针），只能通过派生类继承实现。(T/F)

Q9. Given:

1
2
3
4
5

class A {
    A() {};
    virtual f() {};
    int i;
};

A. i is private

B. f() is an inline function

C. i is a member of class A

D. sizeof(A) == sizeof(int)

Q10. 以下说法正确的是？

A. 在虚函数中不能使用 this 指针

B. 在构造函数中调用虚函数，不是动态联编

C. 抽象类的成员函数都是纯虚函数

D. 构造函数和析构函数都不能是虚函数