PTA选择判断——2019_4Inheritance

2-1下列关于类的继承描述中，( )是正确的。4

1. 派生类公有继承基类时，可以访问基类的所有数据成员，调用所有成员函数。
2. 派生类也是基类，所以它们是等价的。
3. 派生类对象不会建立基类的私有数据成员，所以不能访问基类的私有数据成员。
4. 一个基类可以有多个派生类，一个派生类可以有多个基类。

第一个选项：不i可以访问私有数据成员

第三个选项：可以通过基类的公有成员函数或者保护成员函数来访问基类的私有数据成员

2-2在c++中，类之间的继承关系具有( )。3

1. 自反性
2. 对称性
3. 传递性
4. 反对称性

2-3(2018final) 下面描述中，表达错误的是（ ）。2

1. 公用继承时基类中的public成员在派生类中仍是public的
2. 公用继承时基类中的private成员在派生类中仍是private的
3. 公用继承时基类中的protected成员在派生类中仍是protected的
4. 私有继承时基类中的public成员在派生类中是private的

第二个选项，私有成员不能被派生类使用，所以不存在第二个选项的说法

2-4(2018final) 以下说法正确的是（ ）。2

1. 派生类可以和基类有同名成员函数，但是不能有同名成员变量
2. 派生类的成员函数中，可以调用基类的同名同参数表的成员函数
3. 派生类和基类的同名成员函数必须参数表不同，否则就是重复定义
4. 派生类和基类的同名成员变量存放在相同的存储空间

2-5在下列关键字中，不能用来表示继承方式的是3

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

2-6下列关于继承的描述中，错误的是( )。4

1. 析构函数不能被继承
2. 派生类是基类的组合
3. 派生类的成员除了它自己的成员外，还包含了它的基类的成员
4. 派生类中继承的基类成员的访问权限到派生类保持不变

2-7下面关于类的继承与派生的程序，其输出结果是3

#include<iostream>
using namespace std;
class A {
public:
    A(int i) {    x = i;  }
    void dispa() {
        cout << x << ',';
    }
private:
    int x;
};
class B: public A {
public:
    B(int i) : A(i + 10) {
        x = i;
    }
    void dispb() {
        dispa();
        cout << x << endl;
    }
private:
    int x;
};
int main() {
    B b(2);
    b.dispb();
    return 0;
}

1. 10,2
2. 12,10
3. 12,2
4. 2,2

2-8在派生类对基类继承的传递性中，__是错误的。3

1. 在公有继承方式下，直接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员
2. 在公有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员
3. 在私有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员
4. 不管是私有继承还是公有继承，基类中的私有成员在派生类的作用域内都是不可能见的。

2-9若obj是类D的对象，则下列语句中正确的是4

class B{
private: void fun1(){ }
protected: void fun2(){ }
public: void fun3(){ }
};
class D : public B {
protected: void fun4(){ }
};

1. obj.fun1();
2. obj.fun2();
3. obj.fun4();
4. obj.fun3();

2-10下列程序的执行结果为3

#include <iostream>
using namespace std;

class A {
public:
    A() {     cout << "1";    }
    ~A() {    cout << "2";    }
};
class B: public A {
public:
    B() {    cout << "3";    }
    ~B() {    cout << "4";    }
};
int main() {
    B b;
    return 0;
}

1. 1234
2. 1324
3. 1342
4. 3142

2-11下面关于继承和派生的构造函数和析构函数的程序，输出结果是2

#include<iostream>
using namespace std;
class AA {
public:
    AA() { cout << "A"; }
    ~AA() { cout << "a"; }
};
class BB: public AA {
    AA aa;
public:
    BB() { cout << "B"; }
    ~BB() { cout << "b"; }
};
int main() {
    BB bb;
    return 0;
}

1. AABaab
2. AABbaa
3. BAAaab
4. BAAbaa