有如下程序: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
相似考题
更多“有如下程序: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”相关问题
-
第1题：
有如下程序:includeusing namespace std;class GA{public:virtual int f( ){return 1 有如下程序： #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
正确答案：C
解析：基类对象作为实参进行传递时，无论使用的是对象还是对象引用作为形参，都只能在该函数中调用基类成员函数，因此当GA a作为实参时，调用的只能是GA的成员函数。而当派生类对象作为实参传递时，函数的形参则要分情况而定：如果是普通的对象传递，则是值传递，那么在函数中也只能调用基类的成员函数；如果是对象引用作为形参，则是地址传递，这个时候函数就可以调用重载后的虚成员函数。 -
第2题：
有如下程序:includeusing namespace std;class A{public:static int a;void init(){a 有如下程序： #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
正确答案：B
解析：有如下程序： #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; 运行时输出的结果是( )。 -
第3题：
有如下程序:includeusing namespace std;class TlestClass{int n;public:TestClass(i 有如下程序： #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
正确答案：B
解析：C++中对常对象的成员函数调用，将自动调用其常成员函数，程序中调用原型为"intget()const;"的函数，对于非常对象将调用原型为"int get();"的函数。因为首先用5对对象p进行了初始化，所以执行p.get()时直接返回5，而对于常对象则以6对q进行初始化，在调用q.get()时，将调用原型为"int get()const;"的函数．该函数将返回n+1，第二个输出应为7，所以本题答案为57。 -
第4题：
有如下程序:includeusing namespace std;class Base{public:Base(int x=0){cout< 有如下程序： #include＜iostream＞ using namespace std； class Base{ public： Base(int x=0){cout＜＜x；} }； class Derived：public Base{ public： Derived(int x=0){cout＜＜x；} private： Base val； }； int main( ){ Derived d(1)； return 0； } 程序的输出结果是
A．0
B．1
C．01
D．001
正确答案：D
解析：派生对象在创建时先调用基类的构造函数，然后调用派生类的构造函数；撤销对象时，先调用派生类的构造函数，然后调用基类的构造函数。当类中出现其他类对象时，在初始化时先调用该对象的类的构造函数创建该对象。第5题：
有如下程序:includeusing namespace std;class XX{protected;int k;public:XX(int n= 有如下程序： #include＜iostream＞ using namespace std； class XX{ protected； int k； public： XX(int n=5)：k(n){} ～XX(){cout＜＜"XX"；} Virtual void f()cons=0； }； inline void XX：：f()const{cout＜＜k+3；} class YY:public XX{ public：
A．28XX
B．28YYXX
C．-33XX
D．-33XXYY
正确答案：A
第6题：
有如下程序: includcusing namespace std; class VAC{ public: in 有如下程序： #includc＜iostream＞ using namespace std； class VAC{ public： int f()const{return 3;} int f(){return 5;} }； int main(){ VAC v1； const VAC v2； cout＜＜v1．f()＜＜v2．f()； return 0； } 运行时的输出结果是
A．53
B．35
C．55
D．33
正确答案：A
第7题：
有如下程序:includeusing namespace std;class AA{ int n;public: AA(int k):n (k){} 有如下程序： #include＜iostream＞ using namespace std； class AA{ int n； public： AA(int k)：n (k){} int get(){return n；) int get()const{return n+1；} }； int main() { AA a(5)； const AA b(6)； cout＜＜a．get()＜＜b．get()； return 0； } 执行后的输出结果是
A．55
B．57
C．75
D．77
正确答案：B
解析：本题考核常成员函数和函数的重载。所谓函数重载，是指同一个函数名可以对应着多个函数的实现，类AA中定义了两个get()函数，一个为普通成员函数，另一个为常成员函数。一般对象a既可以调用普通成员函数get，也可以调用常成员函数get，但是由于常成员函数不能更新对象的数据成员，所以题中通过对象a调用的函数为普通成员函数get()，返回值为5。常对象b只能调用常成员函数，所以题中通过对象b调用的函数为常成员函数get()，返回值为7。第8题：
有如下程序:includeusing namespace std;class MyClass{public:MyClass(){＋＋count;}~ 有如下程序： #include＜iostream＞ using namespace std； class MyClass{ public： MyClass(){++count；} ～MyClass(){--count；} static int getCount(){return count；} private： static int count； }； int MyClass：：count=0； int main(){ MyCl
A．121
B．232
C．221
D．122
正确答案：A
解析： 本题考查的知识点是静态成员。类中的静态成员是解决同—：个类的不同对象之间的数据和函数共享问题的。静态成员被所有属于这个类的对象共享。这种共享与全局变量或全局函数相比，既没有破坏数据隐藏的厚则，又保证了安全性。题目中，首先定义了一个obj对象，其构造函数使MyClass的静态数据成员count增1,所以第一条输出语句输出的结果是1。然后通过指针动态创建了一个MyClass类的对象，构造函数再次被调用，count变为2，所以第2次输出结果是2。接下来是用dilete删除了刚才动态创建的MyClass对象。析第9题：
执行如下程序,输出星号(*)的个数为includeusing namespaee std;class Sample{public: 执行如下程序，输出星号(*)的个数为 #include＜iostream＞ using namespaee std； class Sample{ public： Sample( ){ } ～Sample( ){cout＜＜'*'；} }； int main( ){ Sample temp[2]，*pTemp[2]； return 0； }
A．1
B．2
C．3
D．4
正确答案：B
解析：类在创建对象时调用构造函数，在撤销对象时调用析构函数，而在定义类指针时则不调用构造函数和析构函数。sampie temp[2]定义了一个2个元素的对象数组，因此调用两次析构函数，打印2个*。第10题：
有如下程序:includeusing namespaee std;class AA{public:AA( ){cout<<'1';}};class 有如下程序： #include＜iostreanl＞ using namespaee std； class AA{ public： AA( ){cout＜＜'1'；} }； class BB：public AA{ int k； public： BB( )：k(0){eout＜＜'2';} BB(int n)：k(n){cout＜＜'3'；} }； int main( ){ BB，b(4)，c； return 0； } 程序的输出结果是
A．1312
B．132
C．32
D．1412
正确答案：A
解析：创建派生类对象时，先调用基类构造函数，然后调用派生类构造函数，b(4)先调用基类构造函数，然后调用BB的带参数构造函数，打印1和3；c调用基类AA的构造函数，然后调用BB的构造函数，打印1和2。故答案为A。第11题：
有下列程序:includeusing namespace std;class VAC{public: int f() const{return3;} 有下列程序： #include＜iostream＞ using namespace std; class VAC{ public: int f() const{return3;} int f() {return 5;} }; int main(){ VAC v1; const VAC v2; cout＜＜v1.f()＜＜v2.f();
A．53
B．35
C．55
D．33
正确答案：A
解析： 此题考查的是常成员函数的应用。VAC类中说明了两个函数，一个是常成员函数，一个是普通函数；在主函数中说明了两个对象，通过普通对象v1调用的是普通函数，输出5；通过常对象V2调用是常成员函数，输出3。第12题：
有如下程序: includeusing namespace std; class VAC{ public: 有如下程序： #include＜iostream＞ using namespace std； class VAC{ public： int f() const{return 3;} int f() {return 5;} }； int main(){ VAC v1； const VAC v2； cout＜＜v1.f()＜＜v2.f()； return 0； } 运行时的输出结果是( )。
A．53
B．35
C．55
D．33
正确答案：A
解析：此题考查的是常成员函数的应用。VAC类中说明了两个函数，一个是常成员函数，一个是普通函数：在主函数中说明了两个对象，通过普通对象v1调用的是普通函数，输出5：通过常对象v2调用的是常成员函数，输出3。第13题：
有如下程序:includeusing namespace std;class XX{protected:int k;public:XX(int n= 有如下程序： #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
正确答案：A
解析：类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”。第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 Base{public:Base( ){cout<<"BB" 如下程序的输出是 #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
正确答案：A
解析：当创建派生类对象时，首先调用基类的构造函数，最后调用派生类的构造函数。第16题：
有如下程序:includeusing name。pace std;class AA{int n:public:AA(int k):n(k){}in 有如下程序： #include＜iostream＞ using name。pace std； class AA{ int n： public： AA(int k):n(k){} in get( ){return n；} int get( )const{return n+1；} }； int main( ){ AA a(5)； const AA b(6)； cout＜＜a．get( )＜＜b．get( )； return 0： 执行后的输出结果是
A．55
B．57
C．75
D．77
正确答案：B
解析：如果一个对象被定义为常对象，则它只能调用该类的常成员函数而不能调用其他的成员函数。第17题：
有以下程序:includeusing namespace std;definePl 3.14Class Point{private:int x,y 有以下程序： #include＜iostream＞ using namespace std； #definePl 3.14 Class Point {private： int x，y； public： Point(int a，intB) {X＝a； y：b；} int getx() ＜return x；} int gety() {return y；}}； class Circle：public Point {pri
A．314
B．157
C．78.5
D．153.86
正确答案：A
解析： 本程序设计了一个点类Point，包含了横，纵两个坐标数据x和y，由它派生出了圃类Circle，并加入了新的数据成员，即一个半径r和一个求圆面积的函数成员area。在主函数main中，首先定义了一个圃Circle类的对象c1，并通过它的构造函数初始化其数据成员。由此可知，其半径r的值为10，所以其面积为PI*10*10=314，即对象c1的函数成员area的返回值为314。第18题：
有如下程序includeusing namespace std;class GA{public:virtual int f( ) {return 1 有如下程序 #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){cout＜＜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
正确答案：C
第19题：
有如下程序: includeusing namespaee std; class A{ public: A( ){cout<<"A";} 有如下程序：
include＜iostream＞
using namespaee std；
class A{
public：
A( ){cout＜＜"A"；}
～A( ){cout＜＜"A"；}
}；
class B{
A a；
public：
B( ){cout＜＜"B"；}
～B( )t cout＜＜"B"；}
}；
int main( ){
B b；
return 0；
}
程序的输出结果是______。
正确答案：ABBA
ABBA第20题：
有如下程序:includeusing namespace std;class VAC{public;intf()const{return 3;}in 有如下程序： #include＜iostream＞ using namespace std； class VAC{ public； intf()const{return 3；} int f(){return 5；} }； Int main(){ VAC v1； const VAC v2； cout＜＜v1.f()＜＜v2.f()； return 0； } 运行时的输出结果是( )。
A．53
B．35
C．55
D．33
正确答案：A
解析： 本题考查的是常成员函数的应用。VAC类中说明了两个函数，一个是常成员函数，一个是普通函数；在主函数中说明了两个对象，通过普通对象v1调用的是普通函数，输出5；通过常对象V2调用的是常成员函数，输出3。第21题：
有如下程序:includeusing namespaee std;class A{public:A(int i):rl(i){ }void prin 有如下程序： #include＜iostream＞ using namespaee std； class A{ public： A(int i)：rl(i){ } void print( ){cout＜＜'E'＜＜rl＜＜'-'；} void print( )const}cout＜＜'C'＜＜rl*rl＜＜'-';} private： int rl； }； int main( ){ A al(2)；eonst A a2(4)； a1．print( )；a2．print( )； return 0； } 程序的输出结果是
A．运行时出错
B．E2-C16-
C．C4-C16-
D．E2-E4-
正确答案：B
解析：在类中重载函数的情况下，常对象调用类的常成员函数，非常对象调用类的非常成员函数，故答案为B。第22题：
有下列程序:includeUsing namespace std;Class Amount{ int amount;public; Amount(i 有下列程序： #include＜iostream＞ Using namespace std; Class Amount{ int amount; public; Amount(int n=O):amount(n){} Int getAmount()const{return amount;} Amount &operator+=(AmountA) {
A．*this
B．this
C．&amount
D．amount
正确答案：D
解析： 此题考查的是“+”运算符重载和this指针。语句amount+=a.amount；实现3和7的求和，得到amount=10，要使程序的输出结果为10，需要把amount的值作为函数的返回值，所以横线处应填入amot。第23题：
有如下程序： #include<iostream> using namespace std； class VAC{ public： intfconst{return 3；} int f{retum 5；} }； int main { VAC vl； const VAC v2； cout<<vl．f<<v2．f； return 0； } 执行这个程序的输出结果是( )。
A.53
B.35
C.55
D.33
正确答案：A
本题考查常对象及常成员函数及构造函数，常埘象只能凋用常成员函数，所以本题中，对象v1为普通对象，执行v1．f后，会执行默认构造函数，输出5，对象v2为常列象，执行v2．f后，会执行常构造函数，输出3。