第七章 C++继承和派生

第1题

若有以下程序，则该程序运行后的输出结果是（）。

#include<iostream>
using namespace std;
class TestClass
{
public:
    void who(){cout<<"TestClass"<<endl;}
};
class TestClass1:public TestClass
{
public:
    void who(){cout<<"TestClass1"<<endl;}
};
int main()
{
    TestClass *p;
    TestClass1 obj1;
    p=&obj1;
    p->who();
    return 0;
}

第2题

下列有关继承和派生的叙述中，正确的是（）。

第3题

下面叙述错误的是（）。

第4题

列程序的输出结果为2，横线处应添加语句（）。

#include<iostream>
using namespace std;
class TestClass1
{
public:
    ______ void fun(){cout<<1;}
};
class TestClass2:public TestClass1
{
public:
    void fun(){cout<<2;}
};
int main()
{
    TestClass1 *p=new TestClass2;
    p->fun();
    delete p;
    return 0;
}

第5题

要使程序执行后的输出结果为ABCD，应在横线处添加语句（）。

#include<iostream>
using namespace std;
class A
{
public:A(){cout<<"A";}
};
class B:______
{
public:B(){cout<<"B";}
};
class C:virtual public A
{
public:C(){cout<<"C";}
};
class D:public B,public C
{
public:D(){cout<<"D";}
};
void main(){D obj;}

第6题

下面的描述中，正确的是（）。

第7题

下列说法中错误的是（）。

第8题

多继承的构造顺序可分为四步：①所有非虚基类的构造函数按照它们被继承的顺序构造；②所有虚基类的构造函数按照它们被继承的顺序构造；③所有子对象的构造函数按照它们声明的顺序构造；④派生类自己的构造函数体。这四个步骤的正确顺序是（）。

第9题

设有以下定义和程序，则以下不合语法的调用语句是（）。

#include<iostream.h>
class A1
{
public:
    void show1()
    {
        cout<<"class A1"<<endl;
    }
};
class A2:public A1
{
public:
    void show2()
    {
        cout<<"class A2"<<endl;
    }
};
class A3:protected A2
{
public:
    void show3()
    {
        cout<<"class"<<endl;
    }
};
void main()
{
    A1 obj1;
    A2 obj2;
    A3 obj3;
}

第10题

下列关于派生类构造函数和析构函数的说法中，错误的是（）。

第11题

有如下程序，执行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class TestClass1
{
public:
    TestClass1(){cout<<"TestClass1";}
    ~TestClass1(){cout<<"~TestClass1";}
};
class TestClass2:public TestClass1
{
    TestClass1 *p;
public:
    TestClass2(){cout<<"TestClass2";p=new TestClass1();}
    ~TestClass2(){cout<<"~TestClass2";delete p;}
};
int main()
{
    TestClass2 obj;
    return 0;
}

第12题

有如下类说明，在构造函数TestClass1的下列定义中，正确的是（）。

class TestClass
{
    int x;
public:
    TestClass (int n){x=n;}
};
class TestClass1:public TestClass {
    int y;
public:
    TestClass1 (int a,int b);
};

第13题

声明派生类时，已知有如下定义：

class TestClass{
protected:
    void fun(){}
};
class TestClass1:TestClass{};

则TestClass类中的成员函数fun()，在TestClass1中的访问权限是（）。

第14题

下面叙述错误的是（）。

第15题

关于虚函数，以下说法正确的是（）。

第16题

下列关于纯虚函数与抽象类的描述中，错误的是（）。

第17题

有如下类定义，类MyDERIVED中保护的数据成员和成员函数的个数是（）。

class MyBASE
{
    int k;
public:
    void set(int n){k=n;}
    int get()const{return k;}
};
class MyDERIVED:protected MyBASE
{
protected:
    int j;
public:
    void set(int m,int n){MyBASE::set(m);j=n;}
    int get()const{return MyBASE::get()+j;}
};

第18题

下列关于继承的描述中，错误的是（）。

第19题

有如下程序，执行上面的程序将输出（）。

class YY:public XX
{
public:
    ~YY()
    {
        cout<<"YY";
    }
    void f()const
    {
        cout<<k;XX::f();
    }
};
int main()
{
    XX &p=*new YY;
    p.f();
    delete &p;
    return 0;
}

第20题

