在下列程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD（ ）。#include<iostream>usingnamespacestd；classA{public：A（）{cout<<A；}}；classB：{public：B（）{cout<<B；}}；classC：virtualpublicA{public：C（）{cout<<C；}}；classD：publicB，publicD{public：D（）{cout<<D；}}；voidmain（）{D04；}A.publicAB.private
题目
在下列程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD（ ）。
#include<iostream>
usingnamespacestd；
classA
{
public：A（）{cout<<'A'；}
}；
classB：
{
public：B（）{cout<<'B'；}
}；
classC：virtualpublicA
{
public：C（）{cout<<'C'；}
}；
classD：publicB，publicD
{
public：D（）{cout<<'D'；}
}；
voidmain（）{D04；}
A.publicA
B.privateA
C.protectedA
D.virtualpublicA
相似考题
参考答案和解析
D。【解析】由主函数main入手，定义了类D对象obi。其中D为类B和C的公有继承，A是C的虚基类。题目中要求的输出结果为ABCD，依次为类A、类B、类C、类D中构造函数的输出语句。为了保证基类通过多条路径被派生类继承，即保证A只被继承一次，输出一个A，所以不但需要声明A为C的虚基类，同样也要声明A为B的虚基类。
更多“在下列程序的横线处填上适当的内容,使程序执行后的输出结果为ABCD( )。 #include<iostream> ”相关问题
-
第1题：
在下面程序横线处填上适当内容,使得程序的输出为9876。includeusing namespace std;te 在下面程序横线处填上适当内容，使得程序的输出为9876。
include ＜iostream＞
using namespace std;
template＜class T＞
void f(【 】)
{
T t;
for (int i=0;i＜n/2;i++)
{
t=a Ii];
a [i]=a[n-1-i];
a [n-1-i]=t;
}
}
int main ( )
{
int x[]={6,7,8,9};
f(x,4);
for (int i=0;i＜4;i++)
cout＜＜x[i];
cout＜＜end1;
return 0;
}
正确答案：Ta[]int n
Ta[],int n 解析：函数f的形参之一为T类型的数组a，形参之二为整型数n。 -
第2题：
下面程序执行后，输出结果为：true请在程序的每条横线处填写一个语句，使程序的功能完整。
注意：请勿改动main()主方法和其他已有的语句内容，仅在横线处填入适当的语句。
public class TestStringCompare{
{public static void main(String ____________________ args)
{char charl[]={'t','e','s','t'};
char char2[]={'t','e','s','t','1'};
String str1=new String(___________________);
String str2=new String(char2,0,4);
System.out.println(__________________________);
}
}
正确答案：[ ] char1 str1．equals(str2)
[ ] char1 str1．equals(str2) 解析：本题主要考查main()主方法的使用、String类的使用。解答本题的关键是熟练掌握main()主方法的使用、String类的使用。在本题中，public static void main(String[]args)中的[]是定义数组的标志，str1．equals(str2)语句的功能是判断字符串str1和字符串str2的内容是否相等。 -
第3题：
在下面程序的横线处填上适当的语句,使该程序执行结果为10。 includeusing namespace 在下面程序的横线处填上适当的语句，使该程序执行结果为10。
include ＜iostream＞
using namespace std；
class MyClass
{
public：
MyClasS(int A)
{
X=a；
}
【 】//取x的值
private：
int x；
}；
int main()
{
MyClass my(10)；
正确答案：int GetNum(){return x；}
int GetNum(){return x；} 解析：由主函数中调用对象my成员函数GetNum()可得到，成员函数GetNum()的功能是返回其私有数据成员x的值。 -
第4题：
在下面的程序的横线处填上适当的语句，使该程序的输出为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 解析：本题考核作用域分辨符“::”的使用。 -
第5题：
在下面程序的画线处填上适当的内容,使程序执行后的输出结果为ABCD。 includeusing 在下面程序的画线处填上适当的内容，使程序执行后的输出结果为ABCD。
include ＜iostream＞
using namespace std；
class A{
public：A( ){cout＜＜'A'；}
}；
class B： (11) {
public：B( ){cout＜＜'B'；}
{；
class C： (12) {
public：C( ){cout＜＜'C'；}
}；
class D：public B，public C{
public：D( ){cout＜＜'D'；}
}；
void main( ){
D( )；
cout＜＜endl；
}
正确答案：public A 空格
public A 空格 解析：考查在继承中构造函数的调用顺序，创建派生类对象时依次调用基类的构造函数，最后调用派生类的构造函数。考查在继承中构造函数的调用顺序，创建派生类对象时依次调用基类的构造函数，最后调用派生类的构造函数。 -
第6题：
请将下列程序的横线处补充完整,使得输出结果为bbaaincludeusing namespace std;class 请将下列程序的横线处补充完整，使得输出结果为bbaa
include＜iostream＞
using namespace std;
class A{
public:
______{cout＜＜"aa";}
};
class B:public A{
public:
～B(){cout＜＜"bb";}
};
int main(){
B*p=new
正确答案：～A()
～A() 解析： 此题考查的是类的构造与析构。本题要求输出的结果中包含aa，所以基类A中横线处的函数一定要被执行。横线处应是定义基类的构造或者析构函数，如果定义的是构造，那么aa肯定在new操作时就输出，而下面的bb是在析构函数中，会在delete时被输出。故可以肯定应填入基类A的析构函数定义：～A()。 -
第7题：
在下列程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD（ ）。 #include<iostream> usingnamespacestd； classA { public：A（）{cout<<A；} }； classB： { public：B（）{cout<<B；} }； classC：virtualpublicA { public：C（）{cout<<C；} }； classD：publicB，publicD { public：D（）{cout<<D；} }； voidmain（）{D04；}
A.publicA
B.privateA
C.protectedA
D.virtualpublicA
正确答案：D
D。【解析】由主函数main入手，定义了类D对象obi。其中D为类B和C的公有继承，A是C的虚基类。题目中要求的输出结果为ABCD，依次为类A、类B、类C、类D中构造函数的输出语句。为了保证基类通过多条路径被派生类继承，即保证A只被继承一次，输出一个A，所以不但需要声明A为C的虚基类，同样也要声明A为B的虚基类。 -
第8题：
要使程序执行后的输出结果为ABCD，应在横线处添加语句（ ）。
A．public A
B．private A
C．protected A
D．virtual public A
正确答案：D
-
第9题：
有以下程序：
程序执行后的输出结果是（ ）。
A.321，cba
B.abc，123
C.123，abc
D.lbe，a23
正确答案：D
字符串是一个特殊的数组，所以按照数组的规则，sl应该指向的是数组的首地址，即“abc”的第一个字符的地址。s2指向的是“123”的第一个字符的地址。调用swap函数之后交换的是两个字符串的第一个字符‘a’和‘1’的内容，所以打印输出为D)。 -
第10题：
要使程序执行后的输出结果为ABCD,应在横线处添加语句()。includeusing namespace std; 要使程序执行后的输出结果为ABCD，应在横线处添加语句( )。 #include＜iostream＞ using namespace std; { public:A(){cout＜＜'A';} }; class B=______ { public:B(){cout＜＜'B';} }; class C:virtual public A { public:C(){cout＜＜'C';} }; class D:public B,public C { public:D(){cout＜＜'D';} }; void main(){D obj;}
A．public A
B． private A
C．protected A
D．virtual public A
正确答案：D
解析：由主函数main入手，定义了类D对象obj。其中D为类B和C的公有继承，A是C的虚基类。题目中要求的输出结果为“ABCD”，依次为类A，类B，类C，类D中构造函数的输出语句。为了保证基类通过多条路径被派生类继承时，即保证A只被继承一次，输出一个A，所以不但需要声明A为C的虚基类，同样也要声明A为B的虚基类。 -
第11题：
在下面的程序的横线处填上适当的语句,使该程序的输出结果为12。includeusing namespac 在下面的程序的横线处填上适当的语句，使该程序的输出结果为12。
include＜iostream＞
using namespace std;
class TestClass
{
public:
int a,b;
TestClass(int i,int j)
{
a=i;
b=j;
}
};
class TestCla
正确答案：coutTestClass∷a
coutTestClass∷a 解析： 题目中程序TestClass为基类，TestClass1为派生类，在主函数中定义TestClass1对象d(1)。据题目要求“输出基类数据成员a的值”，基类为TestClass，利用∷域运算符取其成员a的值。 -
第12题：
有程序：CHARACTER*4A，B*6A=‘ABCD’B=A∥‘EFGH’WRITE（*，*）BEND此程序执行后的输出结果为：（）
- A、ABCDEFGH
- B、ABCDEF
- C、ABCD
- D、EFGH
正确答案:B -
第13题：
在下面程序横线处填上适当内容,以使该程序执行结果为4.4。includeusing namespace std; 在下面程序横线处填上适当内容，以使该程序执行结果为4.4。
include＜iostream＞
using namespace std；
template＜typename T＞
T average(T*datA)
{
T s=0；
int i：0；
while(data[i])
【 】；
return s/(i+1)；
}
int main()
{
double x[]={2.5，4.5，6.5，5，0.0，5，3，18.5}；
cout＜＜average(X)；
return 0；
}
正确答案：s+=data[i++]
s+=data[i++] 解析：函数average()中的while循环用来将求传入的数组中各元素的值的总和。 -
第14题：
下列程序功能为：弹出一个对话框询问用户是否输出，如果是，则输出；否则结束。请在程序空白处填入适当内容使程序完整。
Sub PrintOut()
Dim a As Integer
a = MsgBox("输出结果?", vblnformation + vbYesNo, "提示：")
If a = ______ Then
Print "Myresult"
End If
End Sub
正确答案：vbYes(或6)
vbYes(或6) 解析：MsgBox函数在对话框中显示消息，等待用户单击按钮，并返回一个Integer告诉用户单击哪一个按钮。返回值是一个整数，这个整数与选择的按钮有关，如下表所示。
-
第15题：
在下列的程序的横线处填上适当的语句,使该程序的输出为12。 includeusing namespace st 在下列的程序的横线处填上适当的语句，使该程序的输出为12。
include＜iostream＞
using namespace std;
class TestClass
{
public:
int a,b;
TestClass(int i,int j)
{
a=i;
b=j;
}
};
class TestClass1:public TestClass
{
int a;
public:
TestClass1(int x):TestClass(x,x+1){}
void show()
{
______;//输出基类数据成员a的值?
cout＜＜b＜＜endl;
}
};
int main()
{
TestClass1 d(1);
d.show();
return 0;
}
正确答案：coutTestClass::a
coutTestClass::a 解析：题目中程序TestClass为基类，TestClass1为派生类，在主函数中定义TestClass1对象d(1)。根据题目要求“输出基类数据成员a的值”，基类为TestClass，利用::域运算符取其成员a的值。 -
第16题：
在下面程序的画线处填上适当的内容,使程序执行后的输出结果为1／2005。 includeusin 在下面程序的画线处填上适当的内容，使程序执行后的输出结果为1/2005。
include ＜iostream＞
using namespace std；
class Date{
public：
Date(int m=1，int y=0)：month(m)，year(y){}
void Print( ){cout＜＜month＜＜"/"＜＜year＜＜endl；}
(9) operator+(const Date&dl，const Date& d2)；
private：
int month，year；
}；
(10) operator+(const Date& dl，const Date& d2){
int year，month；
year=d1．year+d2．year；
month=d1．month+d2．month；
year+=(month-1)/12；
month=(month-1)%12+1；
return Date(month，year)；
}
void main( ){
Date dl(3，2004)，d2，d3(10)；
d2=d3+dl；
d2．Print( )；
}
正确答案：friend：Date Date
friend：Date Date 解析：因为重载函数后面有两个形参，“+”运算符是二元运算符，故将“+”运算符重载为友元函数，重载为友元函数的一般格式为：
niend函数类型operator运算符(形参表){函数体} -
第17题：
在下面程序的横线处填上适当的内容,使程序执行后的输出结果果为1／2005。 includeusing 在下面程序的横线处填上适当的内容，使程序执行后的输出结果果为1/2005。
include＜iostmam＞
using namespace std;
class Date
{
public:
Date(int m=1,int y=0):month(m),year(y){}
void Print(){cout＜＜month＜＜"/"＜＜year＜＜endl;}
operator+(const Date&d1．const Date& d2);
private:
int month,year;
};
operator+(const Date&d1,const Date &d2)
{
int year,month;
year=d1.year+d2.year;
month=d1.month+d2.month;
year+=(month-1)/12;
month=(month-1)%12+1;
return Date(month,year);
}
void main()
{
Date d1(3,2004),d2,d3(10);
d2=d3+d1；
d2.Print();
}
正确答案：friend Date Date
friend Date Date -
第18题：
在下面程序的横线处填上适当的内容,使程序执行后的输出结果为ABCD。 includeusingn 在下面程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD。
include ＜iostream.h＞
using namespace std;
class A
{
public: A() {cout＜＜'A';
};
class B:______
{
public: B() {cout＜＜'B';}
};
class C:______
{
public: C(} cout＜＜'C';}
};
class D:public B, public C
{
public: D(){cout＜＜'D';}
};
void main(){D obj;}
正确答案：virtual public A； visual public A
virtual public A； visual public A 解析：本题考核虚基类的应用。通过虚基类所派生的类，在所产生的对象中，只包含了一个和其他类共享的基础对象，也就是说，从同一个基类中以虚拟方式派生的所有类，在它们所产生的对象里，不会有一份基础对象，而只是在内存里保留一份基础对象，而派生类中只保留指向此基础对象的指针，这样就千会同时有两份基类对象的情形发生。题中程序最后字符A只输出了一次，所以类A必须为类 B和类C的虚基类。 -
第19题：
程序运行后，利用冒泡法对数组a中的数据按从小到大排序。请在空白处填上适当的内容，在横线处应填写（ ）。
A. Form=0 To 4
B. Form=0 To 4
C. Form=1 To 4
D. Form=1 To 4
正确答案：C
C) 【解析】本题考查冒泡排序。可通过双重循环来实现冒泡排序，题中内层循环进行的是相邻元素两两比较，每一轮使未排序中的最大数移动到数组最后的元素中。外层循环需要进行的次数计算方法为：有n个数要排序时，则要进行n-1轮外层循环。题中共有5个数，因此外循环进行4轮，所以m最大值为4。
-
第20题：
在下向程序和横线处填上适当的内容,使程序执行后的输出结果为1／2005。 includeusing 在下向程序和横线处填上适当的内容，使程序执行后的输出结果为1/2005。
include ＜iostream＞
using namespace std;
class Date
{
public:
Date(int m=1,int y=0):month(m),year(y){}
void Print() {cout＜＜month＜＜"/"＜＜year＜＜end 1; }
【 】 operator+(eonst Date& d1, const Date& d2);
private:
int month,year;
};
【 】 operator+(const Date& d1, const Date& d2)
{
int year,month;
year=d1.year+d2.year;
month=d1. month+d2.month;
year+=(month-1 )/12;
month=(month-1 )% 12+1;
return Date(month,year);
}
void main()
Date d1 (3,2004),d2,d3(10);
d2=d3+d1;
d2,Print();
}
正确答案：friend Date Date
friend Date Date 解析：重载及友元的相关内容。 -
第21题：
下列程序的输出结果为2，横线处应添加语句（ ）。
A．public
B．private
C．virtual
D．protected
正确答案：C
-
第22题：
在下列的程序的横线处填上适当的语句,使该程序的输出为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即可。 -
第23题：
在下面程序的横线处填上适当的内容,使程序执行后的输出结果为ABCD。 includeusing nam 在下面程序的横线处填上适当的内容，使程序执行后的输出结果为ABCD。
include＜iostream＞
using namespace std;
class A
{
public: A(){cout＜＜'A';}
};
class B:【 】
{
public:B(){cout＜＜'B';)
};
class C:【 】
{
public;C(){cout＜＜'C';}
};
class D:public B,public C
{
public:D(){cout＜＜'D';}
};
void main(){D obi;}
正确答案：virtual public A virtual public A
virtual public A virtual public A