为完成下面的程序,应在划线处填入的语句是()。includeusingnamespacestd;classBase{pr为完成下面的程序，应在划线处填入的语句是( )。 #include ＜iostream＞ using namespace std； class Base { private： int x； public： Base(int i) { x=i； } ～Base(){} }； class Derived ： public Base { public: _______________ //完成
题目
为完成下面的程序，应在划线处填入的语句是( )。 #include ＜iostream＞ using namespace std； class Base { private： int x； public： Base(int i) { x=i； } ～Base(){} }； class Derived ： public Base { public: _______________ //完成类Derive构造函数的定义 }； int main() { Derived Obj； return 0； }
A．Derived(int i)：Base(i){}
B．Derived(){}
C．voidDerived(int i)：Base(0){}
D．Derived(int i){Base(i)；}
相似考题
更多“为完成下面的程序,应在划线处填入的语句是()。includeusingnamespacestd;classBase{pr 为完成下面的程序，应在划线处填入的语句是( )。 #include ＜iostream＞ using namespace std； class Base { private： int x； public： Base(int i) { x=i； } ～Base()”相关问题
-
第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题：
为完成下面的程序,应在划线处填入的语句是includeusingnamespace std;class Base{pri 为完成下面的程序，应在划线处填入的语句是 #include＜iostream＞ using namespace std； class Base { private： int x； public： Base (int i) { x=i； } ～Base(){} }； class Derived：public Base { public： ______________//完成类Derive构造函数的定义 }； int main() { Derived Obj； return 0； }
A．Derived(int i)：Base(i){}
B．Derived(){}
C．void Derived (int i)：Base(i){}
D．Derived(int i){Base(i)；}
正确答案：A
解析：本题考核派生类中的构造函数。程序中，类Derived是基类Base的公有派生。在类Derived的构造函数应该包括调用基类构造函数使基类的数据成员得以初始化。 -
第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 Base{ public: void fun() { cout<<" 有如下程序： #include ＜iostream＞ using namespace std; class Base { public: void fun() { cout＜＜"Base::fun"＜＜endl; } }; class Derived : public Base { public: void fun() { ______ cout＜＜"Derived::fun"＜＜endl; } }; int main() { Derived d; d.fun(); return 0; } 已知其执行后的输出结果为： Base::fun Derived::fun 则程序中下划线处应填入的语句是( )。
A．Base.fun();
B．Base::fun();
C．Base-＞fun();
D．fun();
正确答案：B
解析：此题考查的是继承的使用。分析题目可知，横线处应填入对基类成员函数fun()的调用语句，此处只能使用作用域运算符“::”才能调用到基类的同名函数。 -
第5题：
在下列程序画线处填入的正确语句是()。includeusing namespace std;classBase{public: 在下列程序画线处填入的正确语句是( )。 #include ＜iostream＞ using namespace std； class Base { public： void fun() { cout＜＜"Base：：fun"，＜＜end1； } }； class Derived：public Base { void fun() { ______________ //显式调
A．fun()；
B．Base.fun()；
C．Base：：fun()；
D．Base-＞fun()；
正确答案：C
解析：本题主要考核作用域分辨符的使用。作用域分辨符“::”可以用来限定要访问的成员所在类的名称。 -
第6题：
下面程序的打印结果是【】。 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。 -
第7题：
有如下程序:includeusing namespace std;class Base{private:charc;public:Base(cha 有如下程序：#include ＜iostream＞using namespace std;class Base{private: char c;public: Base(char n) :c(n){} ～Base() { cout＜＜c; } };class Derived: public Base{private: char c; public: Derived(char n):Base(n+1),c(n) {} ～Derived() { cout＜＜c; }};int main (){ Derived obj ('x'); return 0;}执行上面的程序净输出
A．xy
B．yx
C．x
D．y
正确答案：A
解析：在C++中，由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。在此题的程序中，在主函数main结束时，派生类Derived对象obj将被删除，所以就会调用对象的析构函数。先调用派生类的析构函数，输出x，然后调用基类的析构函数，输出y。 -
第8题：
有如下程序: includeusing namespace std; class Base { public: 有如下程序： #include＜iostream＞ using namespace std; class Base { public: void fun() { cout＜＜"Base::fun"＜＜endl; } }; class Derived: public Base { public: void tim() } ____________ cout＜＜"Derived:: fun"＜＜endl; } }; int main() { Derived d; d.fun(); return O; } 已知其执行后的输出结果为： Base::fun Derived::fun 则程序中下划线处应填入的语句是
A．Base.fun()；
B．Base::fun()；
C．Base-＞fun()；
D．fun()；
正确答案：B
解析：本题考查的知识点是继承的运用。题目中要求的两行输出结果分别在基类的成员函数fun()与派生类的成员函数fun()中给出，而主函数中只通过派生类对象d调用fun()函数，即只调用了派生类的成员函数fun()。所以，横线处应该填入对基类成员函数fun()的调用语句，此处只能使用作用域运算符“::”才能调用到基类中的同名函数，故应该选择B。 -
第9题：
若有以下程序: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。 -
第10题：
若有以下程序: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的对象对它们进行访问。本程序的功能是对类中各数据成员进行赋值，然后查看赋值是否正确。 -
第11题：
在下列的程序的横线处填上适当的语句,使该程序的输出为12。includeusing namespace 在下列的程序的横线处填上适当的语句，使该程序的输出为12。
include＜iostream.h＞
using namespace std；
class Base
{
public：
int a，b；
Base(int i){a＝i;}
}；
class Derived：public Base
{
int a；
public：
Derived(int x)：Base(x)，b(x+1){}；
void show()
{
正确答案：eoutBase：：a。
eoutBase：：a。 解析： 本题考查的是基类和派生类的构造函数。派生类构造函数的执行顺序：首先调用基类的构造函数，调用顺序按它们被继承时说明的顺序；然后调用子对象的构造函数，调用顺序按它们在类中说明的顺序；最后是派生类构造函数中的内容。本题要求结果是输出12，分析题目，首先调用基类的构造函数，然后是调用子对象的构造函数，横线处要求输出基类成员a的值，填入toutBase：：a即可。 -
第12题：
在下面横线上填上适当的语句,完成程序。includeusing namespace std; class Base { in 在下面横线上填上适当的语句，完成程序。
include＜iostream＞
using namespace std；
class Base
{
int x；
public：
Base(int i){x＝i；}
～Base(){}
)；
class Derived：public Base
{
public：
______//完成类Derive构造函数的定义
};
iht main()
{
Derived obj
正确答案：Derived(int i；Base(i){}。
Derived(int i；Base(i){}。 解析： 程序中，类Derived是基类Base的公有派生。在类Derived的构造函数应该包括调用基类构造函数使基类的数据成员得以初始化， -
第13题：
在下面的程序的横线处填上适当的语句，使该程序的输出为12。
include 〈iostream〉
using namespace std;
class Base
{
public:
int a;
Base(int i) { a=i；}
};
class Derived : public Base
{
int a;
public:
Derived(int x) : Base(x),b(x+1) {}
void show()
{
【 】; //输出基类数据成员a的值
cout〈〈b〈〈end1;
}
};
int main()
{
Derived d(1);
d.show();
return 0;
}
正确答案：cout〈〈Base::a
cout〈〈Base::a 解析：本题考核作用域分辨符“::”的使用。 -
第14题：
有如下程序: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
解析：派生对象在创建时先调用基类的构造函数，然后调用派生类的构造函数；撤销对象时，先调用派生类的构造函数，然后调用基类的构造函数。当类中出现其他类对象时，在初始化时先调用该对象的类的构造函数创建该对象。第15题：
有如下程序: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
解析：本题考核派生类的定义和使用。当对象被删除时，派生类的析构函数就被执行。由于析构函数不能被继承，因此在执行派生类的析构函数时，基类的析构函数也将被调用。执行顺序是先执行派生类的析构函数，再执行基类的析构函数，其顺序与执行构造函数的顺序正好相反。所以当main函数结束时，派生类DERIVED的对象x将被删除，那么派生类DERIVED的析构函数先被调用，输出DERIVED，然后调用基类的析构函数输出BASE。第16题：
有以下程序 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。第17题：
有如下程序;includeusing namespace std;class Base{public;Base(inti){x=i;}void d 有如下程序; #include ＜iostream＞ using namespace std; class Base { public; Base(inti){x=i;} void dispa0{cout＜＜x＜＜',';} private; int x; }; class Derived;public Base { public; Derived(int i);Base(i+10) {x=i;) void dispb(){dispa();cout＜＜x＜＜end1;} private; int x; }; int main() { Derived b(2) ; b.dispb(); return 0; } 运行的结果是( )。
A．2,2
B．12,2
C．12,10
D．10,2
正确答案：B
解析："Derived b(2) ;¨以整数2实例化变量b，在执行Derived的构造函数时，以i+10即12去调用类Derived的父类的构造函数，将Base::x初始化为12，然后将Derived::x赋值为2。在执行b.dispb()时，先调用父类中的dispa，输出Base::x，即12，再输出Derived::x，即2，所以运行结果为“12，2”。第18题：
应在下列程序画线处填入的正确语句是 ( )。includeusing namespace std;clas Base{pu 应在下列程序画线处填入的正确语句是 ( )。 #include ＜iostream＞ using namespace std; clas Base { public: void fun() { cout＜＜"Base::fun"＜＜end1; } }; class Derived : public Base { void fun() { ________________//显示调用基类的函数 fun() cout＜＜"Derived::fun"＜＜end1; } };
A．fun();
B．Base.fun();
C．Base::fun();
D．Base-＞fun();
正确答案：C
解析：作用域分辨符号是“::”，它可以用来限定要访问的成员所在的类的名称。在派生类Derive的定义中显式调用基类的函数fun()，则只能借助于作用域分辨符“::”。第19题：
如下程序执行后的输出结果是【】。includeusing namespace std; class Base { public: 如下程序执行后的输出结果是【 】。
include ＜iostream＞
using namespace std;
class Base
{
public:
Base(int x,int y)
{
a=x;
b=y;
}
void Show()
{
cout＜＜"Base: "＜＜a＜＜ ',' ＜＜b＜＜" ";
}
private:
int a,b;
};
class Derived : public Base
{
public:
Derived(int x, int y, int z) : Base(x,y),c(z) { }
void Show()
{
cout＜＜"Derived:"＜＜c＜＜end1;
}
private:
int c;
};
int main()
{
Base b(100,100),*pb;
Derived d(10,20,30);
pb=&b;
pb-＞Show();
pb=&d;
pb-＞Show();
return 0;
}
正确答案：Base：100100 Base：1020
Base：100,100 Base：10,20 解析：本题考核对象指针的应用。主函数中通过对象指针pb．分别调用其类成员函数Show()和派生类成员函数Show()先后输出 Base：100,100Base：10,20。第20题：
有如下程序： #include＜iostream) using namespace std； classBase{ 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
A．100
B．000
C．010
D．001
正确答案：D
解析： 本题考查的知识点是：类的构造。建立一个类的对象时，构造函数的执行顺序如下：①执行基类的构造函数，调用顺序按照各个基类被继承时声明的顺序(自左向右)；②执行成员对象的构造函数，调用顺序按照各个成员对象在类中声明的顺序(自上而下)：③执行自身的构造函数。本题Derived类继承于Base类，所以首先会构造基类Base，但 Derived类的构造函数没有初始化列表，所以将调用Base类的默认构造函数，输出一个0。接下来由于它的成员中还定义了一个Base类的对象，而构造函数也没有显示初始化这个对象，所以再次调用第21题：
有以下程序:inClUdeusingnamespacestd;ClassBase{public: Base(intx) {a=x; } voidsh 有以下程序： #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； } 运行后的输出结果是( )。
A．1
B．5
C．2
D．0
正确答案：C
解析：基类Base派生出派生类Derived，在主函数中，定义了基类对象b，基类指针pb，以及派生类对象d，并让基类指针pb指向派生类对象d。在C++中，当派生类的对象赋值给基类对象时，只能使用派生类对象中从基类继承的成员。所以最后执行语句“pb->show()；”是调用基类的成员函数show()，输出a的值2。第22题：
下列程序中划线处正确的语句是()。includeusing namespace std;class Base{public:vo 下列程序中划线处正确的语句是( )。#include ＜iostream＞using namespace std;class Base{public:void fun() { cout＜＜"Base:: fun"＜＜end1; }};class Derived: public Base{ void fun() { _______________________ //显试调用基类的函数 fun() cout ＜＜"Derived:: fun"＜＜end1;};
A．fun();
B．Base. fun();
C．Base:: fun();
D．Base-＞fun();
正确答案：C
第23题：
请在下列程序的横线处填写正确的语句。includeusing namespace std; class Base{ publ 请在下列程序的横线处填写正确的语句。
include＜iostream＞
using namespace std;
class Base{
public:
void fun(){cout＜＜"Base fun"＜＜endl;}
};
class Derivde:public Base{
public:
void fun(){
______∥ 调用基类的函数
正确答案：Base∷fun()
Base∷fun() 解析： 此题考查的是派生类对基类成员的访问。本题中派生类Derived覆盖了基类Base中的fun()，如果需要调用基类中的fun()，则需要使用域运算符“∷”。故应填写Base∷fun()。