下列关于虚函数的描述中，正确的是（）。

第21题

在下列横线处应添加的语句是（）。

class Base{public: void fun(){cout<<"Base::fun"<<endl;}};
class Derived:public Base
{
public:
    void fun()
    {
        //显示调用基类的fun函数
        cout<<"Derived::fun"<<endl;
    }
};

第22题

若类A和类B的定义如下，则上述定义中非法的表达式是（）。

#include<malloc.h>
class A
{
    int i,j;
public:
    int geti()
    {
        return i;
    }
};
class B:public A
{
    int k;
public:
    void make()
    {
        k=i*j;
    }
};

第23题

派生类的构造函数的成员初始化列中，不能包含（）。

第24题

派生类的对象对它的基类成员中（）是可以访问的。

第25题

 C++类体系中，不能被派生类继承的有（）。

第26题

有如下程序，执行上面的程序将输出（）。

#include<iostream>
using namespace std;
class TestClass
{
public:
    TestClass(){cout<<"BB";fun();}
    void fun(){cout<<"Bf";}
};
class TestClass1:public TestClass
{
public:
    TestClass1(){cout<<"DD";}
    void fun(){cout<<"Df";}
};
int main(){TestClass1 d;return 0;}

第27题

下列程序中横线处正确的语句是（）。

#include<iostream>
using namespace std;
class TestClass
{
public:
    void fun(){cout<<" TestClass::fun"<<endl;}
};
class TestClass1:public TestClass
{
    void fun()
    {
        //显示调用基类的函数fun()
        cout<<" TestClass1::fun"<<endl;
    }
};

第28题

下面关于虚函数的描述中正确的是（）。

第29题

有如下程序，执行上面程序的输出是（）。

#include<iostream>
using namespace std;
class TestClass1
{
public:
    virtual void fun() {cout<<"1";}
};
class TestClass2:public TestClass1
{
public:
    TestClass2(){cout<<"2";}
};
class TestClass3:public TestClass2
{
public:
    virtual void fun(){TestClass2::fun();cout<<"3";}
};
int main()
{
    TestClass1 aa,*p;
    TestClass2 bb;
    TestClass3 cc;
    p=&cc;
    p->fun();
    return 0;
}

第30题

有如下类声明，在构造函数XB的下列定义中，正确的是（）。

class XA{

    int x;

public:

    XA(int n){x=n;}

};

class XB:public XA{

    int y;

public:

    XB(int a,int b);

};

第31题

有如下程序，执行后的输出结果是（）。

#include<iostream>
using namespace std;
class BASE{
public:
    ~BASE(){cout<<"BASE";}
};
class DERIVED:public BASE{
public:
    ~DERIVED(){cout<<"DERIVED";}
};
int main(){DERIVED d;return 0;}

第32题

下列有关类继承的叙述中，错误的是（）。

第33题

 在下列关键字中，不能用来表示继承方式的是（）。

第34题

在类声明中，紧跟在“public:”后声明的成员的访问权限是（）。

第35题

定义派生类时，若不使用关键字显式地规定采用何种继承方式，则默认方式为（）。

第36题

 有如下定义，下列选项中，输出结果为A0的语句是（）。

class XX
{
    int xx;
public:
    XX(): xx(0) {cout<<'A';}
    XX(int n): xx(n) {cout<<'B';}
};
class YY: public XX
{
    int yy;
public:
    YY(): yy(0) {cout<<yy;}
    YY(int n): XX(n+1), yy(n) {cout<<yy;}
    YY(int m, int n): XX(m), yy(n) {cout<<yy;}
};

第37题

有如下类定义，YY类的对象包含的数据成员的个数是（）。

class XX{
    int xdata;
public:
    XX(int n=0):xdata(n){}
};
class YY: public XX{
    int ydata;
public:
    YY(int m=0,int n=0):XX(m),ydata(n){}
};

第38题

下列关于继承方式的描述中，错误的是（）。

第39题

下列代码段声明了3个类，下列关于这些类之间关系的描述中，错误的是（）。

class Person{};
class Student:public Person{};
class Undergraduate:Student{};

第40题

下列关于基类和派生类关系的叙述中，正确的是（）。

第41题

若已定义了类Vehicle，则下列派生类定义中，错误的是（）。

第42题

下列描述中，错误的是（）。

第43题

当派生类继承一个基类时，默认的继承方式为（）。

