2013微软实习生笔试题

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

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.CLASSACLASSBCLASSBCLASSB

C.CLASSA

D.CLASSACLASSBCLASSBCLASSACLASSBCLASSBCLASSB


正确答案：C

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

在下面程序的横线处填上适当的语句,使程序执行后的输出结果为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;)


正确答案：virtual A或virtual public A或virtual private A或virtual protected A与virtual A或virtual public A或virtual private A或virtual protected A
virtual A或virtual public A或virtual private A或virtual protected A与virtual A或virtual public A或virtual private A或virtual protected A 解析：由于每执行一次A类的构造函数，都将输出一个字符A，输出结果中只有一个A，且第一个输出为A，D继承B，可知必有B继承A。由题中要求C肯定继承某个类，所以，这里的C只能是继承于A，保证输出中只有一个A，A必须为虚基类，所以本题中的空都填virtual A。

有以下程序： #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。【解析】本题考查的是类的继承和派生。系统首先要通过派生类的构造函数调用基类的构造函数，对基类成员初始化，然后对派生类中的新增成员初始化。

有如下程序: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

下面程序段的输出结果为 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。

摘要:http://www.szjcbgjj.com/1.实现可变参数printf可以调用约定：A．cdeclB．stdcallC．pascalD．fastcall2.输出结果：classA{public:virtualvoidf(){cout<<"A:f()"<<endl;}voidf()const{cout<<"A:f()const"<<endl;}};classB:publicA{public:voidf(){cout<<"B:f()"<<endl;}http://www.ksam11.com http://www.szam11.com/voidf()const{cout<<"B:f()const"<<endl;}};voidga(constA*a){a->f();}int_tmain(intargc,_TCHAR*argv[]){A*a=newB();a->f();ga(a);}A.B::f()B::f()const….答案：B::f()A::f()const3.链表和数组的区别A.在有序的情况下的查找效率B.dynamicadd/removeC.randomaccessD.datatype4.关于线程和进程，下面哪句话正确：A.系统应用中一定至少有一个进程，但是不一定要有线程B.线程有自己的栈，必须和它的父进程共享自己的资源C.线程必须属于进程D.5.输出结果：intx=10;inty=10;x=x++;http://www.nbam11.com/ http://www.njam11.com/y=++y;printf("%d%d/n",x,y);sy

