C选择题2概要.docx
《C选择题2概要.docx》由会员分享，可在线阅读，更多相关《C选择题2概要.docx（34页珍藏版）》请在冰豆网上搜索。
C选择题2概要
1.在语句cin>>data;中，cin是（类与对象3）
C++的关键字
类名
对象名
函数名
2.有如下程序：
#include
usingnamespacestd;
classComplex{
doublere,im;
public:
Complex（doubler,doublei）:
re（r）,im（i）{}
doublereal（）const{returnre;}
doubleimage（）const{returnim;}
Complex&operator+=（Complexa） {
re+=a.re;
im+=a.im;
return*this;
} };
ostream&operator<<（ostream&s,constComplex&z） {
returns<<’（’<}
intmain（） {
Complexx（1,-2）,y（2,3）;
cout<<（x+=y）<return0;
}
执行这个程序的输出结果是
（1,-2）
（2,3）
（3,5）
（3,1）
3.执行如下的程序段后，输出结果是（）。
cout.fill（’*’）;cout.width（6）;cout.fill（’#’）;
cout<<123<###123
123###
***123
123***
4.在进行完任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态；其中只能用于检测输入流状态的操作函数名称是（）
fail
eof
bad
good
5.在C++语言中，打开一个文件就是将这个文件与一个（）建立关联。
结构
流
类
对象
6.下面关于C++流的叙述中，正确的是（）。
cin是一个输入流对象
可以用ifstream定义一个输出流对象
执行语句序列char*y="PQMN";cout<执行语句序列charx[80];cin.getline（x,80）;时，若键入Happynewyear则x中的字符串是"Happy"
7.在说明语句:
int*f（）;中,标识符f代表的是（）.
一个用于指向整型数据的指针变量
一个用于指向一维数组的行指针
一个用于指向函数的指针变量
一个返回值为指针型的函数名
8.有如下函数模板定义：
templateTfunc（Tx,Ty）{returnx*x+y*y;}
在下列对func的调用中，错误的是（）。
func（3,5）;
func（3.0,5.5）;
func（3,5.5）;
func（3,5.5）;
在下列函数原型中，可以作为类AA构造函数的是（）。
voidAA（int）;
intAA（）;
AA（int）const;
AA（int）;
9.有如下函数模板定义：
template
Tfunc（Tx,Ty）{returnx*x+y*y;}
在下列对func的调用中，错误的是（）。
func（3,5）;
func（3.0,5.5）;
func（3,5.5）;
func（3,5.5）;
10.有如下函数模板templateTsquare（Tx）{returnx*x;}其中T是
函数形参
函数实参
模板形参
模板实参
11.在C++中，用于实现运行时多态性的是（）。
内联函数
重载函数
模板函数
虚函数
12.#include
usingnamespacestd;
classA{
public:
virtualvoidfunc1（）{cout<<"A1";}
voidfunc2（）{cout<<"A2";}
};
classB:
publicA{
public:
voidfunc1（）{cout<<"B1";}
voidfunc2（）{cout<<"B2";}
};
intmain（）{
A*p=newB;
p->func1（）;
p->func2（）;
return0;
}
运行此程序，屏幕上将显示输出
B1B2
A1A2
B1A2
A1B2
13.要实现运行时的多态性，必须通过（）调用虚函数
基类指针
派生类指针
对象名
派生类名
14.要实现动态联编，派生类中的虚函数（）
返回的类型可以与虚函数的原型不同
参数个数可以与虚函数的原型不同
参数类型可以与虚函数的原型不同
以上都不对
15.要实现动态联编，必须通过（）调用虚函数
对象指针
成员名限定
对象名
派生类名
16.虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。
有如下程序：
#include
usingnamespacestd;
classBase
{
public:
virtualvoidf（）{cout<<"f0+";}
voidg（）{cout<<"g0+";}
};
classDerived:
publicBase
{
public:
voidf（）{cout<<"f+";}
voidg（）{cout<<"g+";}
};
intmain（）
{
Derivedd;
Base*p=&d;
p->f（）;p->g（）;
return0;
}
运行时输出的结果是（）。
f+g+
f0+g+
f+g0+
f0+g0+
17.下面四个选项中，（）是用来声明虚函数的。
virtual
public
include
usingnamespace
18.下面描述中，正确的是（）。
virtual可以用来声明虚函数
含有纯虚函数的类是不可以用来创建对象的，因为它是虚基类
即使基类的构造函数没有参数，派生类也必须建立构造函数
静态数据成员可以通过成员初始化列表来初始化
19.下面关于C++语言的描述错误的是（）。
C++语言支持数据封装
C++语言中引入友元没有破坏封装性
C++语言允许函数名和运算符重载
C++语言支持动态联编
20.有如下程序
#include
usingnamespacestd;
classBase{
protected:
Base（）{cout<<’A’;}
Base（charc）{cout<};
classDerived:
publicBase{
public:
Derived（charc）{cout<};
intmain（）{
Derivedd1（’B’）;
return0;
}
执行这个程序屏幕上将显示输出______。
B BA AB BB
21.在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是（）。
派生类的对象可以赋给基类的对象
派生类的对象可以初始化基类的引用
派生类的对象可以直接访问基类中的成员
派生类的对象的地址可以赋给指向基类的指针
22.在公有继承的情况下，允许派生类直接访问的基类成员包括?
公有成员
公有成员和保护成员
公有成员保护成员和私有成员
保护成员
23.在公有继承的情况下，基类成员在派生类中的访问权限（）。
受限制
保持不变
受保护
不受保护
24.在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则（）。
完全相同
完全不同
部分相同，部分不同
以上都不对
25.下面叙述不正确的是（）。
基类的保护成员在派生类中仍然是保护的成员
基类的保护成员在公有派生类中仍然是保护的
基类的保护成员在私有派生类中仍然是私有的
对基类成员的访问必须是无二义性的
26.下面描述中，表达错误的是（）
公有继承时基类中的public成员在派生类中仍是public的
公有继承时基类中的private成员在派生类中仍是private的
公有继承时基类中的protected成员在派生类中仍是protected的
私有继承时基类中的public成员在派生类中是private的
27.运用运算符delete删除一个动态对象时（）。
系统首先为该动态对象调用构造函数，再释放其占用的内存
系统首先释放该动态对象占用的内存，再为其调用构造函数
系统首先为该动态对象调用析构函数，再释放其占用的内存系统
首先释放动态对象占用的内存，再为其调用析构函数
28.有如下类声明：
classMyBASE{
intk;
public:
voidset（intn）{k=n;}
intget（）const{returnk;}
};
classMyDERIVED:
protectedMyBASE{
protected:
intj;
public:
voidset（intm,intn）{MyBASE:
:
set（m）;j=n;}
intget（）const{returnMyBASE:
:
get（）+j;}
};
则类MyDERIVED中保护的数据成员和成员函数的个数是（）。
4
3
2
1
29.有如下类定义：
classMyBase{
intk;
public:
MyBase（intn=0）:
k（n）{}
intvalue（）{returnk;}
};
classMyDerived:
MyBase{
intj;
public;
MyDerived（inti）:
j（i）{}
intgetK（）const{returnk;}
intgetJ（）const{returnj;}
};
在一个派生类对象结束其生命周期时（）。
先调用派生类的析构函数后调用基类的析构函数
先调用基类的析构函数后调用派生类的析构函数
如果基数没有定义析构函数，则只调用派生类的析构函数
如果派生类没有定义析构函数，则只调用基类的析构函数
30.执行下列语句后的结果为（）.
intx=3,y;
int*px=&x;
y=*px++;
x=3,y=4
x=3,y=3
x=4,y=4
x=3,y不知
48.在用关键字class定义的类中，以下叙述正确的是（）。
在类中，不作特别说明的数据成员均为私有类型
在类中，不作特别说明的数据成员均为公有类型
类成员的定义必须是成员变量定义在前，成员函数定义在后
类的成员定义必须放在类定义体内部
31.有如下程序：
＃include
classBASE{
charc;
public:
BASE（charn）:
c（n）{}
virtual~BASE（）{cout<};
classDERIVED:
publicBASE{
charc;
public:
DERIVED（charn）:
BASE（n+1）,c（n）{}
~DERIVED（）{cout<};
intmain（）
{
DERIVEDD（’X’）;
return0;
}
执行上面的程序将输出（）。
XY
YX
X
Y
32.在以下new和delete运算符使用中,错误的是（）.
char*p=newchar[10];delete[]p;
char*p=newchar[5];delete[]p;p=newchar[10];delete[]p;
char*p=newchar;deletep;
char*p=newint[10];deletep;
33.有如下程序：
#include
usingnamespacestd;
classBASE{
public:
~BASE（）{cout<<"BASE";}
};
classDERIVED:
publicBASE{
public:
~DERIVED（）{cout<<"DERIVED";}
};
intmain（）{DERIVEDx;return0;}
执行后的输出结果是（）。
BASE
DERIVED
BASEDERIVED
DERIVEDBASE
34.有如下程序：
#include
usingnamespacestd;
classA{
public:
A（）{cout<<"A";}};
classB{public:
B（）{cout<<"B";}};
classC:
publicA{
Bb;
public:
C（）{cout<<"C";}};
intmain（）{Cobj;return0;}
执行后的输出结果是（）。
CBA
BAC
ACB
ABC
35.有如下程序：
#include
usingnamespacestd;
classA{
public:
A（inti）{x=i;}
voiddispa（）{cout<private:
intx;
};
classB:
publicA{
public:
B（inti）:
A（i+10）{x=i;}
voiddispb（）{dispa（）;cout<private:
intx;
};
intmain（）{
Bb
（2）;
b.dispb（）;
return0;
}
运行时输出的结果是
10,2
12,10
12,2
2,2
36.用new运算符创建一维数组的正确形式是（）.
int*p=newa[10];
float*p=newfloat[10];
int*p=newint[10]={0};
int*p=newint[5]={1,2,3,4,5,6};
37.有如下程序：
#include
usingnamespacestd;
classA
{
public:
A（）{cout<<"A";}
~A（）{cout<<"~A";}
};
classB:
publicA
{
A*p;
public:
B（）{cout<<"B";p=newA（）;}
~B（）{cout<<"~B";deletep;}
};
intmain（）
{
Bobj;
return0;
}
执行这个程序的输出结果是
BAA~A~B~A
ABA~B~A~A
BAA~B~A~A
ABA~A~B~A
49.重载运算符的实质是函数调用,如果重载了后置单目运算符“++”,执行C++,则相当于执行了哪个函数（）
c.operator++（c,0）
c.operator++（）
operator++（）
operator++（c,0）
38.应在下列程序划线处填入的正确语句是（）
#include
classBase{
public:
voidfun（）{cout<<"Base:
:
fun"<};
classDerived:
publicBase{
voidfun（）
{_____________//显示调用基类的函数fun（）
cout<<"Derived:
:
fun"<}
};
fun（）;
Base.fun（）;
Base:
:
fun（）;
Base->fun（）;
39.有如下程序
#include
#include
usingnamespacestd;
classMyClass{
public:
MyClass（）{cout<<’A’;}
MyClass（charc）{cout< ~MyClass（）{cout<<’B’;}
};
voidmain（）{
MyClassp1,*p2;
p2=newMyClass（’X’）;
deletep2;}
执行这个程序幕上将显示输出______。
ABX
ABXB
AXB
AXBB
40.有如下程序：
#include
usingnamespacestd;
classPoint{
public:
staticintnumber;
public:
Point（）{number++;}
~Point（）{number--;}
};
intPoint:
:
number=0;
voidmain（）{
Point*ptr;
PointA,B;
Point*ptr_point=newPoint[3];
ptr=ptr_point;
PointC;
cout<:
number<delete[]ptr;
}运行时输出的结果是
3
4
6
7
41.以下程序的运行结果是______。
#include"stdio.h"
main（）{
inta[]={1,2,3,4,5,6,7,8,9,10,11,12};
int*p=a+5,*q＝NULL;
*q=*（p+5）;
cout<<*p<<*q;}
运行后报错
66
612
55
42.有如下程序：
#include
usingnamespacestd;
classTest{
public:
Test（）{n+=2;}
~Test（）{n-=3;}
staticintgetNum（）{returnn;}
private:
staticintn;
};
intTest:
:
n=1;
intmain（）
{
Test*p=newTest;
deletep;
cout<<"n="<:
getNum（）<return0;
}
执行后的输出结果是（）。
n=0
n=1
n=2
n=3
43.以下程序段的输出结果是（）.
char*alp[]={"ABC","DEF","GHI"};intj;cout<A
B
D
DEF
44.以下程序的输出结果是______。
main（）
{inti,x[3][3]={9,8,7,6,5,4,3,2,1},*p=&x[1][1];
for（i=0;i<4;i+=2）cout<}
52
51
53
97
45.以下程序的输出结果是（）.
#includevoidmain（）{chars[]="123",*p;p=s;cout<<*p++<123
1
3
321
46.以下程序的输出结果是（）。
#include
voidmain（）{
47.chars[]="12134211",*p;
intv1=0,v2=0,v3=0,v4=0;
for（p=s;*p;p++）
switch（*p）{
case’1’:
v1++;
case’3’:
v3++;
case’2’:
v2++;
default:
v4++;
}
cout<}
4,2,1,1
4,7,5,8
7,3,2,1
8,8,8,8
47.已知数组A和指针p定义为：
intA[20][10],*p;，要使p指向A的首元素，正确的赋值表达式是（）。
p=&A或p=A[0][0]
p=A或p=&A[0][0]
p=&A[0]或p=A[0][0]
p=A[0]或p=&A[0][0]
50.要使语句p=newdouble[20];能够正常执行，变量p应定义为（）。
doublep[20];
doublep;
double（*p）[20];
double*p;
51.要定义一个具有5个元素的一维数组，并使其各元素的初值依次是30，50，-88，0和0，则下列定义语句中不正确的是[]。
intvect[]={30,50,-88};
intvect[]={30,50,-88,0,0};
intvect[5]={30,50,-88};
intvect[5]={30,50,-88,0,0};
52.下面说明不正确的是（）.
chara[10]="china";
chara[10],*p=a;p="china"
char*a;a="china";
chara[10],*p;p=a="china"
53.重载赋值操作符时，应声明为（）函数。
友元
虚
成员
多态
54.在一个类中可以对一个操作符进行（）重载。
1种
2种以下
3种以下
多种
55.在下列函数原型中，可以作为类AA构造函数的是（）。
voidAA（int）
intAA（）
AA（int）const
AA（int）
56.在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是（）。
虚函数
友元函数
构造函数
析构函数
57.在定义构造数据类型时，不能（）。
说明变量
说明存储类型
初始化
末尾不写分号
58.在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。
则operator+有（）个参数，operator*有（）参数。
2、2
2、
升级会员 