第44题

有如下类定义，编译时发现有一处语法错误，对这个错误最准确的描述是（）。

class MyBase
{
    int k;
public:
    MyBase(int n=0):k(n) {}
    int value() const { return k;}
};
class MyDerived: MyBase
{
    int j;
public:
    MyDerived(int i):j(i) {}
    int getK()const { return k;}
    int getJ()const { return j;}
};

第45题

派生类的成员函数不能访问基类的（）。

第46题

有如下类声明，已知X是一个Derived对象，则下列表达式中正确的是（）。

class Base{
protected:
    int amount;
public:
    Base(int n=0): amount(n){}
    int getAmount()const { return amount; }
};
class Derived: public Base {
protected:
    int value;
public:
    Derived(int m,int n): value(m), Base(n){}
    int getData()const { return value+amount; }
};

第47题

在一个派生类的成员函数中，试图调用其基类的成员函数“void f（）；”，但无法通过编译。这说明（）。

第48题

对于通过公有继承定义的派生类，若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是（）。

第49题

建立一个有成员对象的派生类对象时，各构造函数体的执行次序为（）。

第50题

有如下类定义和变量定义，下列语句中正确的是（）。

class Parents {
public:
    int publicData;
private:
    int privateData;
};
class ChildA: public Parents {/*类体略*/};
class ChildB: private Parents {/*类体略*/};
ChildA a;
ChildB b;

第51题

通过派生类的对象可直接访问其（）。

第52题

有如下程序，在标注号码的四条语句中正确的是（）。

#include<iostream>
using namespace std;
class AA {
    int k;
protected:
    int n;
    void setK(int k){this->k=k;}
public:
    void setN(int n){this->n=n;}
};
class BB:public AA {/*类体略*/};
int main() {
    BB x;
    x.n=1;    //1
    x.setN(2); //2
    x.k=3;    //3
    x.setK(4); //4
    return 0;
}

第53题

有如下两个类定义，在类YY中保护成员变量的个数是（）。

class XX{
private:
    double x1;
protected:
    double x2;
public:
    double x3;
};
class YY: protected XX{
private:
    double y1;
protected:
    double y2;
public:
    double y3;
};

第54题

有如下程序，下列叙述中正确的是（）。

#include<iostream>
using namespace std;
class Music{
public:
    void setTitle(char* str){strcpy(title, str);}
protected:
    char type[10];
private:
    char title[20];
};
class Jazz: public Music{
public:
    void set(char* str){
        strcpy(type,"Jazz"); //①
        strcpy(title,str);   //②
    }
};

第55题

当派生类从一个基类保护继承时，基类中的一些成员在派生类中成为保护成员，这些成员在基类中原有的访问属性是（）。

第56题

下列关于派生类和基类的描述中，正确的是（）。

第57题

 有如下程序，下列关于程序编译结果的描述中，正确的是（）。

#include<iostream>
using namespace std;
class Base {
public:
    int data;
};
class Derived1 :public Base {};
class Derived2 :protected Base {};
int main() {
    Derived1 d1;
    Derived2 d2;
    d1.data = 0; //①
    d2.data = 0; //②
    return 0;
}

第58题

有如下程序，运行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class XX{
    int x;
public:
    XX(int xx=0):x(xx){}
    int getX() {return x;}
};
class YY: public XX{
    int y;
public:
    YY(int xx, int yy):XX(xx),y(yy){}
    int getV() {return getX()+y;}
};
int main(){
    YY c(3,4);
    cout<<c.getV()+c.getX()<<endl;
    return 0;
}

第59题

有如下程序，编译时有错误的是（）。

