有如下程序： #includeusingnamespacestd； classA { public： A（）{cout<<"A"；} ～A（）{cout<<"～A"；} }； classB { A*P： public： B（）{cout<<"B"；p=newA；} ～B（）{cout<<"～B"；deleteP；} }； intmain（） { Bobi； return0； } 执行这个程序的输出结果是（ ）。A.BAA～A～B～AB.ABA～B～A～AC.BAA～B～A～AD.ABA～A～B～A

题目

有如下程序： #include

usingnamespacestd； classA { public： A（）{cout<<"A"；} ～A（）{cout<<"～A"；} }； classB { A*P： public： B（）{cout<<"B"；p=newA；} ～B（）{cout<<"～B"；deleteP；} }； intmain（） { Bobi； return0； } 执行这个程序的输出结果是（ ）。

A.BAA～A～B～A

B.ABA～B～A～A

C.BAA～B～A～A

D.ABA～A～B～A

相似考题

1.有如下程序：#includeusing namespace std;class Base{public:void funl(){cout<<"Base\n";}virtual void fun2(){cout<<"Base\n";}};class Derived:public Base{public:void funl(){cout<<"Derived\n";}void fun2(){cout<<"Derived\n";}};void f(Base &B ． {b.funl();b.fun2();}&, lt;, /P>int main(){Derived obj;f(obj);return 0;}执行这个程序的输出结果是A ． Base BaseB ． Base DerivedC ． Derived BaseD ． Derived Derived

2.在下面程序的横线处填上适当的语句,使程序执行后的输出结果为ABCD。 include using nam在下面程序的横线处填上适当的语句，使程序执行后的输出结果为ABCD。include＜iostream＞using namespace std;classA{public:A(){cout＜＜'A';}};class B:______{public:B(){cout＜＜'B';}};class C:______{public:C(){cout＜＜'C';}};class D:public B,public C{public:D(){cout＜＜'D';}};void main(){D obj;)

