计算机二级
有如下程序:includeusing namespaee std;class VAC{public:int f( )COUSt{return 3;}有如下程序： #include＜iostream＞ using namespaee std； class VAC{ public： int f( )COUSt{return 3；} int f( ){return 5；} }； int main( ){ VAC vl； const VAC v2； eout＜＜v1.f( )＜＜v2.f( )； return 0
题目
有如下程序： #include＜iostream＞ using namespaee std； class VAC{ public： int f( )COUSt{return 3；} int f( ){return 5；} }； int main( ){ VAC vl； const VAC v2； eout＜＜v1.f( )＜＜v2.f( )； return 0； } 程序的输出结果是
A．53
B．35
C．55
D．33
参考答案和解析
相似问题和答案
第1题：
有如下程序：
include＜iostream＞
using namespace std;
class A
{
public:
virtual void f(){cout＜＜"1";}
};
class B:public A
{
public:
B (){cout＜＜"2";}
};
class C:public B
{
public:
virtual void f(){B::f();cout＜＜"3";}
};
int main()
{
A aa,*p;
B bb;
C cc;
p=&cc;
p-＞f();
return 0;
}
执行上面程序的输出是______。
2213 解析：B bb将定义一个B型对象bb，这时需调用B的构造函数，在该构造函数中，将输出"2:；C cc将定义一个C型对象cc，这时需调用C的构造函数，面该函数为缺省构造函数，其将调用父类B的构造函数，在该构造函数中，将输出"2"：由于p采用指针方式调用成员函数f，而f在基类中被声明为虚拟函数，故函数f的执行与指针p所指向对象的实际类型相一致，p指向一个C型对象cc，故执行p-＞f()时，将执行C的f函数，在该函数中，首先直接调用了父类B的函数f，而在B中直接继承了A类的f函数，故先要执行A的f函数，输出“1”，然后再输出“3”。
第2题：
有如下程序： #include＜iostream＞ using namespace std； class GA{ public： virtual int f( ){return 1；} }； class GB：public GA{ public： virtual int f( ){return 2；} }； void show(GA g){eout＜＜g.f( )；} void display(GA＆g){cout＜＜g.f( )；} int main( ){ GA a；show(A) ；display(A) ； GB b；show(B) ；display(B) ； return 0； } 程序的输出结果是
A．1111
B．1211
C．1112
D．1212
解析：基类对象作为实参进行传递时，无论使用的是对象还是对象引用作为形参，都只能在该函数中调用基类成员函数，因此当GA a作为实参时，调用的只能是GA的成员函数。而当派生类对象作为实参传递时，函数的形参则要分情况而定：如果是普通的对象传递，则是值传递，那么在函数中也只能调用基类的成员函数；如果是对象引用作为形参，则是地址传递，这个时候函数就可以调用重载后的虚成员函数。
第3题：
有如下程序：
include ＜iostream＞
using namespaee std；
class ONE{
public：
virtual void f( ){cout＜＜"1"；}
}；
class TWO：public ONE{
public：
TWO( )1 cout＜＜"2"；}
{；
class THREE：public TWO{
public：
virtual void f( )}TWO::f( )；cout＜＜"3"；}
}；
int main( ){
ONE aa，*P；
TWO bb；
THREE cc；
P=&cc；
p-＞f( )；
return 0；
}
程序的输出结果是______。
2213 解析：TWO bb；调用TWO的构造函数打印2；THREE cc；调用继承类TWO的构造函数打印2；p-＞f( )；调用类TREE的函数f( )，先显式调用TWO类的函数f( )，TWO中没有重新定义f( )函数，所以调用TWO的基类ONE的虚函数f( )；打印1，然后再打印3，故答案为2213。
第4题：
有如下程序： #include＜iostream＞ using namespace std; class TlestClass { int n; public: TestClass(int k):n(k){} int get(){return n;} int get()const{return n+1;} }; int main() { TestClass p(5); colast TestClass q(6); cout＜＜p.get()＜＜q.get(); return 0; } 执行后的输出结果是( )。
A．55
B．57
C．75
D．77
解析：C++中对常对象的成员函数调用，将自动调用其常成员函数，程序中调用原型为"intget()const;"的函数，对于非常对象将调用原型为"int get();"的函数。因为首先用5对对象p进行了初始化，所以执行p.get()时直接返回5，而对于常对象则以6对q进行初始化，在调用q.get()时，将调用原型为"int get()const;"的函数．该函数将返回n+1，第二个输出应为7，所以本题答案为57。
第5题：
有如下程序： #include＜iostream＞ using namespace std; class A{ public: static int a; void init(){a=1;} A(int a=2){init(); a++;} }; int A::a=0; A obj; int main() { cout＜＜obj.a; return 0; 运行时输出的结果是( )。
A．0
B．1
C．2
D．3
解析：有如下程序： #includeiostream＞ using namespace std; class A{ public: static int a; void init(){a=1;} A(int a=2){init(); a++;} }; int A::a=0; A obj; int main() { coutobj.a; return 0; 运行时输出的结果是( )。
第6题：
有如下程序： #include＜iostream＞ using namespace std； class Base{ int x； public： Base(int n=0):x(n){cout＜＜n；} int getX( )const{return x；} }； class Derived：public Base{ int y； public： Derived(int m，int n)：y(m)，Base(n){tout＜＜m；} Derived(int m):y(m){cout＜＜m；} }； int main( ){ Derived dl(3)，d2(5，7)； return 0； } 程序的输出结果是
A．375
B．357
C．0375
D．0357
解析：有如下程序： #includeiostream＞ using namespace std； class Base{ int x； public： Base(int n=0):x(n){coutn；} int getX( )const{return x；} }； class Derived：public Base{ int y； public： Derived(int m，int n)：y(m)，Base(n){toutm；} Derived(int m):y(m){coutm；} }； int main( ){ Derived dl(3)，d2(5，7)； return 0； } 程序的输出结果是
第7题：
有如下程序： #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()const { cout＜＜k+3; }; class YY:public XX { public: ～YY() { cout＜＜”YY”; } void f()const { cout＜＜k-3; XX::f(); } }; int main() { XX &p=*new YY; P.f(); delete &p; return 0: } 执行上面的程序将输出( )。
A．28XX
B．28YYXX
C．33XX
D．33XXYY
解析：类YY公有派生于类XX，派生类对象可以替代基类对象向基类埘象的引用进行赋值初始化，XX&p=*new YY语句定义了XX对象p引用，并用YY对象初始化，p并不是YY对象的别名，是XX基类对象的别名，故先调用基类XX的构造函数将k初始化为5，p.f()首先输出k-3即2，然后调用XX::f()输出k+3，即8，delete &p删除p，调用XX的析构函数输出“XX”。
第8题：
有如下程序：
include＜iostream＞
using namespaee std；c lass Animal{
public：
virtual char*getType( )const{return"Animal"；}
virtual char*getVoice( )const{return"Voice"；}
}；
class Dog：public Animal{
public：
char*getType( )const{return"Dog"；}
char*getVoice( )eonst{return"Woof"；}
}；
void type(Animal&A) {cout＜＜a．getType( )；}
void speak(Animal A) {eout＜＜a．getVoice( )；}
int main( ){
Dog d；type(D) ；cout＜＜"speak"；speak(D) ；cout< return 0；
}
程序的输出结果是______。
Dog SpeakVoice 解析：派生类继承基类，并重新定义了基类的虚函数。void type(Animal＆A) 是对象引用作为函数参数，传递的是地址，是“地址调用”，故a．getType( )调用的是派生类重新定义后的get—Type( )成员函数。void speak(Animal A) 是对象作为函数参数，是“传值调用”，在进行函数调用时，将派生类对象赋值给基类对象。但是，对象a只能调用派生类继承自基类的成员。故在a．getVoice( )中调用的是基类的虚函数getVoice( )，打印“Voive”。
第9题：
有如下程序： #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
解析：有如下程序： #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; } 程序的输出结果是( )。
第10题：
如下程序的输出是 #include＜iostream＞ using namespace std； class Base{ public： Base( ){cout＜＜"BB"；f( )；} void f( ){cout＜＜"Bf"；} }； class Derived：public Base{ public： Derived( ){eout＜＜"DD"；} void f( ){cout＜＜"Df"；} }； int main( ){Derived d；return 0；}
A．BBBff)D
B．BBDfDDDf
C．DD
D．DDBBBf
解析：当创建派生类对象时，首先调用基类的构造函数，最后调用派生类的构造函数。