niusouti.com
有如下程序:includeusing namespace std;{TestClass(){cout有如下程序： #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";} }; in
题目
有如下程序： #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
相似考题
参考答案和解析
更多“有如下程序:includeusing namespace std;{TestClass(){cout 有如下程序： #include＜iostream＞ using namespace std; { TestClass(){cout＜＜"BB";fun()} void fun(){cout＜＜"Bf";} }; class TestClass1:public TestClass {”相关问题
-
第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题：
执行这个程序的输出结果是(); includeusing 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。 -
第3题：
有如下程序: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。 -
第4题：
有如下程序: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。 -
第5题：
执行如下程序将输出():includeusing namespace std;class Base{public:Base(){cout<< 执行如下程序将输出( ): #include＜iostream＞ using namespace std; class Base { public: Base(){cout＜＜"BB";fun();} void fun (){tout＜＜"Brim";} }; class Derived:public Base { public: Derived(){cout＜＜"DD";} void fun (){cout＜＜"Dfun";} }; int main(){Derived d;return 0;}
A．DD
B．BBDfunDDDfun
C．BBBfunDD
D．DDBBBfun
正确答案：C
解析：C++中创建一个类的实例时，如果该类存在基类，将首先执行基类的构造函数，然后执行该类本身的构造函数。本题中首先执行类Base的构造函数，所以将先输出“BB”，然后调用基类成员函数fun()，输出“Bfun”，最后调用子类Derived的构造函数输出“DD”。 -
第6题：
有如下程序: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”。 -
第7题：
有下列程序:includeusing namespace std;c1ass TestClass{private;char c;public:Tes 有下列程序： #include＜iostream＞ using namespace std; c1ass TestClass { private; char c; public: TestClass(char n):c(n){} ～TeStClass() { cout＜＜c } }; class TestClass1:public TestClass {
A．xy
B．yx
C．x
D．y
正确答案：A
解析： 题目中程序TestClass为基类，TestClass1为派生类。在主函数中定义TestClass1对象obj('x')，“TestClass1(char n)：TestClass(n+1)，c(n){}”，所以先输出x，然后调用基类构造函数，′x′+=′y′，所以输出y，即答案为xy。 -
第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{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。 -
第10题：
有如下程序: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”。 -
第11题：
下列程序的输出结果为2,横线处应添加语句()。includeusing namespace std;{public:___ 下列程序的输出结果为2，横线处应添加语句( )。 #include＜iostream＞ using namespace std; { public: ______void fun(){cout＜＜1;} }; class TestClass2:public TestClass1 { public:void fun(){cout＜＜2;) }; int main() { TestClass1 *p=new TestClass2; p-＞fun(); delete p; Teturn 0; }
A．public
B．private
C．virtual
D．protected
正确答案：C
解析：由主函数main入手，定义TestClass1类的指针对象p指向派生类Testclass2。因为基类和派生类中都有fun函数，题目要求输出为2，就是基类对象访问派生类中fun函数。通过虚函数与指向基类对象的指针变量的配合使用，就能方便调用同名函数。所以这里将基类中的fun函数声明为virtual。并且当一个成员函数被声明为虚函数后，其派生类中的同名函数自动成为虚函数。 -
第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题：
有下列程序:includeusing 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题：
有如下程序: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; } 程序的输出结果是( )。 -
第15题：
下列程序中横线处正确的语句是()。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
-
第16题：
有如下程序:includeusing namespace std;class TestClass1{public:TestClass1 (){cou 有如下程序： #include＜iostream＞ using namespace std; class TestClass1 { public: TestClass1 (){cout＜＜"TestClass1";} ～TestClass1 (){cout＜＜"～TestClass1";} }; class TestClass2:public TestClass1 { TestClass1 *p; public: Testclass2(){cout＜＜"TestClass2";p=new TestClass1();} ～TestClass2(){cout＜＜"～TestClass2";delete p;} ); int main() { TestClass2 obj; return 0; } 执行这个程序的输出结果是( )。
A．TestClass2TestClass1TestClass1～TestClass1～TestClass2～TestClass1
B．TestClass1TestClass2TestClass1～TestClass2～TestClass1～TestClass1
C．TestClass2TestClass1TestClass1～TestClass2～TestClass1～TestClass1
D．TestClass1TestClass2TestClas1～TestClass1～TestClass2～TestClass1
正确答案：B
解析：派生类中构造函数的执行顺序是：先调用基类构造函数，对基类数据成员初始化，然后调用子对象构造函数，对子对象数据成员初始化；最后执行派生类构造函数本身，对派生类数据成员初始化。由主函数main入手，首先定义了一个TestClass2对象obj。其中TestClass2公共继承TestClass1，对象obj可以访问TestClass1中的公有成员函数。TestClass2中定义了一个TestClass1的指针p，给p分配新空间，即指向类TestClass1，输出“TestClass1”。在TestClass2的构造函数中首先输出“TestClass2”，并在TestClass1构造函数中输出“TestClass1”。TestClass2析构函数中输出“～TestClass2”，删除指针p，输出“～TestClass1”。析构TestClass1输出“～TestClass1”。 -
第17题：
有如下程序:includeinclude using 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 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”。 -
第19题：
下列程序的输出结果是( )。 includeusing namespace std; class TestClass 下列程序的输出结果是( )。 #include＜iostream＞ using namespace std； class TestClass{ static int i； public： TestClass(){i++;} ～TestClass(){i--;} static int getVal(){return i;} }； int TestClass::i=O； void fun(){TestClass ob2;cout＜＜ob2.getVal();} int main(){ TestClass ob1； fun()； TestClass*ob3=new TestClass;cout＜＜ob3-＞getVal()； delete ob3;cout＜＜TestClass::getVal()； return 0； }
A．111
B．121
C．211
D．221
正确答案：D
解析：由主函数mian入手，首先定义TestClass对象ob1，调用构造函数后，i等于1。“intTestClass::i=0”语句中i首先赋值为0，它是静态函数可以被所有对象引用，当静态成员变量的值改变后，则在各对象中这个数据成员的值都同时改变。主函数中首先调用fun函数，其中又定义了对象ob2，调用getVal；i等于2，输出。主函数“obj*ob3=newTestClass;coutob3-＞getVal();”动态分配，i等于2，输出。“deleteob3;”析构函数后，i等于1，然后输出1。即221。 -
第20题：
有下列程序: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”。 -
第21题：
若有如下程序: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。 -
第22题：
若有以下程序: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
-
第23题：
有如下程序: includeusing 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。