下面这个程序的结果是includeclass A{private:int a;public:void seta( );int geta

下面这个程序的结果是 #include＜iostream.h＞ class A { private： int a； public： void seta( )；int geta( )；}； void A::seta( ) { a = 1；} int A::geta( ) {return a；} class

A．1

B．2

C．随机输出1或2

D．程序有错


正确答案：D
解析：在类A中有geta()函数，在类B中也有geta()函数，类C继承了类A和类B，这样就产生了二义性，所以程序会出错。

下面程序输出的结果为 #include"iostream．h" class A { public： A(){cout＜＜"CLASSA"＜＜endl；} ～A() {} }; class B：public A { public： B(){cout＜＜"CLASSB"＜＜endl；} ～B() {} }； void main() { A * p； p=new B； B *q； q=new B； }

A．CLASS A CLASS B

B．CLASS A CLASS B CLASS B

C．CLASS A CLASS B CLASS A CLASS B

D．CLASS A CLASS B CLASS B CLASS B


正确答案：C
解析：每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。注意：类的实例化和构造函数、析函数的调用方式和何时调用。

在下面的程序中，若调用f1(x)时参数传递采用引用方式，调用f2(y)时参数传递采用传值方式，则输出结果为(47)；若调用f1(x)和f2(y)时参数传递都采用引用方式，则输出结果为(48)。

A．3

B．6

C．8

D．10


正确答案：C
解析：在高级语言中，使用参数是函数(子程序)之间传递信息的一种手段。最常用的参数调用方法有传值调用和引用调用：使用传值调用时，被调用的函数内部对形参的修改不影响实参的值；使用引用调用时，函数中对形参的访问和修改实际上就是对相应时参所作的访问和修改。因此，若调用n(x)时参数传递采用引用方式，调用f2(y)时宰数传递采用传值方式，则程序运行过程中a的值变化如图1所示：

下面程序的运行结果为（ ）。 #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。【解析】本题考查在继承中构造函数和析构函数的调用顺序，应该是先调用基类的构造函数，再调用派生类的构造函数，调用析构函数时的顺序是先调用派生类的析构函数，后调用基类的析构函数。

在下列程序的横线处填上适当的内容，使程序执行后的输出结果为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的虚基类。

更多 “2013微软实习生笔试题” 相关考题
考题 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=10B．x=20C．x=6D．编译不通过正确答案：C
查看答案
考题 在下面的程序中，若调用f1(x)时，参数传递采用传值方式，调用f2(y)时，参数传递采用引用方式，则输出结果为(47)；若调用f1(x)时，参数传递采用引用方式，调用f2(y)时，参数传递采用传值方式，则输出结果为(48)。A．2B．4C．6D．8正确答案：A解析：在过程(或函数)首部声明的参数称为形式参数，简称形参；过程(或函数)调用时的参数称为实际参数，简称实参。调用语句实现了对过程(或函数)体的执行，调用时首先要进行实参与形参间的参数传递。简单地说，以传值方式进行参数传递时，需要先计算出实参的值并将其传递给对应的形参，然后执行所调用的过程(或函数)，在过程(或函数)执行时对形参的修改不影响实参的值。若参数传递采用引用方式，则调用时首先计算实际参数的地址，并将此地址传递给被调用的过程，因此对应的形参既得到了实参的值又得到了实参的地址，然后执行被调用的过程(或函数)。在过程(或函数)的执行过程中，针对形式参数的修改将反映在对应的实际参数变量中。题目中若调用f1(x)时，参数传递采用传值方式，则主过程中实际参数a的值不会被改变，所以输出结果为2。若调用f1(x)时，参数传递采用引用方式，调用翅f2(y)时，参数传递采用传值方式，则在函数f1中调用f2不会改变f1中x的值，而在f1中对x的修改就会反映在主过程main的实参a中，因此输出结果为4。
查看答案
考题 在下列程序的横线处填上适当的内容，使程序执行后的输出结果为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.publicAB.privateAC.protectedAD.virtualpublicA正确答案：DD。【解析】由主函数main入手，定义了类D对象obi。其中D为类B和C的公有继承，A是C的虚基类。题目中要求的输出结果为ABCD，依次为类A、类B、类C、类D中构造函数的输出语句。为了保证基类通过多条路径被派生类继承，即保证A只被继承一次，输出一个A，所以不但需要声明A为C的虚基类，同样也要声明A为B的虚基类。
查看答案
考题 本题定义了一个方法add（），用于求两个整形数的和。方法中有两个整形参数a和b，方法体中计算a和b的和sum，并将结果返回。程序中调用add（）方法求整数24和34的和，并将结果打印输出。public class javal{public static void main（String[]args）{int a=24，b=34；System．out．println（add（a，b））；}public static int add（ ）{；sum—a+b；；}}正确答案：第1处：inta，intb第2处：intsum第3处：returnsum【解析】第1处是add方法的两个整型的形参；第2处是声明一个整型的变量sum；第3处是求得sum值后，返回sum。
查看答案
考题 下面程序输出的结果为（ ）。 #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.CLASSA CLASSBCLASSB CLASSBC.CLASSAD.CLASSA CLASSBCLASSB CLASSACLASSB CLASSBCLASSB正确答案：CC。【解析】本题考查类的继承、类的实例化和构造函数、析构函数的调用方式以及何时调用。每实例化一个类就要调用其构造函数，结束运行该实例后调用析构函数。
查看答案
考题 关于可变参数说法正确的是（）A、可变参数可以在参数列表的任何位置B、一个方法中允许包含多个可变参数C、可变参数的本质就是一个数组 调用一个包含可变参数的方法时，只能传入多个参数D、不能传入数组正确答案:C
查看答案
考题 若有定义inta=8,b=5;要实现输出形式为：8*5=40，正确的printf()函数调用语句是()。A.printf(“a*b=a*b\n”);B.printf(“a*b=%d\n”,a*B.;C.printf(“%d*%d=a*b\n”,a,B.;D.printf(“%d*%d=%d\n”,a,b,a*B.;正确答案：D
查看答案
考题 有如下程序： #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～AB.ABA～B～A～AC.BAA～B～A～AD.ABA～A～B～A正确答案：BB。【解析】本题考查的是类的构造函数和析构函数。派生类构造函数的执行顺序：首先调用基类的构造函数，调用顺序按它们被继承时说明的顺序；然后调用子对象的构造函数，调用顺序按它们在类中说明的顺序；最后是派生类构造函数中的内容。因此本题中，首先调用基类构造函数输出A，然后调用子对象的构造函数输出B，P=newA再调用类A的构造函数输出A。析构函数的调用顺序和构造函数的调用顺序相反。
查看答案
考题 有以下程序： #include<iostream> usingnamespacestd； classA{ public： A（）{cout<<"A"；} }； classB{public：B（）{cout<<"B"；}}； classC：publicA{ Bb； public： C（）{cout<<"C"；} }； intmain（）{Cobj；return0；} 执行后的输出结果是（ ）。A.CBAB.BACC.ACBD.ABC正确答案：DD。【解析】本题考查的是类的继承和派生。系统首先要通过派生类的构造函数调用基类的构造函数，对基类成员初始化，然后对派生类中的新增成员初始化。
查看答案
考题 下面程序段的输出结果为 package test； public class Class A { int x=20； static int y=6； public static void main(String args[]) { Class B b=new Class B(); 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=10B．x-20C．x=6D．编译不通过正确答案：C解析：本题考查在Java中静态变量(类变量)的用法。在题目程序段中生成了一个staticinty=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。
查看答案
相关内容
最新试卷
热门试卷