#include<iostream>
using namespace std;
class Media{
pub
lic:
    void Name(){}
    void Show(){}
protected:
    int page;
};class Book: private Media{
public:
    void Print() { cout<<page<<endl; }
    void Show() { Media::Show(); } //①
};
int main(){
    Book Bible;
    Bible.Name();    //②
    Bible.Print();   //③
    Bible.Show();    //④
    return 0;

第60题

有如下程序，执行后的输出结果是（）。

#include<iostream>
using namespace std;
class A {
public:
    A(){cout<<"A";}
};
class B:public B{cout<<"B";}
class C:public A {
    B b;
public:
    C(){cout<<"C";}
};
int main(){ C obj; return 0;}

第61题

有如下程序，执行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class A {
public:
    A(){ cout<<"A";}
    ~A(){ cout<<"~A";}
};
class B: public A {
    A* p;
public:
    B(){ cout<<"B"; p=new A();}
    ~B(){ cout<<"~B"; delete p;}
};
int main(){
    B obj;
    return 0;
}

第62题

有如下程序，执行这个程序屏幕上将显示输出（）。

#include<iostream>
using namespace std;
class Base{
protected:
    Base() {cout<<"A";}
    Base(char c){cout<<c;}
};
class Derived:public Base{
public:
    Derived(char c){cout<<c;}
};
int main(){
    Derived d1('B');
    return 0;
}

第63题

 在一个派生类对象结束其生命周期时（）。

第64题

有如下程序，运行时输出的结果是（）。

#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;
}

第65题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class Base{
    int x;
public:
    Base(int n=0):x(n){cout<<n;}
    int getX() const{return x;}
};
class Derived:public Base {
    int y;
public:
    Derived(int m,int n):y(m),Base(n){cout<<m;}
    Derived(int m):y(m){cout<<m;}
};
int main(){
    Derived d1(3),d2(5,7);
    return 0;
}

第66题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class AA{
public:
    AA(){ cout<<'1'; }
};
class BB: public AA{
    int k;
public:
    BB():k(0) { cout<<'2'; }
    BB(int n):k(n) { cout<<'3'; }
};
int main(){
    BB b(4), c;
    return 0;
}

第67题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class Base{
public:
    Base(int x=0): valB(x){cout<<valB;}
    ~Base(){cout<<valB;}
private:
    int valB;
};
class Derived:public Base{
public:
    Derived(int x=0,int y=0):Base(x),valD(y){cout<<valD;}
    ~Derived(){cout<<valD;}
private:
    int valD;
};
int main(){
    Derived obj12(2,3);
    return 0;
}

第68题

生成派生类对象时，派生类构造函数调用基类构造函数的条件是（）。

第69题

有如下程序，运行时的输出结果是（）。

#include<iostream>
using namespace std;
class Base1 {
public:
    Base1(int d) {cout<<<d;}
    ~Base1() {}
};
class Base2 {
public:
    Base2(int d) {cout<<<d;}
    ~Base2() {}
};
class Derived: public Base1,Base2 {
public:
    Derived(int a,int b,int c,int d):
        Base1(b), Base2(a), b1(d), b2(c) {}
private:
    int b1;
    int b2;
};
int main(){
    Derived d(1,2,3,4);
    return 0;
}

第70题

已知基类Employee只有一个构造函数，其定义如下： Employee::Employee(int n):id(n){} ，Manager是Employee的派生类，则下列对Manager的构造函数的定义中，正确的是（）。

第71题

运行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class A{
public:
    A(){cout<<'A';}
    ~A(){cout<<'C';}
};
class B:public A{
public:
    B(){cout<<'G';}
    ~B(){cout<<'T';}
};
int main(){
    B obj;
    return 0;
}

第72题

有如下程序，运行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class Mountain{
    int height;
public:
    Mountain (int h=0):height(h) {}
    virtual char* GetName() const { return "山";}
    int GetHeight() const { return height;}
};
class Lushan:public Mountain{
public:
    Lushan(int d):Mountain(d) {}
    char* GetName() const { return "庐山";}
};
int main(){
    Mountain *p=new Lushan(1000);
    cout<<p->GetName()<<"海拔"<<p->GetHeight()<<"米";
    return 0;
}

第73题

在C++中，用于实现运行时多态性的是（）。

第74题

下列关于虚函数的说明中，正确的是（）。

第75题

有如下程序，运行此程序，屏幕上将显示输出（）。

#include<iostream>
using namespace std;
class A{
public:
    virtual void func1(){cout<<"A1";}
    void func2(){cout<<"A2";}
};
class B:public A{
public:
    void func1(){cout<<"B1";}
    void func2(){cout<<"B2";}
};
int main(){
    A *p=new B;
    p->func1();
    p->func2();
    return 0;
}

第76题

有如下程序，运行时输出的结果是（）。