3.有如下程序:includeusing namespace std;classA{public:virtua1 voidfunc1(){cout有如下程序： #include＜iostream＞ using namespace std； classA{ public： virtua1 voidfunc1(){cout＜＜“A1”；} voidfunc2(){cout＜＜“A2”；}}； class B：publicA{ public： void funcl(){cout＜＜“B1”；} void func2(){cout＜＜“B2”；}}； intmain(){ A*p＝neA．B1B2B．A1A2C．B1A2D．A1B2

4.下面程序输出的结果为（ ）。include"iostream．h"classA{public：A（）{cOUt＜＜"CLASSA"＜＜endl；}～A（）{}}；ClaSSB：publicA{public：B（）{cout＜＜"CLASSB"＜＜endl；}～B（）{}}；voidmain（）{A*P；P=newB：B*q：q=newB；}A.CLASSAB.CLASSACLASSBCLASSBCLASSBC.CLASSAD.CLASSACLASSBCLASSBCLASSACLASSBCLASSBCLASSB

更多“有如下程序: #includeusingnamespacestd; classA { public: A(){cout&lt;&lt;&quot;A&quot;;} ~A ”相关问题

  • 第1题：

    有以下程序： #include<iostream> usingnamespacestd； classA{ public： A（ ）{cout<<"A"；} }； classB{public：B（ ）{cout<<"B"；}}； classC：publicA{ Bb； public： C（ ）{cout<<"C"；} }； intmain（ ）{Cobj；return0；} 执行后的输出结果是（ ）。

    A.CBA

    B.BAC

    C.ACB

    D.ABC


    正确答案：D
    D。【解析】本题考查的是类的继承和派生。系统首先要通过派生类的构造函数调用基类的构造函数，对基类成员初始化，然后对派生类中的新增成员初始化。

  • 第2题：

    有如下程序:includeusing namespace std;classA{public:A(){cout<<"A";}};class B{pu

    有如下程序： #include＜iostream＞ using namespace std; classA { 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;} 执行后的输出结果是( )

    A．ABC

    B．BAC

    C．ACB

    D．CBA


    正确答案：A

  • 第3题：

    下面程序段的输出结果为 package test； public class ClassA { int x=20； static int y=6； public static void main(String args[]) { ClassB b=new ClassB()； b.go(10)； System.out.println("x="+b.x)； } } class ClassB { int x； void go(int y) { ClassA a=new ClassA()； x=a.y； } }

    A．x=10

    B．x=20

    C．x=6

    D．编译不通过


    正确答案：C
    解析：本题考查在Java中静态变量(类变量)的用法。在题目程序段中生成了一个static int y=6类变量，在ClassA中调用的 b．go(10)，只不过是在ClassB中的一个局部变量，通过调用ClassB中的go方法可以生成一个ClassA对象，并给这个新生成的对象赋以ClassA中的类变量y的值。从main()方法作为入口执行程序，首先生成一个ClassB的对象，然后b.go(10)会调用 ClassA，会给x和y赋值，x=a.y后，x值为6，再返回去执行System.out.println("x="/b.x)语句，输出为x=6，可见，正确答案为选项C。

  • 第4题：

    有如下程序： #included<iostream> usingnamespacestd； classA{ public： virtualvoidfuncl（）{cout<<"A1"；) voidrune2（）{cout<<"A2"；}}； classB：publicA{ public： voidfuncl（）{cout<<："B1"；} voidfunc2（）{eout<<"B2"；}}； intmain（）{ A*p=newB； p->func1（）； P->func2（）； return0；} 执行该程序，屏幕上将显示输出（ ）。

    A.B1B2

    B.A1A2

    C.B1A2

    D.A1B2


    正确答案：C
    C。【解析】程序中B为A的派生类，由主函数入手，主函数中定义了类A的指针P指向类B。根据基类中的“virtualvoidfuncl”知道A中的funcl为虚函数，执行“P->fund；”语句，通过指针变量调用此虚函数，此时调用的就是指针变量指向的同名函数，即派生类的fund函数，输出B1。而fun2不是虚函数，所以执行“p->func2；”输出为A2。

  • 第5题：

    下面程序段的输出结果为（ ）。 package test； public class ClassA { int x=20： static int y=6； public static void main(String args[]) { ClassB b=new ClassB； go(10)； System．out．println("x="+b．x)； } } class ClassB { int X； void go(int y) { ClassA a=new ClassA； x=a．Y ； } }

    A.x=10

    B.x=20

    C.x=6

    D.编译不通过


    正确答案：C
    C。【解析】本题考查在Java中静态变量(类变量)的用法。在题目程序段中生成了一个staticinty=6类变量，在ClassA中调用的b．go(10)，只不过是在ClassB中的一个局部变量，通过调用ClassB中的90方法可以生成一个ClassA对象，并给这个新生成的对象赋以ClassA中的类变量Y的值。从main方法作为入口执行程序，首先生成一个ClassB的对象，然后b．go(10)会调用ClassA，会给X和Y赋值，X=a．Y后，X值为6，再返回去执行System．out．println("x="+b．x)语句，输出为x=6，可见，正确答案为选项C。

  • 第6题：

    设有以下定义和程序:includeclassA1{public:void show1(){ cout<<"classA1”<

    设有以下定义和程序： #include＜iostream.h＞ classA1 { public： void show1() { cout＜＜"classA1”＜＜end1； } }； classA2：public A1 { public： void show2() { cout＜＜"classA2"＜＜end1； } }； class A3：protected A2 { public： voidshow3() { cout＜＜"class A1”＜＜end1； } }； void main() { A1obj1； A2obj2； A3obj3； } 则以下不合语法的调用语句是

    A．obj1．show1()；

    B．obj2．show1();

    C．obj3．show1()；

    D．obj2．show2()；


    正确答案：C
    解析：本题考核派生类的使用以及访问权限问题。C++中，通过类的对象只能访问类的公有成员，不能访问类的保护成员和私有成员。A2是A1的公有派生类，A3是A2的保护派生类，所以类A1的成员函数show1()在类A3中呈现保护属性，不能通过A3类的对象访问。

  • 第7题：

    若有以下程序:includeusingnamespacestd;classBase{public: Base() {x=0; } intx;};

    若有以下程序： #include ＜iostream＞ using namespace std； class Base { public： Base() { x=0； } int x； }； class Derivedl : virtual public Base { public: Derivedl() { x=10; } }; class Derived2 : virtual public Base { public: Derived2() { x=20; } }; class Derived : public Derivedl,protected Derived2 { }; int main () { Derived obj; cout＜＜obj.x＜＜end1; return 0; } 该程序运行后的输出结果是( )。

    A．10

    B．20

    C．30

    D．0


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

  • 第8题：

    有以下源程序： package test; public class ClassA { int x=20; static int y=6; public static void main(String args[]) { ClassB b=new ClassB(); b.go(10); System.out.println("x="+b.x); } } class ClassB { int x; void go(int y) { ClassA a=new ClassA(); x=a.y; } } 上述源程序文件的运行结果为( )。

    A．x=10

    B．x=20

    C．x=6

    D．编译不通过


    正确答案：C
    解析：本题考查在Java中静态变量(类变量)的用法规则。对于static修饰的成员变量和成员方法，可以直接使用类名对它们进行访问。对于类变量，也就是static修饰的变量，在生成类的第一个实例对象时，Java运行时，系统对这个对象的每个类变量分配一块内存，以后再生成该类的实例对象时，所有实例对象将共享同一个类变量，每个实例对象对类变量的改变都会直接影响到其他实例对象，类变量除了可以通过类名直接访问外，还可以通过实例对象来访问。在本例中生成了一个staticinty=6类变量，在ClassA中调用的b.go(10)，只不过是ClassB中的一个局部变量，通过调用ClassB中的go方法可以实现生成一个ClassA对象，并给这个新生成的对象赋予ClassA中的类变量y的值。

  • 第9题：

    在下列程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD（ ）。

    #include<iostream>

    usingnamespacestd；

    classA

    {

    public：A（）{cout<<'A'；}

    }；

    classB：

    {

    public：B（）{cout<<'B'；}

    }；

    classC：virtualpublicA

    {

    public：C（）{cout<<'C'；}

    }；

    classD：publicB，publicD

    {

    public：D（）{cout<<'D'；}

    }；

    voidmain（）{D04；}

    A.publicA

    B.privateA

    C.protectedA

    D.virtualpublicA


    正确答案：D
    D。【解析】由主函数main入手，定义了类D对象obi。其中D为类B和C的公有继承，A是C的虚基类。题目中要求的输出结果为ABCD，依次为类A、类B、类C、类D中构造函数的输出语句。为了保证基类通过多条路径被派生类继承，即保证A只被继承一次，输出一个A，所以不但需要声明A为C的虚基类，同样也要声明A为B的虚基类。

  • 第10题：

    有以下程序:inClUdeusingnamespacestd;ClassBase{public: Base(intx) {a=x; } voidsh

    有以下程序： #inClUde ＜iostream＞ using namespace std； Class Base { public： Base(int x) { a=x； } void show() { cout＜＜a； } private： int a； }； class Derived ： public Base { public： Derived(int i) ：Base(i+1)，b(i){} void Show() { cout＜＜b； } private： int b； }； int main() { Base b(5)，*pb； Derived d(1)； pb=&d； pb-＞show()； return 0； } 运行后的输出结果是( )。

    A．1

    B．5

    C．2

    D．0


    正确答案：C
    解析：基类Base派生出派生类Derived，在主函数中，定义了基类对象b，基类指针pb，以及派生类对象d，并让基类指针pb指向派生类对象d。在C++中，当派生类的对象赋值给基类对象时，只能使用派生类对象中从基类继承的成员。所以最后执行语句“pb->show()；”是调用基类的成员函数show()，输出a的值2。

  • 第11题：

    要想在网页中输出“<”正确的方法是（）。

    • A、&amp；
    • B、&lt；
    • C、&gt；
    • D、&quot；

    正确答案:B

  • 第12题：

    单选题
    10. public class ClassA {  11. public void count（int i） {  12. count（++i）；  13. }  14. }  And：  20. ClassA a = new ClassA（）；  21. a.count（3）；  Which exception or error should be thrown by the virtual machine？（）
    A

     StackOverflowError

    B

     NullPointerException

    C

     NumberFormatException

    D

     IllegalArgumentException

    E

     ExceptionlnlnitializerError


    正确答案： B
    解析： 暂无解析

  • 第13题：

    若有以下程序:includeusingnamespacestd;classA{private:int x; public:int x;void s

    若有以下程序： #include＜iostream＞ usingnamespacestd； classA { private： int x； public： int x； void setx(int i) { x=i； } int getx() { return x； } }； class B：public A { private： int m； public： int p； void setvalue (int a,int b,int C) { setx(A) ； z=b； m=c； } void display() { cout＜＜getx()＜＜","＜＜z＜＜","＜＜m＜＜end1； } }； int main() { B obj； obj.setvalue(2，3,4)； obj．display()； return 0； } 程序运行以后的输出结果是

    A．产生语法错误

    B．2,3,4

    C．2,2,2

    D．4,3,2


    正确答案：B
    解析：本题考核继承与派生。当类的继承方式为公有继承时，基类的公有成员和保护成员分别作为派生类的公有成员和保护成员，派生类的其他成员可以直接访问它们。其他外部使用者只能通过派生类的对象访问继承宋的公有成员。在本题中，数据成员z和函数setx都是基类A的公有成员，它们经过公有继承以后，在派生类B中还是公有成员，而派生类B中的函数setvalue和display都是公有成员，可以通过对象对它们进行访问。所以程序中对各成员的访问是正确的。本程序的功能是输出已设置的各成员的值。

  • 第14题：

    有以下程序:includeusing namespace std;classA{private: int x;public: A(int a) {x

    有以下程序: #include＜iostream＞ using namespace std; class A { private: int x; public: A(int a) { x=a; } friend class B; }; class B { public: void print(A a) { a.x--; cout＜＜a, x＜＜end1; } }; int main () { A a(10); B b; b.print (a) ; return 0; } 程序执行后的输出结果是( )。

    A．9

    B．10

    C．11

    D．12


    正确答案：A
    解析：本题考核友元类的应用。在程序中，类B是类A的友元类，因此，在类B的所有成员函数中均可访问类A的任何成员。在main()中，先定义类A的一个对象a(10)和类B的一个对象b。然后通过对象b调用其成员函数print()，输出对象a的私有成员x的值减1即9。

  • 第15题：

    下面程序的运行结果为（ ）。 #include<iostream．h> ClassA { public：A（ ）{cout<<"1"；} ～A（ ）{cout<<"2"；} }； ClassB：public：A { public： B（ ）{cout<<"3"；} ～B（ ）{cout<<"4"；} }； Voidmain（ ） { Bb； }

    A.1234

    B.1324

    C.1342

    D.3142


    正确答案：C
    C。【解析】本题考查在继承中构造函数和析构函数的调用顺序，应该是先调用基类的构造函数，再调用派生类的构造函数，调用析构函数时的顺序是先调用派生类的析构函数，后调用基类的析构函数。

  • 第16题：

    在下列程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD（ ）。 #include<iostream> usingnamespacestd； classA { public：A（）{cout<<A；} }； classB： { public：B（）{cout<<B；} }； classC：virtualpublicA { public：C（）{cout<<C；} }； classD：publicB，publicD { public：D（）{cout<<D；} }； voidmain（）{D04；}

    A.publicA

    B.privateA

    C.protectedA

    D.virtualpublicA


    正确答案：D
    D。【解析】由主函数main入手，定义了类D对象obi。其中D为类B和C的公有继承，A是C的虚基类。题目中要求的输出结果为ABCD，依次为类A、类B、类C、类D中构造函数的输出语句。为了保证基类通过多条路径被派生类继承，即保证A只被继承一次，输出一个A，所以不但需要声明A为C的虚基类，同样也要声明A为B的虚基类。

  • 第17题：

    下面程序输出的结果为（ ）。 #include"iostream．h" classA {public： A（）{cOUt<<"CLASSA"<<endl；} ～A（）{}}； ClaSSB：publicA {public： B（）{cout<<"CLASSB"<<endl；} ～B（）{}}； voidmain（） {A*P； P=newB： B*q： q=newB；}

    A.CLASSA

    B.CLASSA CLASSBCLASSB CLASSB

    C.CLASSA

    D.CLASSA CLASSBCLASSB CLASSACLASSB CLASSBCLASSB


    正确答案：C
    C。【解析】本题考查类的继承、类的实例化和构造函数、析构函数的调用方式以及何时调用。每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。

  • 第18题：

    有如下程序： #include<iostream> usingnamespacestd； classA { public： A（）{cout<<"A"；} ～A（）{cout<<"～A"；} }； classB { A*P： public： B（）{cout<<"B"；p=newA；} ～B（）{cout<<"～B"；deleteP；} }； intmain（） { Bobi； return0； } 执行这个程序的输出结果是（ ）。

    A.BAA～A～B～A

    B.ABA～B～A～A

    C.BAA～B～A～A

    D.ABA～A～B～A


    正确答案：B
    B。【解析】本题考查的是类的构造函数和析构函数。派生类构造函数的执行顺序：首先调用基类的构造函数，调用顺序按它们被继承时说明的顺序；然后调用子对象的构造函数，调用顺序按它们在类中说明的顺序；最后是派生类构造函数中的内容。因此本题中，首先调用基类构造函数输出A，然后调用子对象的构造函数输出B，P=newA再调用类A的构造函数输出A。析构函数的调用顺序和构造函数的调用顺序相反。

  • 第19题：

    下面程序的结果是（ ）。 #include(iostream．h> classA { inta； public： A（ ）：a(1){} voidshowa（ ）(cout<<a；} }； classB { inta； public： B（ ）：a(2){} voidshowa（ ）{cout<<a；} }； classC：publicA，publicB { inta； public： C（ ）：a(3){} voidshowa（ ）{cout<<a；} }； voidmain（ ） { CC； showa（ ）； }

    A.1

    B.2

    C.3

    D.程序有错误


    正确答案：C
    C。【解析】类A，类B，中都有showa函数，类C继承后再次重写showa函数就解决了继承的二义性，这时C．showa函数显示的就是类C中的showa的值。

  • 第20题：

    有如下程序:includeusingnamespacestd;classXX{protected: intk;public: XX(intn=5):

    有如下程序： #include ＜iostream＞ using namespace std； class XX { protected： int k； public： XX(int n=5)：k(n){} ～XX() { cout＜＜"XX"； } virtual void f() const=0； }； inline void XX：：f()

    A．28XX

    B．28YYXX

    C．-33XX

    D．-33XXYY


    正确答案：A
    解析：本题中，&p是一个对象指针，通过使用new运算符变成了指向派生类YY的对象指针。所以当建立并初始化对象指针&p时，程序将调用基类XX的构造函数，给私有数据成员k赋值5。然后调用派生类YY的常成员函数f()，输出值2和8。最后调用基类XX的析构函数输出XX。

  • 第21题：

    下面程序输出的结果为( )。 include"iostream.h"classA{public: A(){cOUt<<&qu

    下面程序输出的结果为（ ）。

    #include"iostream．h"

    classA

    {public：

    A（）{cOUt<<"CLASSA"<<endl；}

    ～A（）{}}；

    ClaSSB：publicA

    {public：

    B（）{cout<<"CLASSB"<<endl；}

    ～B（）{}}；

    voidmain（）

    {A*P；

    P=newB：

    B*q：

    q=newB；}

    A.CLASSB

    B.CLASSA CLASSB CLASSB

    C.CLASSA CLASSB CLASSA CLASSB

    D.CLASSA CLASSB CLASSB CLASSB


    正确答案：C
    C。【解析】本题考查类的继承、类的实例化和构造函数、析构函数的调用方式以及何时调用。每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。

  • 第22题：

    10. public class ClassA {  11. public void count（int i） {  12. count（++i）；  13. }  14. }  And：  20. ClassA a = new ClassA（）；  21. a.count（3）；  Which exception or error should be thrown by the virtual machine？（） 

    • A、 StackOverflowError
    • B、 NullPointerException
    • C、 NumberFormatException
    • D、 IllegalArgumentException
    • E、 ExceptionlnlnitializerError

    正确答案:A

  • 第23题：

    单选题
    类ClassA有一个名为M1的方法，在程序中有如下一段代码，假设该段代码是可以执行的，则声明M1方法时一定使用了（）修饰符。      ClassA Aobj=new ClassA（）；     ClassA.M1（）；
    A

     public

    B

     public static

    C

     private

    D

     virtual


    正确答案： A
    解析： 暂无解析

相关内容