下面程序的运行结果是( )。 #include<iostream．h> class base{ protected： int a； public： base{cout<<”0”；} }； class basel：virtual base{ public： basel{cout<<”1”；} }； class base2：virtual base i public： base2{cout<<”2”；} }； class derived：public basel，public base2{ public： d
题目
下面程序的运行结果是( )。 #include<iostream．h> class base{ protected： int a； public： base{cout<<”0”；} }； class basel：virtual base{ public： basel{cout<<”1”；} }； class base2：virtual base i public： base2{cout<<”2”；} }； class derived：public basel，public base2{ public： derived{cout<<”3”；} }； void main derived obj； cout<<endl：
A.0123
B.3120
C.0312
D.3012
相似考题
更多“下面程序的运行结果是( )。 #include<iostream.h> class base{ protected: int a; public ”相关问题
-
第1题：
有如下程序: includeusing namespace std; class Base { public: 有如下程序： #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．1
D．1
正确答案：D
解析：本题考查的知识点是：类的构造。建立一个类的对象时，构造函数的执行顺序如下：
①执行基类的构造函数，调用顺序按照各个基类被继承时声明的顺序(自左向右)；
②执行成员对象的构造函数，调用顺序按照各个成员对象在类中声明的顺序(自上而下)：(如果一行声明了多个对象，则还要遵循自左向右)
③执行自身的构造函数。
本题Derived类继承于Base类，所以首先会构造基类Base，但Derived类的构造函数没有初始化列表，所以将调用Base类的默认构造函数，输出一个0。接下来由于它的成员中还定义了一个Base类的对象，而构造函数也没有显示初始化这个对象，所以再次调用Base类的默认构造函数输出一个0。最后构造自身，因为主函数中传入了构造参数1，所以构造自身时输出了一个1。故最终输出结果为001，应该选择 D。 -
第2题：
下面程序的运行结果是()。includeclass base{protected:int a;public:base(){cout<< 下面程序的运行结果是( )。 #include＜iostream.h＞ class base{ protected： int a； public： base(){cout＜＜“0”；} }； Class basel：Virtual base{ public： basel(){cout＜＜“1”；} }； Class base2：virtual base{ public： base2(){cout＜＜“2”；)
A．0123
B．3120
C．0312
D．3012
正确答案：A
解析： 本题考查的是含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最后调用派生类自己的构造函数。 -
第3题：
有如下程序: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
解析：派生对象在创建时先调用基类的构造函数，然后调用派生类的构造函数；撤销对象时，先调用派生类的构造函数，然后调用基类的构造函数。当类中出现其他类对象时，在初始化时先调用该对象的类的构造函数创建该对象。第4题：
有如下程序:includeusing namespace std;class BASE{public:~BASE( ){cout<<"BASE";} 有如下程序： #include＜iostream＞ using namespace std； class BASE{ public： ～BASE( ){cout＜＜"BASE"；} }； class DERIVED：public BASE{ public： ～DERIVED( ){cout＜＜"DERIVED"；} }； int main( ){DERIVED x；return 0；} 程序的输出结果是
A．BASE
B．DERIVED
C．BASEDERIVED
D．DERIVEDBASE
正确答案：D
解析：基类和派生类的析构函数的执行顺序是先执行派生类的析构函数，最后执行基类的析构函数；故先执行DIVERED的析构函数，后执行BASE的析构函数。第5题：
下面程序的输出结果是【】。includeusing namespace std; class base { protected: int 下面程序的输出结果是【 】。
include ＜iostream＞
using namespace std;
class base
{
protected:
int a;
public:
base(){cout＜＜"0":}
};
class basel: virtual public base
{
public:
base1(){ cout＜＜"1";}
};
class base2 : virtual public base
{
public:
base2(){cout＜＜"2";}
};
class derived : public base1,public base2
{
public:
derived () {cout＜＜"3"; }
}
int main ()
{
derived obj;
cout＜＜end1;
return 0;
}
正确答案：0123
0123 解析：本题考核含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最有调用派生类自己的构造函数．题中先调用base的构造函数，然后调用base1、base2的构造函数，最后调用derived的构造函数。第6题：
下面程序的运行结果是includeclass base{protected:int a;public:base( ){cout<<"0 下面程序的运行结果是 #include＜iostream.h＞ class base{ protected： int a； public： base( ){cout＜＜"0"；} }； class basel：virtual base { public： base1( ){cout＜＜"1"；} }； class base2：virtual base{ public：
A．123
B．3120
C．312
D．3012
正确答案：A
解析：本题考查的是含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最后调用派生类自己的构造函数。第7题：
若有以下程序:includeusing namespace std; class Base public: Base() { x=0;} in 若有以下程序： #include ＜iostream＞ using namespace std; class Base public: Base() { x=0; } int x; }; class Derivedl: virtual public Base public: Derived1() { x=10; } }; class Derived2: virtual public Base publici Derived2() x=20; }; class Derived :public Derived1,protected Derived2 {}; int main() Derived obj; cout＜＜obj.x＜＜end1; return 0; } 该程序运行后的输出结果是
A．20
B．30
C．10
D．0
正确答案：A
解析：本题考核虚基类的应用。本题中，虽然Derived1和Derived2都是由共同的基类x派生而来的，但山于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第8题：
下面程序运行的结果是()。includeusing namespace std;class A{ protected:int a; pub 下面程序运行的结果是( )。 #include＜iostream＞ using namespace std； class A{ protected: int a; public: void input(int i) {a=i;} }; class B{ protected: int a; public: void input(int j) {a=j;} }; class C: public A, public B { int x; public: void input() {x=A::a * B::a;cout＜＜x＜＜endl;} }; void main() { C c; c.A::input(5); c.B::input(8); c.input(); }
A．5
B．8
C．40
D．编译出错
正确答案：C
解析：用成员名限定法来消除二义性，故答案为C。第9题：
若有以下程序: includeusing namespace std;class Base{public:Base ( ){x=0;}int x 若有以下程序：# include ＜iostream＞using namespace std;class Base{public: Base ( ) { x=0; } int x;};class Derived1 : virtual public Base{public: Derived1 ( ) { x=10; }}; class Derived2 : virtual public Base{public: Derived2 () { x=20; }};class Derived : public Derived1,protected Derived2{ };int main(){ Derived obj; cout＜＜obj.x＜＜end1; return 0;} 该程序运行后的输出结果是
A．10
B．20
C．30
D．0
正确答案：B
解析：本题考核虚基类。本题中，虽然Derived1和Derived2都是由共同的基类 x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derived obj”时，就会先调用虚基类 Base的构造函数，使得x=0，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第10题：
有如下程序includeusing namespace std;class Base{protected:Base(){cout<<'A';}Bas 有如下程序 #include＜iostream＞ using namespace std； class Base{ protected： Base(){cout＜＜'A'；} Base(char c){cout＜＜c;) }; class Derived: public Base{ public： Derived(char c){cout＜＜c;) }； int main(){ Derived dl('B')； return 0； } 执行这个程序屏幕上将显示输出( )。
A．B
B．BA
C．AB
D．BB
正确答案：C
第11题：
下面程序的运行结果是includeclass base{protected: int a;public: base(){cout << 下面程序的运行结果是 #include＜iostream．h＞ class base{ protected： int a； public: base(){cout ＜＜"0"；} }； class basel：virtual base{ public： basel () {cout ＜＜"1"；} }； class base2：virtual base{ public： base2(){cout ＜＜"2"；} }； class derived：public basel，public base2{ public： derived(){cout ＜＜"3"；} }； void main() { derived obj； cout ＜＜end1； }
A．123
B．3120
C．312
D．3012
正确答案：A
解析：本题考查的是含有虚基类的继承中构造函数的调用顺序，应该先调用基类的构造函数，接着是按照派生类继承列表的顺序依次调用虚基类的构造函数，最后调用派生类自己的构造函数。第12题：
下列程序的输出结果是______。 includeclass base { int x,y; public: base(int i,i 下列程序的输出结果是______。
include＜iostream.h＞
class base
{
int x,y;
public:
base(int i,int j){x=i;y=j;}
virtual int add( ){return x+y;}
};
class three:public base
{
int z;
public:
three(int i,int j,int k):base(i,j){z=k;)
int add( ){return(base::add( )+z);}
};
void main( )
{
three*q=new three(10,20,30);
cout＜＜q-＞add( )＜＜endl;
}
正确答案：60
60 解析：本题考察继承中子类对父类的继承方式，注意子类的add成员函数，它直接使用了父类的成员函数进行运算。第13题：
已知如下类定义: class Base { public Base (){ ／／... } public Base ( int m ){ ／／... } protected void fun( int n ){ ／／... } } public class Child extends Base{ ／／ member methods } 如下哪句可以正确地加入子类中?()A.private void fun( int n ){ //...}
B.void fun ( int n ){ //... }
C.protected void fun ( int n ) { //... }
D.public void fun ( int n ) { //... }
正确答案:CD
第14题：
有如下程序:includeusing namespace std;class Base{protected:Base(){cout<<'Base'; 有如下程序： #include＜iostream＞ using namespace std; class Base{ protected: Base(){cout＜＜'Base';} Base(char c){cout＜＜c;} }; class Derived:public Base{ public: Derived(char c){cout＜＜c;} }; int main(){ Derived d('Derived'); return 0; } 执行这个程序屏幕上将显示输出( )。
A．Derived
B．DerivedBase
C．BaseDerived
D．DerivedDerived
正确答案：C
解析：派生类Derived由基类Base公有派生，在派生类构造函数声明时系统会自动调用基类的缺省构造函数。调用Derived d('Derived')；后，执行类Derived构造函数的Derived(char c)，系统自动调用基类的缺省构造函数Base()，输出字母Base；再执行派生类的构造函数Derived(char c)，输出字母Derived。第15题：
若有以下程序:includeusing namespace std;class Base{public: Base ( ) {x=0; } in 若有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base ( ) { x=0; } int x; }; class Derivedl : virtual public Base { public: Derivedl () { x=10; } }; class Derived2 : virtual public Base { public: Derived2 () { x=20; } }; class Derived : public Derivedl,protected Derived2{ }; int main ( ) { Derived obj; cout＜＜obj .x＜＜end1; return 0; } 该程序运行后的输出结果是 ( )。
A．20
B．30
C．10
D．0
正确答案：A
解析：本题中，虽然Derivedl和Derived2都是由共同的基类x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derived1的构造函数，使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第16题：
下列程序的运行结果是______。includeclass Base { public: void f(int x){cout<<“B 下列程序的运行结果是______。
include＜iostream.h＞
class Base
{
public：
void f(int x){cout＜＜“Base：”＜＜x＜＜endl；}
)；
class Derived：public Base
{
public：
void f(char*str){cout＜＜“Derived：”＜＜str＜＜endl；}
}；
void main(void)
{
Base*pd＝ne
正确答案：Base：97。
Base：97。 解析： 本题主要考查两个知识点，一是基类指针可以指向派生类对象，并可以访问派生类的所有成员。二是在函数重载中进行隐式类型转换。如pd-＞f(‘a’)；系统到底调用哪个重载函数呢?实参既不是派生类中的形参，也不是基类中f函数的形参类型。此时系统根据就近原则和从高优先级到低优先级的规则尝试隐式转换。单字符更接近整数，故调用的是基类的f函数。第17题：
有以下程序 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。第18题：
下面程序的打印结果是【】。 includeusing namespace std; class Base { public:Base(i 下面程序的打印结果是【 】。
include ＜iostream＞
using namespace std;
class Base
{
public:
Base(int x)
{
a=x;
}
void show()
{
cout＜＜a;
}
private:
int a;
};
class Derived : public Base
{
public:
Derived(int i) :Base(i+1) ,b(i) { }
void show()
{
cout＜＜b;
}
private:
int b;
};
int main ( )
{
Base b(5) , *pb;
Derived d(1);
pb=&d;
pb-＞show();
return 0;
}
正确答案：2
2 解析：基类Base派生出派生类Derived，在主函数中，定义了基类对象b，基类指针pb，以及派生类对象d，并让基类指针pb指向派生类对象乙在C++中，当派生类的对象赋值给基类对象时，只能使用派生类对象中从基类继承的成员。所以最后执行语句“pb-＞show()；”是调用基类的成员函数show()，输出a的值2。第19题：
若有以下程序:includeusing namespace std;class A{protected: int a;public: A() { 若有以下程序： #include ＜iostream＞ using namespace std; class A { protected: int a; public: A() { a=10; } }; class A1 : public A { public: A1() { a=a+1; } }; class A2 : public A { public: A2 () { a=a+2; } }; class B : public A1,public A2 { public: B(){} void print() { cout＜＜a＜＜end1; } }; int main ( ) { B obj; obj.print(); return 0; } 程序运行后的输出结果是( )。
A．产生语法错误
B．11
C．12
D．10
正确答案：A
解析：本题考核派生类的定义和使用。本程序有语法错误，这是由于类B中的print函数中的语句“coutaend1；”要输出成员a的值，从而产生了二义性。分析如下：程序中定义了类A，类A1和类A2都是在类A的基础上以公有继承方式产生的派生类，而类B是在类A1和类A2的基础上经过多重继承方式产生的派生类，所以在类B中成员a有两个拷贝，系统无法区分是从A1继承过来的a，还从A2类继承过来的a。修改方法有以下两种：①在被访问的成员加上作用域分辨符“::”。将类B中的print()函数体中语句改为：coutA1：：aend1；或coutA2：：aend1；但两者的输出结果不同，前者输出11，而后者输出12。②采用虚基类的方法。就是在定义A1和A2时，在派生方式前加上关键词“virtual”。第20题：
若有以下程序:includeusing namespace std;class Base {public:Base() { x=0; } int 若有以下程序： #include ＜iostream＞ using namespace std; class Base { public: Base() { x=0; } int x; }; class Derivedl: virtual public Base { public: Derivedl() { x=10; } }; class Derived2: virtual public Base { public: Derived2() ( x=20; } }; class Derived: public Derivedl,protected Derived2 { }; int main() { Derived obj; cout＜＜obj.x＜＜end1; return 0; } 该程序运行后的输出结果是
A．20
B．30
C．10
D．0
正确答案：A
解析：本题考核虚基类的应用。本题中，虽然Derivedl和Derivec[2都是由共同的基类x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derivedl中修改，还是在类Derivect2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj；”时，就会先调用虚基类Base的构造函数，使得x=0，然后执行类Derivedl的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第21题：
若有以下程序:includeusingnamespacestd;classBase{public: Base() {x=0; } intx;}; 若有以下程序： #include ＜iostream＞ using namespace std； class Base { public： Base() { x=0； } int x； }； class Derivedl : virtual public Base { public: Derivedl() { x=10; } }; class Derived2 : virtual public Base { public: Derived2() { x=20; } }; class Derived : public Derivedl,protected Derived2 { }; int main () { Derived obj; cout＜＜obj.x＜＜end1; return 0; } 该程序运行后的输出结果是( )。
A．10
B．20
C．30
D．0
正确答案：B
解析：本题中，虽然Derived1和Derived2都是由共同的基类x派生而来的，但由于引入了虚基类，使得它们分别对应基类的不同副本。这时数据成员x只存在一份拷贝，不论在类Derived1修改，还是在类Derived2中修改，都是直接对这惟一拷贝进行操作。本题程序执行语句“Derivedobj”时，就会先调用虚基类Base的构造函数，使得x=O，然后执行类Derived1的构造函数使得x=10，再执行类Derived2的构造函数，使得x=20。最后输出x的值为20。第22题：
有如下程序： #include<iostroam> using namespace std； class Base{ protected： Base{cout<<’A’；} Base(char C）{cout<<c；} }； class Derived：public Base{ public： Derived(char C）{tout<<C；} }； int main{ Derived dl(’B’)； retum 0； } 执行这个程序的输出结果是（ ）。
A.B
B.BA
C.AB
D.BB
正确答案：C
本题考查派生类的构造函数和析构函数．在定义一个派生类的对象时，先调用基类的构造函数，然后再执行派生类的构造函数；对象释放时，先执行派生类的析构函数，再执行基类的析构函数。本题中定义了一个派生类对象d1，首先执行基类的构造函数，输出A；然后执行派生类的构造函数，输出B。所以答案为c。第23题：
下列程序的运行结果是______。 includeclass Base { public: virtual void func(int 下列程序的运行结果是______。
include＜iostream.h＞
class Base
{
public:
virtual void func(int i){cout＜＜"class Base:"＜＜i＜＜end1;)
};
class Derived: public Base
{
public:
void func(double d){cout＜＜"class Derived:"＜＜d＜＜endl;}
};
void main( )
{
Base a,*p=a;
Derived b;
p=&b;
(*p).func(3.3);
}
正确答案：class Base:3
class Base:3 解析：题中基类和派生类中有同名函数，但是参数不同。派生关系中，只有在函数类型、函数名和参数个数、参数类型完全相同时，才表现多态性。本题中参数不同，编译器便认为是两个完全不同的函数。通过基类的指针指向派生类对象时，该指针只能访问到派生类中具有多态性的成员函数，而与基类无关的函数是无法通过基类指针来访问的。故调用的是base类的 func函数，系统将3.3强制转化为整型数3。如果将派生类中的func的形参改为int型，则执行的就会是派生类的func函数，此时表现为多态。