有以下程序： #include 〈iostream〉 using namespace std; class A { public: virtual void setx(int i,int j=0) { x=i; y=j; } virtual void print()=0; protected: int x,y; }; class B : public A { public: void print() { cout〈〈x*x〈〈", "; } }; class C : public A { public:
题目
有以下程序： #include 〈iostream〉 using namespace std; class A { public: virtual void setx(int i,int j=0) { x=i; y=j; } virtual void print()=0; protected: int x,y; }; class B : public A { public: void print() { cout〈〈x*x〈〈", "; } }; class C : public A { public: void print() { cout〈〈x*x*x〈〈end1; } }; int main() { A *pa; B b; C c; pa=&b; pa->setx(5); pa->print (); pa=&c; pa->setx(2); pa->print(); return 0; } 程序运行后的输出结果是( )。
A．25，8
B．2，5
C．5，2
D．8，25
相似考题
更多“有以下程序:#include 〈iostream〉using namespace std;class A{public: virtual void setx(int i, ”相关问题
-
第1题：
程序的输出结果是【 】。 includeusing namespace std; class A{ int x; public: A(int 程序的输出结果是【 】。
include ＜iostream＞
using namespace std；
class A{
int x；
public：
A(int x=1)：x(x){cout＜＜x；}
}；
void main(){
A a，b(2)，c(3)；
}
正确答案：123
123 解析：a对象使用和默认的构造函数，b对象使用2来初始化对象c对象使用3来初始化对象，输出相应的值后，结果变为123。 -
第2题：
程序的输出结果是【 】。 includeusing namespace std; class A{ public: A(){a=b=2;} 程序的输出结果是【 】。
include ＜iostream＞
using namespace std；
class A{
public：
A(){a=b=2；}
A(int i，int j){a=i；b=j；}
void display(){cout＜＜a＜＜b；}
private：
int a，b；
}；
void main(){
A m，n(4，8)；
m．display()；
n．display()；
}
正确答案：2248
2248 解析：m对象使用和默认的构造函数，其a与b变量的值均为2；而n变量使用4和8来初始化程序的变量，a，b的值为4和8，依次输出的结果为2248。 -
第3题：
有以下程序:includeusing namespace std; class Base { public: Base() { K=0; } int 有以下程序：
include＜iostream＞
using namespace std；
class Base
{
public：
Base()
{
K＝0；
}
int x；
}；
class Derivedl：virtual public Base
{
public：
Derivedl()
{
x＝10；
}
}；
class Derived2：virtua1 public Base
正确答案：20。
20。 解析： 本题中，虽然Derived1和Derived2由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1中修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obi；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x＝20。最后输出x的值为20。 -
第4题：
若有以下程序:includeusing namespace std;class A{private:int x;public:int z;voi 若有以下程序：#include ＜iostream＞using namespace std;class A{private: int x;public: int z; void setx(int i) { x=i; } int getx() { return x; }};class B: public A{private: int m;public: int p; void setvalue(int a, int b, int c) { setx(a); z=b; m=c; } void display() { cout＜＜getx()＜＜","＜＜z＜＜","＜＜m＜＜end1; }};int main(){ B obj; obj.setvalue(2,3,4); obj.display(); return 0;程序运行以后的输出结果是( )
A．产生语法错误
B．2，3，4
C．2，2，2
D．4，3，2
正确答案：B
-
第5题：
有以下程序:includeusing namespace std;int s=0;class sample{ static int n;publi 有以下程序: #include ＜iostream＞ using namespace std; int s=0; class sample { static int n; public: sample (int i) { n=i; } static void add() { s+=n; } }; int sample::n=0;
A．2
B．5
C．7
D．3
正确答案：B
解析：程序中定义对象a(2)时，通过构造函数使静态数据成员n=2，在定义对象 b(5)时，通过构造函数使静态数据成员n=5(覆盖了前面n=2)，再执行“sample：：add()；”使全局变量s=5。注意：本题程序中尽管代码中静态数据成员n的初始化语句“int sample：：n=0；”没有意义(因为各对象中的n值由变量i赋给)，但不能省略，否则会出现编译错误。 -
第6题：
有下列程序:includeusing namespace std;class ONE{ public:virtual void f(){COUt<<" 有下列程序：
include＜iostream＞
using namespace std;
class ONE
{
public:
virtual void f(){COUt＜＜"1";}
};
c1assTWO:public ONE
{
public:
TWO(){cout＜＜"2";}
};
class THREE:public TWO
{
pub
正确答案：2213
2213 解析： 此题考查的是派生类的构造和析构函数。建立TWO的对象bb时，调用TWO的构造函数，输出“2”；THREE类又派生于TWO类，所以建立THREE类的对象cc时又会输出“2”；ONE类的对象指针p指向了THREE类的ONE类的虚函数f()，输出“1”；最后调用THREE类的f()，输出“3”。故最终的输出结果是2213。 -
第7题：
有如下程序:includeusing namespace std;int s=0;class sample { static int n;publ 有如下程序： #include ＜iostream＞ using namespace std; int s=0; class sample { static int n; public: sample(int i) { n=i; } static void add() { s+=n; } };
A．2
B．5
C．7
D．3
正确答案：B
解析：本题考核静态数据成员和静态成员函数的应用。程序中定义一个类sample，它包括一个静态数据成员n和一个静态成员函数add，并在类的构造函数中给类私有静态数据成员n赋值。在主函数main中，定义对象a(2)时，通过构造函数使静态数据成员n的值变为2，在定义对象b(5)时，通过构造函数使静态数据成员n=5(覆盖了前面的n=2)，再执行sample::add()使全局变量s=5。 -
第8题：
有以下程序:includeusing namespace std;class A{public: virtual void show() {cout 有以下程序：
include ＜iostream＞
using namespace std;
class A
{
public:
virtual void show()
{
cout＜＜"A";
}
};
class B : public A
{
public:
void show()
{
cout ＜＜ "B";
}
};
void display( A * obj )
{
obj-＞ show();
}
int main ( )
{
A demol;
B demo2;
display( & demol );
display( & demo2 );
return 0;
}
执行后的输出结果为【 】。
正确答案：AB
AB 解析：本题考核赋值兼容原则以及派生与继承的应用。题中函数display()形参类型为类A，执行语句“display(&demo1)；”则输出A。执行语句“display(&dem02)；”时，由于show()函数为虚函数，所以调用类B中show()函数，输出B。所以最后结果为AB。 -
第9题：
有以下程序:includeusing namespace std;class sample{private: int x;public: void 有以下程序： #include ＜iostream＞ using namespace std; class sample { private: int x; public: void setx(int i) { x=i; } int putx () { return x; } }; int main ( ) { sample *p; sample A[3]; A[0] .setx(5); A[1] .setx (6); A[2] .setx(7); for (int j=0;j＜3;j++) { p=&A[j]; cout＜＜p-＞putx () ＜＜", "; } cout＜＜end1; return 0; } 执行后执行结果是( )。
A．5,6,7,
B．5,5,5,
C．6,6,6,
D．7,7,7,
正确答案：A
解析：对象数组是指数组元素为对象的元素，该数组中的每一个元素都是同一个类的对象。程序中，定义了类sample的对象数组A，并调用各个对象的成员函数给其私有数据成员赋值。然后通过for循环将其值输出。 -
第10题：
若有以下程序:includeusing namespace std;class A{private:int a;public:A(int i){a 若有以下程序： #include＜iostream＞ using namespace std； class A {private： int a； public： A(int i) {a=i;} void disp() {cout＜＜a＜＜“，”；}}； class B {private： int b； public： B(int j {b＝j；} void disp() {cout＜＜b＜＜
A．10，10，10
B．10，12，14
C．8，10，12
D．8，12，10
正确答案：D
解析： 本题考查派生类构造函数的使用。派生类C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。 -
第11题：
若有以下程序:includeusing namespace std;class Base{private: int x;protected: i 若有以下程序： #include ＜iostream＞ using namespace std; class Base { private: int x; protected: int y; public: int z; void setx(int i) { x=i; int getx () { return x; } }
A．1,2,3,4
B．产生语法错误
C．4,3,2,1
D．2,3,4,5
正确答案：A
解析：本题考核私有继承中类成员的访问权限。当类的继承方式为私有继承时，基类公有成员和保护成员都以私有成员属性出现在派生类中。私有派生类的成员对其基类成员的访问权和公共派生的方式相同，但是，由私有派生的类声明的对象，不能访问任何基类的成员。本题中，基类Base中的保护成员y和公有成员setx和getx，经过私有继承以后，称为派生类Inherit的私有成员，所以可以在派生类Inherit的函数成员中对它们进行访问。类Inherit中的函数成员setvalue和display都是公有成员，所以可以通过Inherit的对象对它们进行访问。本程序的功能是对类中各数据成员进行赋值，然后查看赋值是否正确。 -
第12题：
若有以下程序:includeusing namespace std;class A{private: int a;public: A(int 若有以下程序： #include ＜iost ream＞ using namespace std; class A { private: int a; public: A(int i) { a=i; } void disp () { cout＜＜a＜＜", "; } }; class B { private:
A．10,10,10
B．10,12,14
C．8,10,12
D．8,12,10
正确答案：D
解析：本题考核派生类构造函数的使用。本题中，派生C具有多重继承关系，所以在派生类C的构造函数中应该包含基类A和B的成员初始化列表。而且派生类C中的成员函数disp分别调用了基类A、B的公有成员函数disp()用于输出基类中私有数据变量初始化后的值。所以由类C构造函数的初始化形式可知，程序最后输出为8，12，10，即D选项。 -
第13题：
以下程序的执行结果为______。includeusing 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 -
第14题：
有以下程序:includeusing namespace std;class Base{public: Base(){} virtual void 有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base(){} virtual void f1() { cout＜＜"f1 of base"＜＜end1; } ～Base(){} }; class Derive: public Base { public: void fl(int x) { cout＜＜"f1 of derive"＜＜end1; } }; int main ( ) { Base *p; Derive obj1; p=&obj 1; p-＞f1 ( ); return 0; }
A．编译时出错
B．f1 of derive
C．f1 of base
D．以上答案都不对
正确答案：B
解析：本程序中，将基类的成员函数n()定义为虚函数，而函数f1()在派生类中被重新定义，重定义的函数仍然是一个虚函数。在C++中，一个基类指针(或引用)可以指向它的派生类对象，而且通过这样的指针或引用调用虚函数时，被调用的是该指针(或引用)实际所指向的对象类的那个重定义版本。 -
第15题：
有以下程序 includeusing namespace std; class Base { int a; public: Base(int x) 有以下程序
include ＜iostream＞
using namespace std;
class Base
{
int a;
public:
Base(int x){ a=x; }
void show(){ cout＜＜a; }
class Derived : public Base
{
int b;
public:
Derived(int i) :Base(i+1),b(i){}
void show() { cout＜＜b;
};
int main ()
{
Base b(5),*pb;
Derived d(1);
pb=&d;
pb-＞show ();
return 0;
}
运行后的打印结果是______。
正确答案：2
2 解析：本题考核基类指针与派生类指针的使用。本例程序中类Derived是从基类Base公有继承来的。main()中定义了基类对象b和一个基类指针pb，又定义了派生类Derived的对象d。由于Derived是Base的子类型，因此可以将派生类Derived的对象d的地址赋值给指向基类Base的指针pb，但这时指针pb只能使用从基类Base继承的成员。所以通过对象指针Pb调用的show函数是基类的成员函数show()，从而输出基类私有数据成员a的值2。 -
第16题：
下面程序执行的结果是【 】 includeusing namespace std; class A{ public: static in 下面程序执行的结果是【 】
include＜iostream＞
using namespace std；
class A{
public：
static int x；
A(inty){cout＜＜x+y；}
}；
int A：：x=2；
void main(){
A a(5)；
}
正确答案：7
7 解析：程序的静态变量初始化为2，而构造函数招待过程中y变量为初始化为5，故程序执行的结果为7。 -
第17题：
有如下程序:includeusing namespace std;class AA{public: virtual void f() {cout< 有如下程序: #include ＜iostream＞ using namespace std; class AA { public: virtual void f() { cout＜＜ "AA"; } }; class BB : public AA { public: BB() { cout ＜＜ "BB"; } }; cla
A．AA
B．AABBCC
C．BBAABBCC
D．BBBBAACC
正确答案：D
解析：本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。最后执行语句“p=&cc； p-＞f()；”，输出AA和CC。 -
第18题：
若有以下程序:includeusing namespace std;class A{private: int x;protected: int 若有以下程序： #include ＜iostream＞ using namespace std; class A { private: int x; protected: int y; public: int z; void setx(int i) { x=i; } int getx () { return x; }; class B : protected A { public: void setvalue(int a, int b, int c) { setx (a); y=b; z=c; } void display() { cout＜＜getx ( ) ＜＜", "＜＜y＜＜", "＜＜z＜＜", "＜＜end1; } }; int main () { B obj; obj.setvalue(5, 6, 7); obj.display ( ); return 0; } 程序运行后的输出结果是( )。
A．产生语法错误
B．7,6,5
C．5,6,7
D．7,5,6
正确答案：C
解析：本题考核保护继承中对类成员的访问权限。①在保护继承中，基类公有成员和保护成员都以保护成员身份出现在派生类中，而基类私有成员不可访问。②基类的公有成员和保护成员被继承以后作为派生类的保护成员，这样，派生类的其他成员可以直接访问它们。③由保护派．生的类声明的对象，不能访问任何基类的成员。在本题中，基类A中的数据成员y和函数setx，经过保护继承以后，在派生类B中成为保护成员，派生类B的对象不能访问它们。而派生类B中的函数setvalue和display都是公有成员，可以通过对象对它们进行访问。所以程序中对各成员的访问是正确的。本程序的功能是对类中各数据成员进行赋值，然后查看赋值是否正确。 -
第19题：
下面程序输出的结果是【 】。 includeusing namespace std; class A { public:virtual 下面程序输出的结果是【 】。
include ＜iostream＞
using namespace std;
class A {
public:
virtual void show() {cout＜＜"A!";
};
class B: public A {
public:
void show() {cout ＜＜ "B!";}
};
class C: public B{
public:
void show(){cout ＜＜ "C!";}
};
void show_info(A &i) {i. show();}
void main() {
A ia; B ib; C ic; show_info(ia);show_info(ib); show_info(ic); }
正确答案：A! A! A!
A! A! A! 解析：由于基类中没有声明虚函数，故调用的全部是基类的函数。 -
第20题：
有如下程序: inCludeusing namespace std; class AA { public: viltual void f() { c 有如下程序：
inClude＜iostream＞
using namespace std；
class AA
{
public：
viltual void f()
{
cout＜＜"AA"；
}
}；
class BB：public AA
{
public：
BB()
{
cout＜＜"BB"；
}
}；
class CC：public BB
{
public：
virtual void f()
{
BB::f()；
cout＜＜"CC"；
}
}；
int main()
{
AA aa,*p；BB bb；CC cc；
p=&cc；
p-＞f()；
return 0；
}
运行后的输出结果【 】。
正确答案：BBBBAACC
BBBBAACC 解析：本题考核虚函数。本题中，函数f()在基类AA中派生类CC中都声明为虚函数，所以采用动态联编。主函数首先定义类AA的对象aa和指针对象p，然后定义了类BB的对象bb，此时调用了类BB的构造函数输出BB。再定义类CC的对象cc，由于类CC是类BB的派生类，所以此时又调用类BB的构造函数输出BB。最后执行语句“p=&cc；p-＞f()；”，输出AA和CC。 -
第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：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。 -
第22题：
有下列程序: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。 -
第23题：
若有以下程序:includeusing namespace std;class A{private:int x;public:int z;void 若有以下程序：#include＜iostream＞using namespace std；class A {private: int x;public: int z; void setx(int i) { x=i; } int getx () { return x; }}:class B : public A{private: int m;public: int p; void setvalue(int a, int b, int c) { setx(a) ; z=b; m=c; } void display{) { cout＜＜getx ()＜＜", "＜＜z＜＜", "＜＜m＜＜end1; }};int main(){ B obj; obj. setvalue(2,3,4); obj.display(); return 0;} 程序运行以后的输出结果是
A．产生语法错误
B．2,3,4
C．2,2,2
D．4,3,2
正确答案：B
解析：本题考核继承与派生。当类的继承方式为公有继承时，基类的公有成员和保护成员分别作为派生类的公有成员和保护成员，派生类的其他成员可以直接访问它们。其他外部使用者只能通过派生类的对象访问继承来的公有成员。在本题中，数据成员z和函数setx都是基类A的公有成员，它们经过公有继承以后，在派生类B中还是公有成员，而派生类B中的函数setvalue和display都是公有成员，可以通过对象对它们进行访问。所以程序中对各成员的访问是正确的。本程序的功能是输出已设置的各成员的值。