#include<iostream>
using namespace std;
class Base{
    int a,b;
public:
    Base(int x, int y){a=x; b=y;}
    void show() {cout<<a<<','<<b<<endl;}
};
class Derived:public Base{
    int c,d;
public:
    Derived(int x,int y,int z,int m):Base(x,y){c=z; d=m;}
    void show() {cout<<c<<','<<<d<<endl;}
};
int main(){
    Base B1(50,50),*pb;
    Derived D1(10,20,30,40);
    pb=&D1;
    pb->show();
    return 0;
}

第77题

 有如下程序，运行时输出的结果是（）。

#include<iostream>
using namespace std;
class Base{
public:
    virtual void f(){cout<<"f0+";}
    void g() { cout<<"g0+";}
};
class Derived:public Base{
public:
    void f(){cout<<"f+";}
    void g() { cout<<"g+";}
};
int main(){
    Derived d;
    Base *p=&d;
    p->f(); p->g();
    return 0;
}

第78题

有如下程序，运行时的输出结果是（）。

#include <iostream> using namespace std;
 class Publication{ //出版物类 char name[30]; 
public: Publication(char *name="未知名称"){ strcpy(this->name,name); 
} const char* getName()const{ 
return name; }
 virtual const char* getType()const{ return "未知类型";} }; 
class Book: 
public Publication{ //书类 public: Book(char *name):
 Publication(name){}
 virtual const char* getType()const{ return "书";} };
 void showPublication( Publication &p){ cout<<p.getType()<<":"<<p.getName()<<endl; }
 int main(){ Book book("精彩人生"); 
showPublication(book); 
return 0; }

第79题

有如下程序，运行时的输出结果是（）。

 #include<iostream> using namespace std; class B{ 
public: B(int xx):x(xx){++count;x+=10;} 
virtual void show() const {cout<<count<<'_'<<x<<endl;}
 protected: static int count; private: int x; }; class D:
public B{ public: D(int xx,int yy):B(xx),y(yy){++count;y+=100;} 
virtual void show() const {cout<<count<<'_'<<y<<endl;} 
private: int y; }; 
int B::count=0; int main(){ B *ptr=new D(10,20); ptr->show(); delete ptr; return 0; }

第80题

有如下程序，下列叙述中正确的是（）。

 #include<iostream> using namespace std; 
class Instrument{ public: virtual void Display()=0; };
 class Piano : public Instrument{ public: void Display(){/*函数体程序略*/} };
 int main(){ Instrument s; Instrument *p=0; //... return 0; }

第81题

有如下程序，若程序运行时输出结果是“文学”，则划线处缺失的语句是（）。

#include
using namespace std;
class Book{
public:
Book(char*t="") {strcpy(title,t);}
private:
char title[40];
};
class Novel: public Book{
public:
Novel(chart=""): Book(t){}
charCategory() const { return "文学";}
};
int main(){
Book pb;
pb=new Novel();
cout<Category();
return 0;
}

第82题

对虚函数的调用（）。

第83题

有如下程序，执行这个程序的输出结果是（）。

#include<iostream>
using namespace std;
class A
{
public:
    A(){cout<<"A";}
    ~A(){cout<<"~A";}
};
class B:public A
{
    A*p;
public:
    B(){cout<<"B";p=new A;}
    ~B(){cout<<"~B";delete p;}
};
int main()
{
    B obj;
    return 0;
}

第84题

若有如下程序，程序执行后的输出结果是（）。

#include<iostream>
using namespace std;
class A
{
public:
    A(int i,int j)
    {
        a=i;
        b=j;
    }
    void move(int x,int y)
    {
        a+=x;
        b+=y;
    }
    void show()
    {
        cout<<a<<","<<b<<endl;
    }
private:
    int a,b;
};
class B:private A
{
public:
    B(int i,int j):A(i,j){}
    void fun()
    {
        move(3,5);
    }
    void f1()
    {
        A::show();
    }
};
int main()
{
    B d(3,4);
    d.fun();
    d.f1();
    return 0;
}

第85题

有如下程序，执行这个程序，屏幕上将显示输出（）。

#include<iostream>
using namespace std;
class TestClass
{
protected:
    TestClass(){cout<<"x";}
    TestClass(char c){cout<<c;}
};
class TestClass1:public TestClass
{
public:
    TestClass1(char c){cout<<c;}
};
int main()
{
    TestClass1 d1('y');
    return 0;
}

第86题

下面是关于派生类声明的开始部分，其中正确的是（）。