若有如下程序:includeusing namespace std;class TestClass{public:void who(){cout若有如下程序： #include＜iostream＞ using namespace std； class TestClass { public： void who(){cout＜＜“TestClass”＜＜endl；} }； class TestClassl：public TestClass { public： void who(){cout＜＜“TestCla

题目

若有如下程序:includeusing namespace std;class TestClass{public:void who(){cout<

若有如下程序： #include＜iostream＞ using namespace std； class TestClass { public： void who(){cout＜＜“TestClass”＜＜endl；} }； class TestClassl：public TestClass { public： void who(){cout＜＜“TestClassl”＜＜endl； int main() { TestC

A．TestClassl

B．TestClass

C．0

D．无输出

相似考题

1.有如下程序: include using namespace std; class TestClass{ int k; public: TestCla有如下程序:include＜iostream＞using namespace std;class TestClass{int k;public:TestClass(int x=1):k(x){}～TestClass O{cout＜＜k;}};int main(){TestClass a[]={TestClass(3),TestClass(3),TestClass(3)};TestClass *p=new TestClass[2];delete []p;return ():}这个程序的输出结果是______。

2.有如下程序:inCludeusing namespace std;Class TestClass{public:virtUal void furll有如下程序： #inClude＜iostream＞ using namespace std； Class TestClass {public： virtUal void furll() {cout＜＜“funlTestclass”；} virtual void fun2() {cout＜＜“{fun2TestClass”；}}； class TestClassl：public TestClass {void fun() {cout＜＜“fuA．fun1TestClass1 fun2TestClassB．fun1TestClass1 fun2TestClass1C．fUnlTestClass fun2TestClassD．funlTe3tClass fun2TestClassl

3.有如下程序:includeusing namespqce Std;class TestClass{private;Char C;public;Tes有如下程序： #include＜iostream＞ using namespqce Std； class TestClass { private； Char C； public； TestClass(char n)：c(n){} ～TestClass() { cout＜＜c； }； class TestClassl：public TestClass { private： Char C； public：A．xyB．yxC．xD．y

4.有如下程序:includeusing namespace std;Class TestClass{private:int x,y;public:Te有如下程序： #include＜iostream＞ using namespace std； Class TestClass { private： int x，y； public： TestClass(int i，int j) { x＝i; y＝j； } void print() { cout＜＜“print1”＜＜endl； } void print()const { cout＜＜”prinA．printlB．print2C．printl print2D．程序编译时出错。

更多“若有如下程序:includeusing namespace std;class TestClass{public:void who(){cout 若有如下程序： #include＜iostream＞ using namespace std； class TestClass { public： void who(){cout＜＜“TestClass”＜＜endl；} }； class”相关问题

第1题：

若有如下程序:includeusing namespace std;Class TestClass1{private:int a;public:T

若有如下程序： #include＜iostream＞ using namespace std； Class TestClass1 { private： int a； public： TestClassl(int i) { a=i； } void disp() { cout＜＜a＜＜“，”； } }； Class TestClass2 { private： int b； public
A．10，10，10
B．10，12，14
C．8，10，12
D．8，12，10

正确答案：D
解析：首先定义TestClass3的对象Obj，参数为10。其中TestClass3为TestClassl和TestClass2的派生类。然后调用disp成员函数。Disp中首先执行“TestClassl：：disp()；”，然后执行“TestClass2：：disp()；”，最后执行输出语句“coutcend1”。TestClass1(k-2)，所以第一个输出8，TestClass2(k+2)，第二个输出12，最后一个本类中的输出即为10。
第2题：

以下程序的执行结果为______。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
第3题：

有如下程序: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; } 程序的输出结果是( )。
第4题：

有如下程序:includeusing namespace std;{TestClass(){cout<<"BB";fun()}void fun(){

有如下程序： #include＜iostream＞ using namespace std; { 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;} 执行上面的程序将输出( )。
A．BBBfDD
B．BBDfDDDf
C．DD
D．DDBBBf

正确答案：A
第5题：

有如下程序:includeusing namespace std;class TestClass1{public:virtual void fun(

有如下程序： #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() { TestClass 1 aa,*p; TestClass2 bb; TestClass3 cc; p=&cc; P-＞fun(); return 0; } 执行上面程序的输出是( )。
A．1122
B．2112
C．2213
D．2223

正确答案：C
解析：主函数中定义TestClass1的对象aa，*p对象指针，TestClass2的对象bb以及TestClass3的对象cc。p指向cc，TestClass3为TestClass2的派生类，构造函数输出2。TestClass3中fun函数中为TestClass2中的。fun，调用TestClass2的构造函数，输出2。“p-＞fun();”，TestClass2继承于TestClass1中的fun，所以输出1。然后输出TestClass3中的“cout”3””，即输出3。
第6题：

若有以下程序: include using namespace std; class TestClass 1 { public: TestClass

若有以下程序：
include＜iostream＞
using namespace std;
class TestClass 1
{
public:
TestClass1()
{
X=0;
}
int x;
};
class TestClass2:virtual public TestClass1
{
public:
TestClass2()
{
x=10;
}
};
class TestClass3:virtual public TestClass 1
{
public:
TestClass3()
{
x=20;
}
};
class TestClass4:public TestClass2, protected TestClass3
{ };
int main()
{
TestClass4 obj;
cout＜＜obj.x＜＜end1;
return 0:
}
该程序运行后的输出结果是______。

正确答案：20
20
第7题：

有下列程序:includeusing namespace std;class TestClass{public:virtual void fun1(

有下列程序： #include＜iostream＞ using namespace std; class TestClass { public: virtual void fun1() { cout＜＜"fun1TestClass"; } virtual void fun2() { cout＜＜"fun2TestClass"; } }; class TeSt
A．fun1TeStClass1 fun2TeStClass
B．fun1TestClass1 fun2TestClass1
C．fun1TeStClass fun2TeStClass
D．fun1TestClaSSfun2TestClaSS1

正确答案：A
解析： TestClass为基类，TestClass1是TestClass的派生类。基类中的fun1和fun2被定义为虚函数，C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数，所以派生类中的fun1和fun2也是虚函数。本题从main主函数入手，首先定义了TestClass类型的对象ob1和指针p，然后又定义了TestClass1的对象obj2。指针指向对象obj2，然后调用其成员函数fun1()，即输出“fun1TesClass1”。
第8题：

有如下程序:includeusing namespace std;Class TestClass{int a;public:TestClass(in

有如下程序： #include＜iostream＞ using namespace std； Class TestClass {int a； public： TestClass(int x){a＝x；} void show(){cout＜＜a；}}； class TestClass1：public TestClass {int b； public： TestClass1(int i)：TestClass(i+1)，b(i){} voi
A．5
B．1
C．0
D．2

正确答案：D
解析： TestClass为TestClass1的基类，在主函数main中定义TestClass对象b，*p。TestClassl对象d，p指向d，调用其show函数。“TestClass(int i)：TestClass(i+1)，b(i){}”语句中的TestClass基类参数为2，所以show输出2。
第9题：

有下列程序:includeusing namespace std;class TestClass{protected:TestClass(){cou

有下列程序： #include＜iostream＞ using namespace std; class TestClass{ protected: TestClass(){cout＜＜'x';} TestClass(char c){cout＜＜c;} }; class TestClassl:public TestClass{ public: TestClassl(char c){cout＜＜c;}
A．y
B．yx
C．xy
D．yy

正确答案：C
解析：程序中的类TestClass为基类，TestClass1为TestClass的派生类。由main主函数入手，定义TestClass1类型的对象d1，参数值为y。 TestClass1类继承TestClass，所以主函数中“TestClass1 d('y')；”语句首先调用“TestClass1(char c){coutc；}”，然后调用基类中的 “TestClass(){cout《'x'；}输出x，最后执行“TestClass(char c){coutc；}”，输出y，即答案为“xy”。
第10题：

若有如下程序:includeusing namespace std;class TestClass{public:void who() {cout

若有如下程序： #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; TcstClass1 obj1; p=&obj1; p-＞who(); return 0; } 则该程序运行后的输出结果是( )。
A．TestClass1
B．TestClass
C．0
D．无输出

正确答案：A
解析：程序中的TestClas1为TestClass的派生类，主函数main中定义TestClass对象*p，TestClass1对象obj1，然后p引用obj1，执行p-＞who()则是调用基类中的who函数，输出TcstClass。
第11题：

若有以下程序:includeusing namespace std;class TestClass{public:void who(){cout<

若有以下程序： #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; 则该程序运行后的输出结果是( )。
A．TestClass1
B．TestClass
C．0
D．无输出

正确答案：B
第12题：

有如下程序:includeusing namespace std;classTestClass{protected:TestClass(){cout

有如下程序： #include＜iostream＞ using namespace std； classTestClass{ 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； } 执行这个程序，屏幕上将显示输出( )。
A．y
B．yx
C．xy
D．yy

正确答案：C
解析：程序中的类TestClass为基类，TestClassl为TestClass的派生类。由main主函数入手，定义TestClassl类型的对象d1，参数值为y。TestClass1类继承TestClass，所以主函数中“TestClass1dl('y');”语句首先调用“TestClass1(charc){coutc;}”然后调用基类中的“TestClass(){cout'x';}”输出x，然后执行“TestClass(charc){coutc；}”输出y，即答案为“xy”。
第13题：

有下列程序:include using namespace std; class TestClass1 { public: TestClass1(){

有下列程序：
include＜iostream＞
using namespace std;
class TestClass1
{
public:
TestClass1(){cout＜＜"A";}
};
class TestClass2＜public:TestClass2(){cout＜＜"B";}
};
class TestClass3:public TestClass1{
TestClass2 b;

正确答案：ABC
ABC 解析：主函数中定义TestClass3对象。obj，其中TestClass3继承于TestClass1，先初始化基类构造函数，所以输出A。然后在TestClass3中定义TestClass2对象b，输出B，最后派生类的构造函数输出C。所答案为ABC。
第14题：

执行这个程序的输出结果是(); include using namespace std; class TestClass1 { publ

执行这个程序的输出结果是( )；
include＜iostream＞
using namespace std;
class TestClass1
{
public:
void fun1(){cout＜＜"TestClass1\n";}
virtual void fun2(){cout＜＜"TestClass1\n";}
};
class TestClass2:public TestClass1
{
public:
void fun1(){cout＜＜"TestClass2\n";}
void fun2(){cout＜＜"TestClass2\n";}
};
void f(TestClass1&b){b.fun1();b.fun2();}
int main()
{
TestClass2 obj;
f(obj);
return 0;
}

正确答案：TestClass1 TcstClass2
TestClass1 TcstClass2 解析：主函数中首先定义TestClass2对象obj，然后执行“f(obj);”。“void f(TestClass1& b){b.fun1();b.fun2();}”语句中fun中参数为TestClass1类型的对象b，其中调用fun1()和fun2()。基类 TestClass1中的fun2()为虚函数，所以派生类中的fun2也是虚函数，所以输出为调用TestClass1中的fun1，TestClass2中的fun2。即结果为TestClass1和TestClass2。
第15题：

有如下程序:includeusing namespace std;class TestClass{private;char c;public;Tes

有如下程序： #include＜iostream＞ using namespace std; class TestClass { private; char c; public; TestClass (char n):c(n){} ～TestClass () { cout＜＜c; } }; class TestClass1:public TestClass { Private: char c; public: TestClass1(char n):TestClass (n+1),c(n){} ～TestClass1() { cout＜＜c; } }; int main() { TestClass1 obj('x'); return 0; } 执行上面的程序输出( )。
A．xy
B．yx
C．x
D．y

正确答案：A
解析：题目中程序TestClass为基类，TestClass1为派生类。在主函数中定义TestClass1对象obj('x')，“TestClass1(charn):TestClass(n+1),c(n){}”，所以先输出x，然后调用基类构造函数，'x'+1='y'，所以输出y，即答案为xy。
第16题：

下列程序中横线处正确的语句是()。includeusing namespace std;class TestClass{publi

下列程序中横线处正确的语句是( )。 #include＜iostream＞ using namespace std; class TestClass { public: void fun(){cout＜＜"TestClass::fun"＜＜end1;} }; class TestClass1:public TestClass { void fun() { ______//显示调用基类的函数 fun() cout＜＜"TestClass1::fun"＜＜end1; } }；
A．fun();
B．TestClass.fun()
C．TestClass::fun()；
D．TestClass-＞fun()；

正确答案：C
第17题：

有如下程序:includeincludeusing namespace std;class TestClass{public;T

有如下程序: #include＜iostream＞ #include＜iomanip＞ using namespace std; class TestClass{ public; TestClass (){cout＜＜'A';} TestClass(char C){cout＜＜c;) ～TestClass (){cout＜＜'B';} }; int main(){ TestClass p1,*p2; p2=new TestClass('X'); delete p2; return 0; } 执行这个程序的结果是( )。
A．ABX
B．ABXB
C．AXBB
D．AXB

正确答案：C
解析：在定义对象p1时由系统自动调用构造函数TestClass()，输出字母A；用new创建单个对象TestClass('X')时，要根据参数调用相应的构造函数TestClass(char C)，输出字母X；在执行delete时，系统会自动调用析构函数～TestClass()，输出字母B，当对象的生存周期即将结束时系统会自动调用析构函数～TestClass()，输出字母B。
第18题：

有如下程序:includeusing namespace std;class TestClass{public:virtual void fun1(

有如下程序： #include＜iostream＞ using namespace std; class TestClass { public: virtual void fun1() { cout＜＜"fun1TestClass"; } virtual void fun2() { cout＜＜"fun2TestClass"; } }; class TestClass1:public TestClass { void fun() { cout＜＜"fun1TestClass1"; } void fun2(int x) { cout＜＜"fun2TestClass1"; } }; int main() { TestClass obj1,*p; TestClass1 obj2; p=&obj2; p-＞fun1(); p-＞fun2(); return 0; } 该程序执行后的输出结果是( )。
A．fun1TestClass1 fun2TestClass
B．fun1TestClass1 fun2TestClass1
C．fun1TestClass fun2TestClass
D．fun1TestClass fun2TestClass1

正确答案：A
解析：TestClass为基类，Testclass1是TestClass的派生类。基类中的fun1和fun2被定义为虚函数，C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数，所以派生类中的fun1和tim2也是虚函数。本题从main主函数入手，首先定义了TestClass类型的对象obj1和指针p，然后又定义了TestClass1的对象obi2。指针指向对象obi2，然后调用其成员函数fun1()，即输出“fun1TcstClass1”。多态性是在程序运行过程中才动态地确定操作指针指向的对象，“p-＞fun2();”语句中没有任何参数，并不是调用派生类中的fun2(intx)，而是调用其基类中的fun2()，所以输出“fun2TestClass”。
第19题：

有如下程序： #include(iostream) using namespace std； class TestClass{ protected： TestClass(){couti(cout＜＜‘x’;} TestClass(char c){cout＜＜c；}}; class TestClassl：publicTestClass{ public： TestClassl(char c){cout＜＜c；}}； int main(){ Te
A．y
B．yx
C．xy
D．yy

正确答案：C
解析：本题中类TestClass为基类，TestClass1为TestClass的派生类。由main主函数入手，定义TestClassl类型的对象dl，参数值为y。TestClassl类继承TestClass，所以主函数中“TestClassldl(‘y’)；”语句首先调用“TestClass1 (char c){coutc；}”然后调用基类中的“TestClass(){cout‘x’；}”输出x，然后执行“TestClass(charc){eoutc;}”输出y，即答案为“xy”。
第20题：

有下列程序:includeusing namespace std;class TestClass{private:int x,y;public:Te

有下列程序： #include＜iostream＞ using namespace std; class TestClass { private: int x,y; public: TestClass (int i,int j) { x=i； y=j; } void print() { cout＜＜"printl"＜＜endl； } vo
A．print1
B．print2
C．pfint1 print2
D．程序编译时出错

正确答案：B
解析：由主函数main入手，定义TestClass型的常对象a，然后调用对象a中的成员函数print()。因为在C++中，如果一个对象被声明为常对象，则不能调用该对象中的非const型的成员函数。所以，这里调用的是对象中的const型成员函数“void print ()const”，输出为print2。
第21题：

有下列程序:includeusing namespace std;class TestClass{int a;public:TestClass(in

有下列程序： #include＜iostream＞ using namespace std; class TestClass { int a; public: TestClass(int x)＜a=x;} void show(){cout＜＜a;} }; class TestClass1：publicTestClass { int b; public: TestCla
A．5
B．1
C．0
D．2

正确答案：D
解析： TestClass为TestClass1的基类，在主函数main中定义TestClass对象b,*p。TestClass1对象d,p指向d,调用其show函数。“TestClass1(int i)：TestClass(i+1)，b(i){}”语句中的TestClass类参数为2，所以show输出2。
第22题：

有如下程序:includeusing namespace std;class TestClass{protected:TestClass(){co

有如下程序： #include＜iost earn＞ 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; } 执行这个程序，屏幕上将显示输出( )。
A．y
B．yx
C．xy
D．yy

正确答案：C
解析：程序中的类TestClass为基类，TestClass1为TestClass的派生类。由main主函数入手，定义TestClass1类型的对象d1，参数值为'y'。TestClass1类继承TestClass，所以主函数中“TestClass1 d1('y');”语句首先调用调用基类中的“TestClass(){cout'x';)”输出x，然后调用“TestClass1(char C) {coutc;}”输出y，即答案为“xy”。
第23题：

有如下程序: include using namespace std; class TestClass { int a

有如下程序： #include＜iostream＞ using namespace std； class TestClass { int a； public： TestClass(int x){a=x;} void show(){cout＜＜a;} }； class TestClass1:public TestClass { int b； public： TestClass1(int i):TestClass(i+1),b(i){} void show(){cout＜＜b;} }； int main() { TestClass b(5),*p； TestClass1 d(1)； p=&d； p-＞show()； return 0； } 该程序运行后的打印结果是( )。
A．5
B．1
C．0
D．2

正确答案：D
解析：TestClass为TestClass1的基类，在主函数main中定义TestClass对象b，*p。TestClass1对象d，P指向d，调用其show函数。“TestClass1(inti):TestClass(i+1)，b(i){}”语句中的TestClass基类参数为2，所以show输出2。

itgle.com

题目

相似考题

更多“若有如下程序:includeusing namespace std;class TestClass{public:void who(){cout 若有如下程序： #include＜iostream＞ using namespace std； class TestClass { public： void who(){cout＜＜“TestClass”＜＜endl；} }； class”相关问题

相关内容