niusouti.com

有如下程序:includeusing namespace std;class BASE{public:~BASE( ){cout有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE( ){cout＜＜"BASE"；} }； class DERIVED：public BASE{ public： ～DERIVED( ){cout＜＜"DERIVED"；} }； int main( ){DERIVED x；return

题目
有如下程序:includeusing namespace std;class BASE{public:~BASE( ){cout<<"BASE";}

有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE( ){cout＜＜"BASE"；} }； class DERIVED：public BASE{ public： ～DERIVED( ){cout＜＜"DERIVED"；} }； int main( ){DERIVED x；return 0；} 程序的输出结果是

A．BASE

B．DERIVED

C．BASEDERIVED

D．DERIVEDBASE

相似考题

1.有如下程序 include using namespace std; class Base { protected:有如下程序 #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; } 执行这个程序屏幕上将显示输出A．BB．BAC．ABD．BB

2.有如下程序:includeusing namespace std;Class Base{public:Base(){cout有如下程序： #include＜iostream.h＞ using namespace std； Class Base { public： Base(){cout＜＜“BB”；f()；} void{(){cout＜＜“BF”；} }； class Derived：public Base { public： Derived(){cout＜＜“DD”；} void f(){cout＜＜“Df”；) }； int mainA．BBBfDDB．BBDfDDDfC．DDD．DDBBBf

3.有如下程序： #include＜iostream) using namespace std； classBASE{ public： ～BASE(){cout＜＜“BASE”；} }； class DERIVED：public BASE{ public： ～DERIVED(){COUt＜＜“DERIVED”；} }； int main(){DERIVED x；return 0；} 执行后的输出结果是( )。A．BASEB．DERIVEDC．BASEDERIVEDD．DERIVEDBASE

4.有如下程序: include using namespace std; class Base { public:有如下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(int x=0) { cout＜＜x; } } class Derived: public Base{ public: Derived(int x=0) { cout＜＜x; } private: Base val; }; int main() { Derived d(1); return 0; }程序的输出结果是A．0B．1C．1D．1

更多“有如下程序:includeusing namespace std;class BASE{public:~BASE( ){cout 有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE( ){cout＜＜"BASE"；} }； class DERIVED：public BASE{ public”相关问题

  • 第1题：

    有如下程序:includeusing namespace std;class Base{private:char c;piblic:Base(cha

    有如下程序： #include＜iostream＞ using namespace std； class Base { private： char c； piblic： Base(char n)：c(n){} ～Base() { cout＜＜C； } }； class DeriVed：public Base { private： char c； public： Derived(char n)：Base(n+1)，c(n){} ～Derived() { cout＜＜c； } }； int main() { Derived obj('x')； return 0； } 执行上面的程序将输出

    A．xy

    B．yx

    C．x

    D．y


    正确答案：A
    解析：在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。在此题的程序中，在主函数main结束时，派生类Derived对象。obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出x，然后调用基类的析构函数，输出y。

  • 第2题：

    有如下程序:include using namespace std;class Base{public:Base(){cout<<"BB"; f()

    有如下程序：#include ＜iostream＞using namespace std;class Base{ public: Base(){cout＜＜"BB"; f(); } Void f(){cout＜＜"Bf"; }};class Derived: public Base{ public: Derived() { cout＜＜"DD"; } void f() { cout＜＜"Df"; }};int main() { Derived d; return 0; }执行上面的程序将输出( )。

    A．BBBfDD

    B．BBDfDDDf

    C．DD

    D．DDBBBf


    正确答案：A

  • 第3题：

    有如下程序:includeusing namespace std;class Base{protected:Base(){cout<<'Base';

    有如下程序： #include＜iostream＞ using namespace std; class Base{ protected: Base(){cout＜＜'Base';} Base(char c){cout＜＜c;} }; class Derived:public Base{ public: Derived(char c){cout＜＜c;} }; int main(){ Derived d('Derived'); return 0; } 执行这个程序屏幕上将显示输出( )。

    A．Derived

    B．DerivedBase

    C．BaseDerived

    D．DerivedDerived


    正确答案：C
    解析：派生类Derived由基类Base公有派生，在派生类构造函数声明时系统会自动调用基类的缺省构造函数。调用Derived d('Derived')；后，执行类Derived构造函数的Derived(char c)，系统自动调用基类的缺省构造函数Base()，输出字母Base；再执行派生类的构造函数Derived(char c)，输出字母Derived。

  • 第4题：

    有如下程序:includeusing namespace std;class Base{public:Base(int x=0){cout<

    有如下程序： #include＜iostream＞ using namespace std； class Base{ public： Base(int x=0){cout＜＜x；} }； class Derived：public Base{ public： Derived(int x=0){cout＜＜x；} private： Base val； }； int main( ){ Derived d(1)； return 0； } 程序的输出结果是

    A．0

    B．1

    C．01

    D．001


    正确答案：D
    解析：派生对象在创建时先调用基类的构造函数，然后调用派生类的构造函数；撤销对象时，先调用派生类的构造函数，然后调用基类的构造函数。当类中出现其他类对象时，在初始化时先调用该对象的类的构造函数创建该对象。

  • 第5题：

    有以下程序:include using namespace std; class Base { public: Base() { K=0; } int

    有以下程序：

    include＜iostream＞

    using namespace std；

    class Base

    {

    public：

    Base()

    {

    K＝0；

    }

    int x；

    }；

    class Derivedl：virtual public Base

    {

    public：

    Derivedl()

    {

    x＝10；

    }

    }；

    class Derived2：virtua1 public Base


    正确答案：20。
    20。 解析： 本题中，虽然Derived1和Derived2由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1中修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obi；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x＝20。最后输出x的值为20。

  • 第6题：

    有如下程序:include using namespace std;class Base{ public: void fun() { cout<<"

    有如下程序： #include ＜iostream＞ using namespace std; class Base { public: void fun() { cout＜＜"Base::fun"＜＜endl; } }; class Derived : public Base { public: void fun() { ______ cout＜＜"Derived::fun"＜＜endl; } }; int main() { Derived d; d.fun(); return 0; } 已知其执行后的输出结果为： Base::fun Derived::fun 则程序中下划线处应填入的语句是( )。

    A．Base.fun();

    B．Base::fun();

    C．Base-＞fun();

    D．fun();


    正确答案：B
    解析：此题考查的是继承的使用。分析题目可知，横线处应填入对基类成员函数fun()的调用语句，此处只能使用作用域运算符“::”才能调用到基类的同名函数。

  • 第7题：

    有如下程序:include using namespace std;class Base{public:void fun() {cout<<"Bas

    有如下程序：#include ＜iostream＞using namespace std;class Base { public: void fun() {cout＜＜"Base:: fun"＜＜end1; }};class Derived: public Base ( public: void fun() { ____________________________ cout＜＜"Derived:: fun"＜＜end1; }};int main() { Derived d; D. fun(); return O;}已知其执行后的输出结果为：Base:: funDerived:: fun则程序中下划线处应填入的语句是( )。

    A．Base. fun ()；

    B．Base:: fun ()；

    C．Base-＞fun()；

    D．fun()


    正确答案：B

  • 第8题：

    有以下程序:includeusing namespace std;class BASE{private: char c;public: BASE(c

    有以下程序： #include ＜iostream＞ using namespace std； class BASE { private： char c； public： BASE(char n)：c(n)；{} virtual～BASE() { cout＜＜c； } }； class DERIVED：public BASE { char c； p

    A．XY

    B．YX

    C．X

    D．Y


    正确答案：A
    解析：在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。在此题的程序中，在主函数结束时，派生类DERIVED对象obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出X，然后调用基类的析构函数，输出Y。

  • 第9题：

    有如下程序:include using namespace std;class Base{private:charc;public:Base(cha

    有如下程序：#include ＜iostream＞using namespace std;class Base{private: char c;public: Base(char n) :c(n){} ～Base() { cout＜＜c; } };class Derived: public Base{private: char c; public: Derived(char n):Base(n+1),c(n) {} ～Derived() { cout＜＜c; }};int main (){ Derived obj ('x'); return 0;}执行上面的程序净输出

    A．xy

    B．yx

    C．x

    D．y


    正确答案：A
    解析：在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。在此题的程序中，在主函数main结束时，派生类Derived对象obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出x，然后调用基类的析构函数，输出y。

  • 第10题：

    有下列程序: include using namespace std; class Base { public: Base(){cout<<"B

    有下列程序： #include＜iosteram.h＞ using namespace std; class Base { public: Base(){cout＜＜"BB"; f(); } void f(){cout＜＜"Bf";} }; class Derived:public Base { public: Derived(){cout＜＜"D

    A．BBBfDD

    B．BBDfDDDf

    C．DD

    D．DDBBBf


    正确答案：A
    解析： 此题考查的是类的继承和派生。派生类执行构造函数的一般次序：首先调用基类构造函数；然后调用成员对象的构造函数；最后是派生类构造函数中的内容。题目中定义派生类对象d时，先调用基类Base的构造函数，输出BBBf，然后调用派生类Derived的构造函数，输出DD。

  • 第11题：

    有如下程序:includeusing namespace std;class BASE{public:~BASE(){cout<<"BASE";}}

    有如下程序： #include＜iostream＞ using namespace std; class BASE{ public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE{ public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVED x;return 0;} 执行后的输出结果是( )。

    A．BASE

    B．DERIVED

    C．BASEDERIVED

    D．DERIVEDBASE


    正确答案：D
    解析：此题考查的是派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。

  • 第12题：

    请在如下程序中的空格处填写正确的语句: include using namespace std; class Base {

    请在如下程序中的空格处填写正确的语句：

    include ＜iostream＞

    using namespace std;

    class Base {

    public:

    void fun() {cout＜＜"Base fun"＜＜endl; }

    };

    class Derived: public Base {

    public:

    void fun() {

    【 】; //调用基类的函数fun()

    cout＜＜"Derived fun "＜＜endl;

    }

    };


    正确答案：Base::fun()
    Base::fun() 解析：本题考查的知识点是：派生类对基类成员的访问。本题的派生类Derived覆盖了基类Base中的fun()，如需调用基类版本的fun()，则需要使用域运算符“::”。故应该填写Base::fun()。

  • 第13题：

    以下程序的执行结果为______。include using namespace std; class base { public: vir

    以下程序的执行结果为______。

    include＜iostream＞

    using namespace std;

    class base

    ｛

    public：

    virtual void who()

    ｛

    cout＜＜"base class"＜＜endl;

    ｝

    ｝;

    class derivel：public base

    ｛

    public：

    void who()

    ｛

    cout＜＜"d


    正确答案：base class derivel class derive2 class
    base class derivel class derive2 class

  • 第14题：

    有如下程序: include using namespace std; class BASE { public

    有如下程序： #include＜iostream＞ using namespace std; class BASE { public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE { public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVEDx;retum 0;} 执行后的输出结果是

    A．BASE

    B．DERIVED

    C．BASEDERIVED

    D．DERIVEDBASE


    正确答案：D
    解析：本题考查基类析构函数和派生类析构函数的调用次序。

  • 第15题：

    如下程序的输出是includeusing namespace std;class Base{public:Base( ){cout<<"BB"

    如下程序的输出是 #include＜iostream＞ using namespace std； class Base{ public： Base( ){cout＜＜"BB"；f( )；} void f( ){cout＜＜"Bf"；} }； class Derived：public Base{ public： Derived( ){eout＜＜"DD"；} void f( ){cout＜＜"Df"；} }； int main( ){Derived d；return 0；}

    A．BBBff)D

    B．BBDfDDDf

    C．DD

    D．DDBBBf


    正确答案：A
    解析：当创建派生类对象时，首先调用基类的构造函数，最后调用派生类的构造函数。

  • 第16题：

    有如下程序:includeusing namespace std;class Base{public:void output( ){cout<

    有如下程序： #include＜iostream＞ using namespace std； class Base{ public： void output( ){cout＜＜l；} virtual void Print( ){cout＜＜'B'；} }； class Derived：public Base{ public： void output( ){cout＜＜1；} void Print( ){cout＜＜'D'；} }； int main( ){ Base*prt=new Derived； prt-＞output( )； prt-＞Print( )； delete prt； return 0； } 程序的输出结果是

    A．1B

    B．1D

    C．2B

    D．2D


    正确答案：B
    解析：基类指针可以指向派生类对象，但是只能访问从基类中继承来的成员。派生类对从基类继承来的成员可以被重新定义。故打印1D

  • 第17题：

    有如下程序:include using namespace std;class BASE{public:~BASE(){cout<<"BASE";}

    有如下程序： #include ＜iostream＞ using namespace std; class BASE{ public: ～BASE(){cout＜＜"BASE";} }; class DERIVED:public BASE{ public: ～DERIVED(){cout＜＜"DERIVED";} }; int main(){DERIVED x;return 0;} 执行后的输出结果是

    A．BASE

    B．DERIVED

    C．BASEDERIVED

    D．DERIVEDBASE


    正确答案：D
    解析：本题考核派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。所以当main函数结束时，派生类DERIVED的对象x将被删除，那么派生类DERIVED的析构函数先被调用，输出DERIVED，然后调用基类的析构函数输出BASE。

  • 第18题：

    下面程序的输出结果是【】。include using namespace std; class base { protected: int

    下面程序的输出结果是【 】。

    include ＜iostream＞

    using namespace std;

    class base

    {

    protected:

    int a;

    public:

    base(){cout＜＜"0":}

    };

    class basel: virtual public base

    {

    public:

    base1(){ cout＜＜"1";}

    };

    class base2 : virtual public base

    {

    public:

    base2(){cout＜＜"2";}

    };

    class derived : public base1,public base2

    {

    public:

    derived () {cout＜＜"3"; }

    }

    int main ()

    {

    derived obj;

    cout＜＜end1;

    return 0;

    }


    正确答案：0123
    0123 解析：本题考核含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最有调用派生类自己的构造函数．题中先调用base的构造函数，然后调用base1、base2的构造函数，最后调用derived的构造函数。

  • 第19题：

    有如下程序:includeincludeusing namespace std;class BASE{char c;public

    有如下程序： #include＜iostream＞#include＜iosream＞ using namespace std； class BASE{ char c； public； BASE(char n)：c(n){} virtual ～ BASE(){cout＜＜c;} }； class DERIVED; public BASE{ char c； public： DERIVED (char n): BASE (n+1)

    A．XY

    B．YX

    C．X

    D．Y


    正确答案：A

  • 第20题：

    有以下程序include using namespace std:class Base{private:char c;public:Base(cha

    有以下程序#include ＜iostream＞using namespace std:class Base{private: char c;public: Base(char n) :c(n) {} ～Base ( ) { cout＜＜c; }}; class Derived : public Base{private: char c;public: Derived(char n):Base (n+1),c(n) {} ～Derived() { cout＜＜c; }};int main(){ Derived obj('x'); return 0;} 执行后的输出结果是

    A．xy

    B．yx

    C．x

    D．y


    正确答案：A
    解析：本题考核继承与派生中继承基类的数据成员与成员函数。在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反．在此题的程序中，在主函数main结束时，派生类Derived对象obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出x，然后调用基类的析构函数，输出y。

  • 第21题：

    有如下程序: include using namespace std; class Base { public:

    有如下程序： #include＜iostream＞ using namespace std; class Base { public: void fun() { cout＜＜"Base::fun"＜＜endl; } }; class Derived: public Base { public: void tim() } ____________ cout＜＜"Derived:: fun"＜＜endl; } }; int main() { Derived d; d.fun(); return O; } 已知其执行后的输出结果为： Base::fun Derived::fun 则程序中下划线处应填入的语句是

    A．Base.fun()；

    B．Base::fun()；

    C．Base-＞fun()；

    D．fun()；


    正确答案：B
    解析：本题考查的知识点是继承的运用。题目中要求的两行输出结果分别在基类的成员函数fun()与派生类的成员函数fun()中给出，而主函数中只通过派生类对象d调用fun()函数，即只调用了派生类的成员函数fun()。所以，横线处应该填入对基类成员函数fun()的调用语句，此处只能使用作用域运算符“::”才能调用到基类中的同名函数，故应该选择B。

  • 第22题：

    有如下程序includeusing namespace std;class Base{protected:Base(){cout<<'A';}Bas

    有如下程序 #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 dl('B')； return 0； } 执行这个程序屏幕上将显示输出( )。

    A．B

    B．BA

    C．AB

    D．BB


    正确答案：C

  • 第23题：

    有以下程序includeusing namespace std;class Base{private:char c;public:Base(char

    有以下程序 #include＜iostream＞ using namespace std； class Base { private： char c； public： Base(char n)：c(n){} ～Base() { cout＜＜c； } }； class Derived：public Base { private： char c； public： Derived(char n)：Base(n+1)，c(n){} ～Derived() { cout＜＜c； } }； int main() { Derived obj('x')； return 0； } 执行后的输出结果是

    A．xy

    B．yx

    C．x

    D．y


    正确答案：A
    解析：本题考核继承与派生中继承基类的数据成员与成员函数。在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。在此题的程序中，在主函数main结束时，派生类Derived对象obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出x，然后调用基类的析构函数，输出y。

相关内容