instanceOf（obj，class）判断类型是不是指定类或其子类

题目

相似考题

1.下列程序段中，A_class的成员函数Variance()可求出两数的平方差，请改写该程序段，把Variance()函数从A_class类中分离出来，用友元函数来实现该函数的功能。class A_class { private: intx,y,t; public: A_class(int i,int j):x(i),y(j) { if(y>x){t=x;x=y;y=t;} } intVariance(){return x*x-y*y;} //其它函数从略};void main() { A_classA_obj(3,5); cout<<"Result:"<<A_obj.Variance()<<endl;}

2.以下程序的执行结果是【】。 include using namespace std; class base { public: virmal以下程序的执行结果是【】。include＜iostream＞using namespace std；class base{public：virmal void who(){cout＜＜"Base Class"＜＜endl；)}；class Derivedl:public Base{public：virtual void who(){cout＜＜"Derivedl Class"＜＜endl;}}；class derived2:public Base{public：virtual void who(){cout＜＜"Derived2 Class"＜＜endl；)}；int main(int argc，char*argv[]){base obj1，*P；deliVedl obj2；derived2 obj3；p=&obj1； p-＞who()；p=&obj2； p-＞who()；p=&obj3； p-＞who()；return 0；}

3.（ 29 ）有如下程序：#includeusing namespace std;class Obj{static int i;public:Obj( ){ i++; }~Obj( ){ i--; }static int getVal( ){ return i;}};int Obj::i=0;void f(){Obj ob2; cout<int main( ){Obj ob1;f( );Obj *ob3=new Obj; cout<getVal( );delete ob3; cout< return 0;}程序的输出结果是A ） 232B ） 231C ） 222D ） 221

4.有如下程序#includeusing namespace std;class Obj{static int i;public:Obj（）{i++;}~Obj（）{i--;}static int getVal（）{teturn i;}};int Obj::i=0;void f （）{Obj ob2;coutObj obl;F（）;Obj*ob3=new Obj;coutDelete ob3;cout}程序的输出结果是______。A．232B．231C．222D．221

更多“instanceOf（obj，class）判断类型是不是指定类或”相关问题

第1题：

有以下程序 include using namespace std; class MyClass { public:

有以下程序 #include＜iostream＞ using namespace std； class MyClass { public： MyClass(intn) {number＝n；} //拷贝构造函数 MyClass (MyClass& other) {number＝other.number；} ～MyClass(){} private： int number； }； MyClass fun (MyClass p) { MyClass temp(p)； return temp； } intmain() { MyClass obj1(10)，obj2(0)； MyClass obj3(obj1)； obj2=fun(obj3)； return0； } 程序执行时，MyClass类的拷贝构造函数被调用的次数是
A．5
B．4
C．3
D．2

正确答案：B
解析：本题考核C＋＋的拷贝构造函数。调用拷贝构造函数的情况为：一个新对象被另一个已存在的同类型对象初始化：当一个对象作为实参传递给函数时为初始化形参，要调用拷贝构造函数。在函数值返回时形参的生命期结束时它的结构函数被调用；在函数返回一个对象时调用拷贝构造函数。符合以上条件的有：用对象。obj1来初始化。obj3；obj3作为实参被传入；函数fun返回一个对象时；系统用返回值初始化一个匿名对象时调用了拷贝构造函数。总共调用4次。
第2题：

（ 31 ）若有如下类定义 :
class B{
void fun1(){}
protected:
double varl;
public:
void fun2(){}
};
class D:public B{
protected:
void fun3(){}
};
已知 obj 是类 D 的对象，下列句中不违反类成员访问控制权限的是
A ） obj.funl();
B ） obj.varl;
C ） obj.fun2();
D ） obj.fun3();

正确答案：C
第3题：

下列程序执行结果是 include class A { public: int a; A( ):a(10){tout<

下列程序执行结果是
#include＜iostream.h＞
class A
{ public:
int a;
A( ):a(10){tout＜＜a＜＜endl;}
};
void main( )
{ A obj1;
A obj2(obj1);
cout＜＜" "＜＜obj2.a＜＜endl;
}
A．10 10
B．编译错误缺少拷贝构造函数
C．10 随机数
D．随机数随机数

正确答案：A
解析：本题考察拷贝构造函数的知识。如果类中没有实现拷贝构造函数，则编译器会为其自动生成一个。对于本题这种简单对象，默认生成的拷贝构造函数可以完成数据成员的自动赋值，对于复杂对象，则可能需要显式定义拷贝构造函数。
第4题：

有如下程序:includeusing namespace std;class TestClass{static int i;public:TestC

有如下程序： #include＜iostream＞ using namespace std; class TestClass{ static int i; public: TestClass(){i++;} ～TestClass(){i--;} static int getVal(){return i;} }; int TestClass::i=0; void f(){TestClass obj2;cout＜＜obj2.getVal();} int main(){ TestClass obj 1; f(); TestClass *obj3=new TestClass;cout＜＜obj3-＞getVal(); delete obj3;cout＜＜TestClass::getVal(); return 0; } 程序的输出结果是( )。
A．232
B．221
C．222
D．231

正确答案：B
解析：有如下程序： #includeiostream＞ using namespace std; class TestClass{ static int i; public: TestClass(){i++;} ～TestClass(){i--;} static int getVal(){return i;} }; int TestClass::i=0; void f(){TestClass obj2;coutobj2.getVal();} int main(){ TestClass obj 1; f(); TestClass *obj3=new TestClass;coutobj3-＞getVal(); delete obj3;coutTestClass::getVal(); return 0; } 程序的输出结果是( )。
第5题：

有如下程序:include using namespace std;class Obj { static int i;public:Obj(){i＋

有如下程序：#include ＜iostream＞using namespace std;class Obj { static int i;public: Obj(){i++;} -Obj(){i--;} static int getVal(){return i;} };int Obj::i=0;void f(){Obj ob2; cout＜＜ob2.getVal(); }hat main(){ Obj ob1; f(); Obj *ob3=new Obj; cout＜＜ob3-＞getVal(); delete ob3; cout＜＜Obj:: getVal(); return (); }程序的输出结果是( )。
A．232
B．231
C．222
D．221

正确答案：D
第6题：

若有以下程序: include using namespace std; class Base { public:void who(){ cout

若有以下程序：
include ＜iostream＞
using namespace std;
class Base
{
public:
void who()
{
cout＜＜"class Base"＜＜end1;
}
};
class Derivedl : public Base
{
public:
void who()
{
cout＜＜"class Derivedl"＜＜end1;
}
};
class Derived2 : public Base
{
public:
void who()
{
cout＜＜"class Derived2"＜＜end1;
}
};
int main()
{
Base *p;
Derivedl obj1;
Derived2 obi2;
p=&obj 1;
p=&obj2;
p-＞who ( );
return 0;
}
则该程序运行后的输出结果是【】。

正确答案：class Derived2
class Derived2 解析：本题考核对象指针的应用。主函数中定义了一个Base类对象指针p，然后逐步被赋值为obj1和obj2，最后通过对象指针p调用函数who()，也即调用Derived2中的函数who()，输出class Derived2。
第7题：

设有以下定义和程序:includeclass A1{public: void show1(){cout<<"class A1"<

设有以下定义和程序：#include＜iostream.h＞class A1{public： void show1() { cout＜＜"class A1"＜＜endl； } };class A2 : public A1{public: void show2() { cout＜＜"class A2"＜＜end1 }};class A3 : protected A2{public: void show3() { cout＜＜"class A1"＜＜endl; }};void main(){ A1 obj1; A2 obj2; A3 obj3;} 则以下不合语法的调用语句是
A．obj1. showl()；
B．obj2. showl()；
C．obj3. showl()；
D．obj2. show2()；

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

有以下程序include using namespace std;class MyClass{public:MyClass(int n) { num

有以下程序#include ＜iostream＞using namespace std;class MyClass{public: MyClass(int n) { number=n; } //拷贝的构造函数 MyClass(MyClass& other) {number=other. number; } ～MyClass() { }private: int number;};MyClass fun(MyClass p){ MyClass temp(p); return temp;}int main() MyClass obj 1 (10), obj 2(0); MyClass obi 3 (obj 1); obj2=fun(obj3); return 0;}程序执行时，MyClass 类的拷贝构造函数被调用的次数是( )。
A．5
B．4
C．3
D．2

正确答案：B
第9题：

有如下类定义： class B { public：void funl{} private：void fun2{} protected：void fun3{} }； class D：public B j protected：void fun4{} }；若obj是类D的对象，则下列语句中不违反访问控制权限的是（）。
A.obj．fun1；
B.obj．fun2；
C.obj．tim3；
D.ohj．fun4；

正确答案：A
本题考查公用继承对基类成员的访问属性。在公用继承中，基类的公用成员和保护成员在派生类中保持原有的访问属性，其私有成员仍为基类私有。所以在本题中，在类外引用成员函数时，派生对象只能引用基类的公用成员函数fun1，故本题答案为A。
第10题：

设有以下定义和程序:includeclass A1{public:void show1(){cout<<"class A1"<

设有以下定义和程序： #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 A1"＜＜endl； } }； void main() { A1 obj1； A2 obj2； A3 obi3； } 则以下不合语法的调用语句是( )。
A．objl.show1()；
B．obj2.show1()；
C．obj3.show1()；
D．obj2.show2()；

正确答案：C
第11题：

设有如下代码：
interface IFace{}
class CFace implements IFace{}
class Base{}
public class ObRef extends Base{
public static void main(String argv[]){
ObRef bj = new ObRef();
Base b = new Base();
Object obj1 = new Object();
IFace obj2 = new CFace();
//Here
}
}
则在 //Here处插入哪个代码将不出现编译和运行错误。
A.obj1=obj2;
B.b=obj;
C.obj=b;
D.obj1=b;

正确答案：ABD
第12题：

判断题
instanceOf（obj，class）判断类型是不是指定类或其子类
A
对
B
错

正确答案：错
解析：暂无解析
第13题：

有如下程序: include using namespace std; class Obj { static in

有如下程序： #include ＜iostream＞ using namespace std; class Obj { static int i; public: Obj( ){i++;} ～Obj(){i--;} static int getVal( ){ return i;} }; int Obj::i=0; void f() {Obj ob2; cout＜＜ob2.getVal( ); } int main( ){ Obj ob1; f(); Obj *ob3=ew Obj; cout＜＜ob3-＞getVal( ); delete ob3; cout＜＜Obj::getVal( ); return 0; } 程序的输出结果是
A．232
B．231
C．222
D．221

正确答案：D
解析：本题主要考查的是静态成员。静态成员的特性是不管这个类创建了多少个对象，它的静态成员都只有一个拷贝(副本)，这个副本被所有属于这个类的对象共享。本例中，Obj类定义了一个静态数据成员i，并初始化为0。在主函数中，首先定义了1个该类对象ob1，所以构造函数被执行1次，i被加1。然后调用函数f()，该函数中又定义了一个对象ob2，此时i再次加1变成2，然后通过静态成员函数getVal()输出i的值2。f()函数结束了，局部变量ob2被释放，故析构函数被调用了1次，i变成1。回到主函数中，又动态创建了1个对象并让指针ob3指向它，所以i变成2，接着输出的值为2。最后，释放动态创建的那个对象，i变为1，所以最后输出的值为1。因此，程序最终输出结果为221，应该选择D。
第14题：

若有如下类定义： class B { void fun1() { protected: double var1; public: void fun2() { }, class D: public B protected: void fun3() { };已知obj是类D的对象，下列语句中不违反类成员访问控制权限的是
A．obj.fun1()；
B．obj.varl；
C．obj.fun2()；
D．obj.fun3()；

正确答案：C
解析：本题考查的知识点是：基类成员在派生类中的访问属性。基类中公有成员和保护成员在派生类中的访问属性将随着继承方式而改变：派生类从基类公有继承时，基类的公有成员和保护成员在派生类中仍然是公有成员和保护成员：派生类从基类私有继承时，基类的公有成员和保护成员在派生类中都改变为私有成员；派生类从基类保护继承时，基类的公有成员在派生类中改变为保护成员，基类的保护成员在派生类中仍为保护成员。本题中，D类从B类公有继承，B类中fun1()为私有、fun2()为公有、varl为保护，公有继承到D类后fun1()不可访问、fun2()仍为公有、varl仍为保护。D类自身的fun3()是保护属性。所以综上所述，只有从B类继承的fun2()为公有属性，故本题应该选择C。
第15题：

关于下面程序段说法正确的是()。class X { private: int n; public: X(X&); }; X::X(X&x) {n=x.n} X obj1,obj2(obj1);

A.语句obj2(obj1);的功能是用对象obj2初始化具有相同类类型的对象obj1
B.语句obj2(obj1);的功能是用对象obj1初始化具有相同类类型的对象obj2
C.X(X&x)函数中不能访问对象的私有成员
D.X(X&x)中的&符号可以删除

正确答案：B
第16题：

下列程序的运行结果是______。 include class A { public: virtual void use( ) {cou

下列程序的运行结果是______。
include＜iostream.h＞
class A
{
public:
virtual void use( ) {cout＜＜"in A\n";}
};
class B:public A
{
public:
virtual void use( ) {cout＜＜"in B\n";}
};
class C:public B
{
public:
virtual void use( ){cout<<"in C\n";}
};
void main( )
{
A*obj；
bj=new C;
obj-＞use( );
delete obj;
}

正确答案：in C
in C 解析：本题考查虚函数和多态性。原本obj指向祖先类，随后被赋值，指向新的子孙类，则在使用use这个重载的虚函数时，根据当前指向可确定调用子孙的同名虚函数。
第17题：

设有以下定义和程序:includeclass A1{public:void show1(){cout<<"class A1"<

设有以下定义和程序： #include＜iostream.h＞ class A1 { public: void show1() { cout＜＜"class A1"＜＜end1; } }; class A2:public A1 { public: void show2() { cout＜＜"class A2"＜＜end1; } }; class A3:protected A2 { public: void show3() { cout＜＜"class A1"＜＜end1; } }; void main() { A1 obj1; A2 obj2; A3 obj3; } 则以下不合语法的调用语句是( )。
A．obj1.show1();
B．obj2.show1();
C．obj3.show1();
D．obj2.show2();

正确答案：C
第18题：

以下程序的执行结果是______。 include class base { public: virtual void who(){c

以下程序的执行结果是______。
include＜iostream.h＞
class base
{
public：
virtual void who(){cout＜＜"base class"＜＜endl：}
}；
class derrvel:public base
{
public：
void who(){cout＜＜"derivel class"＜＜endl：}
};
class derive2；public base
{
public：
void who() {cout＜＜"derive2 class"＜＜endl；}
}；
void main()
{
base obj1，*P；
derive1 obj2；
derive2 obj3：
p=&obj1；
p-＞who()；
p=&obj2：
p-＞who()；
p=&obj3；
p-＞who()；
}

正确答案：base class derivel class derive2 class
base class derivel class derive2 class
第19题：

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

有如下程序： #include＜iostream＞ using namespace std； class Base { private： void funl()const {cout＜＜"funl"；} protected： void fun2() const{cout＜＜"fun2"；} public; void fun3() const {cout＜＜"fun3"；} }； class Derived：protected Base { public; void fun4() const {cout＜＜"fun4"；} }; int main() { Derived obj； obj.funl()； //① obj.fun2(); //② obj.fun3()； //③ obj.fun4()： //④ return 0; } 其中有语法错误的语句是
A．①②③④
B．①②③
C．②③④
D．①④

正确答案：B
解析：本题考查的知识点是保护继承。题目中的Derived类保护继承了Base类，因此Base类中的公有成员与保护成员均成了Derived类的保护成员，而Base类的私有成员Derived类不可访问。所以，主函数中通过Derived类的对象只能够访问到　Derived类的公有成员，即只能调用fun4()函数。故应该选择B。
第20题：

有以下程序:include using namespace std;class Base{public:Base(){}virtual void w

有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){} virtual void who() { cout＜＜"Base Class"＜＜end1; } ～Base(){} }; class Derivel : public Base { public: void who() { cout＜＜"Derivel Class"＜＜end1; } }; class Derive2 : public Base { public: void who () { cout＜＜"Derive2 Class"＜＜end1; } }; int main () { Base *p; Derivel obj1; Derive2 obj2; p=&obj1; p=&obj2; p-＞who ( ); return 0; } 执行程序后的输出结果是( )。
A．Base Class
B．Derivel Class
C．Derive2 Class
D．程序编译时出错

正确答案：C
解析：本题考核虚函数的应用。本题中，先定义了一个基类Base，它含有一个虚成员函数who()，随后定义的类Derivel和Derive2都是基类Base的公有派生类。在主函数中定义了一个指向Base类的指针，它也被允许指向其派生类。在执行过程中，不断改变它所指向的对象，p-＞who就能调用不同的函数实现。这是因为使用了虚函数，因而进行动态联编。程序最后把指针p指向派生类Derive2的对象，由于函数who()在基类Base中是虚函数，所以系统调用Derive2中的who()函数，最后输出Derive2Class。
第21题：

若有如下类定义： class B{ void funl(){} protected： double varl： public： void fun2(){} }； class D：public B{ protected： void fun3(){} }；已知obj是类D的对象，下列语句中不违反类成员访问控制权限的是( )。
A．obj.funl()；
B．obj.varl；
C．obj.fun2()；
D．obj.fun3()；

正确答案：C
第22题：

下列程序编译错误,是由于划线处缺少某个语句,该语句是______。 include class A { pr

下列程序编译错误，是由于划线处缺少某个语句，该语句是______。
include＜iostream.h＞
class A
{
private:
int numl;
public:
A( ):numl(0){}
A(int i):numl(i){}
};
class B
{
private:
int num2;
public:
B( ):num2(0){}
B(int i):num2(i){}
int my_math(A obj1, B obj2);
};
int B::my_math(A obj1,B obj2)
{
return(obj1.numl+obj2.num2);
}
void main(void)
{
A objl(4);
B obj,obj2(5);
cout＜＜"obj1+obj2:"＜＜obj.my_math(obj1,obj2);
}

正确答案：friend class B;
friend class B; 解析：在B类中出现了对A类中私有成员numl的直接访问，这是不允许的。所以必须要把类B设成类A的友员才可以通过编译。
第23题：

考虑如下代码：
class Tree{}
class Pine extends Tree{}
class Oak extends Tree{}
public class Forest {
public static void main( String[] args ) {
Tree tree = new Pine();
if( tree instanceof Pine )
System.out.println( "Pine" );
if( tree instanceof Tree )
System.out.println( "Tree" );
if( tree instanceof Oak )
System.out.println( "Oak" );
else
System.out.println( "Oops" );
}
}
则输出结果中有哪些?
A.Pine B.Tree C.Forest D.Oops E.无输出

正确答案：ABD

instanceOf（obj，class）判断类型是不是指定类或其子类

题目

相似考题

更多“instanceOf（obj，class）判断类型是不是指定类或”相关问题

相关内容