2022-2023（2）C++程序设计学习通超星期末考试答案章节答案2024年

2022-2023（2）C++程序设计学习通超星期末考试章节答案2024年classfruit{public:

fruit(){

cout<<"fruitconstructor"<答案:applebobj;YTapplecobj;apple*objPnt=&bobj;objPnt->display();objPnt=&cobj;objPnt->display();;apple*objPnt=newYTapple;objPnt.display();deleteobjPnt;classfruit{public：

fruit(){

cout<<"fruitconstructor"<答案:可以使用virtual限定fruit类中的display接口，那么apple类中的display也跟着成为虚函数。;可以使用virtual限定fruit类中的析构函数~fruit()，那么apple类中的析构函数~apple()也跟着成为虚析构函数。;可以在apple的继承声明中使用virtual限定fruit父类，那么fruit就成为虚基类。面向对象程序设计中的多态有：

答案:静态多态，可以是一般的函数重载;编译时多态，可以是运算符重载;动态多态，可以是指虚函数和基类指针的联用;运行时多态，可以是指虚函数和基类引用的联用面向对象程序设计（OOP：Object-OrientedProgramming）的基本特征是：4

答案:封装;抽象;继承;多态有基类A，其直接子类B，则以下对继承机制中的访问控制错误的是：

答案:B从A公有派生，那么在B的私有访问控制中声明的成员函数无法访问基类A中的受保护成员。;B从A私有派生，那么在B的私有访问控制声明的成员函数无法访问基类的受保护成员。有以下类声明：classA{public：

A();

voidset_pub(intval);

intget();

intpub_val;protected:

voidset_pro(intval);

voidprint();

intpro_val;private:

voidset_pri(intval);

intpri_val;};classB:publicA{public:

voidfun();};classC:protectedA{public:

voidfun();};以下描述正确的是：

答案:对于类型A的成员函数set_pro,可以访问类A的任意成员，因此以下为合法的实现:voidA::set_pro(intval){

pub_val=val;

pro_val=val*2;

set_pri(val*3);}有以下类的声明：classfruit{public:

fruit(stringnam,stringcol):name(nam),color(col);

stringgetname()const;

stringgetcolor()const;

voidchangecolor(stringcol);protected:

stringname;

stringcolor;};classapple:publicfruit{public:

apple(stringnam,stringcol,stringaddr);

stringgetaddress()const;

voidchangeaddress(stringaddr);protected:

stringaddress;};那么下列选项描述正确的是：

答案:apple是fruit的派生类，apple中的数据成员实际上有3个：name，color，address。;fruit是apple的父类，我们可以使用is-A关系描述为appleisfruit面向的程序设计中，下列对使用继承机制来定义新类型的方法描述正确的是：

答案:继承机制是C++面向对象程序设计中快速定义新类型的一种方法。;使用继承机制定义类型的好处是代码重用。;使用继承机制定义类型的好处是使代码更可靠。下列对文件按ASCII文件读写打开时，若设置以下标记（没有其他标记了），则标记含义描述正确的是：

答案:ios::in

代表读文件，如果对应文件不存在则报错;ios::out代表写文件，如果对应文件不存在则会新建一个文件从头开始供写;ios::out代表写文件，如果对应文件存在则会将这个文件清空从头开始待写/star3/origin/042dc716ee520b1984a3b8ba6d3f29d4.jpg

答案:ifstreaminfile("d:/test.txt");charch;while(!infile.eof()){infile.get(ch);cout<<ch;}infile.close();;ifstreaminfile;infile.open("d:\\test.txt");charch;while(infile.get(ch))

cout.put(ch);infile.close();下列对文件的描述正确的是：

答案:文件是操作系统用于组织数据的基本存储单位。它特指存放在外存储器的数据集合。操作系统也会把各种和主机相关联的设备看成是文件来管理，对这些设备的读写等同于对磁盘文件的读写。;在C++程序中，文件的读写操作通过文件流来工作。在使用时需要使用预编译命令#include包含相应的类库。如#include等。整型数据inta=123，若输出流outfile将a按ASCII方式写入文件:outfile<答案:3,4下列代码实现对单向链表Lhead中某个特定值value的查找，哪个查找工作可以直接用于后续的链表相应值的删除工作中：说明：直接的意思是指需要删除时调用封装代码工作就可以了，不需要第二次遍历查找。

答案:node*find(node*head,dataTypevalue){

node*p=head,*pp=nullptr;

while(p&&p->data!=value){pp=p;

p=p->next;}

return

pp;};node*find(node*head,dataTypevalue,node*&target){

node*p=head,*pp=nullptr;

while(p&&p->data!=value){pp=p;

p=p->next;}

target=p;

return

pp;};voidfind(node*head,dataTypevalue,node*&target,node**pre){

target=head,*pre=nullptr;

while(target&&target->data!=value){*pre=target;

target=target->next;}}需要对单向链表Lhead进行升序排序，以下说法正确是：

答案:可以采用逐个向空链表有序插入的方法完成对单向链表的升序排序。具体描述如下：1、构建空链表other；2、从开始遍历Lhead。每遍历一个结点，从Lhead中摘除，并在other中寻找第一个比摘除点值大的结点位置：

1)找不到：如果other为空，则该点成为other的唯一结点;否则追加在other的表尾；

2)找到：如果有前驱点，则插入在前驱点的后面，即当前位置之前；否则就插入在other的表首，并更新other；3、Lhead接管other(Lhead=other;);4、Lhead升序整理完毕。

;可以采用类似于数组中的选择排序方法完成对单向链表的升序排序。具体描述如下：1、从头开始遍历Lhead；设当前遍历点为p;2、假设当前遍历点p的结点值为从p开始的链表的最小值；然后去寻找p开始的链表的真正最小值所在位置；3、找到位置与p不同：交换p和真正最小值所在的结点值；4、p遍历链表的下一个结点，重复2；直到遍历完成。5、Lhead升序整理完毕。;逐个向空链表有序插入的方法也适用于数组排序，可以改为向一个空数组有序插入待排序元素，即从下标0开始寻找第一个比插入元素大的元素的位置，然后放在这个元素之前。没有更大的元素则放在末尾。但是会比链表做的慢，因为插入位置需要其他元素移动腾空。假设有单项链表L1，L2分别用于模拟两个集合A,B的存放,现在要构建一个AB的并集C，并且C为升序排列集合，使用单向链表L3存放。A，B，C均为无重复元素的集合。那么下列工作序列描述能满足要求的是：

答案:1、构建空L3；2、从头开始遍历L1，将遍历到的结点从L1中摘除，并按升序插入的方式依次添加到L3。寻找合适的插入位置是寻找第一个大于待插入结点值的结点；找到则插入到该结点前面，否则追加到L3表尾；将L1置空。3、从头开始遍历L2，将遍历到的结点从L2中摘除，并按升序插入的方式依次添加到L3。寻找合适的插入位置是先寻找第一个不小于待插入结点值的结点；找到则判断该节点值是否与待插入结点值相等，是则删除L2中的对应结点，否则插入到找到的结点前面；若找不到则追加到L3表尾；将L2置空。4、L3求解完毕。;1、构建带哨兵的L3；1、对L1进行升序整理2、对L2进行升序整理3、p1是L1表首结点，p2是L2表首结点，若L1，L2均不空，则重复比较p1和p2的结点值：

1）若p1的<p2的，那么将p1的结点从L1中摘除添加到L3表尾，更新L1，p1；

2）若p1的>p2的，那么将p2的结点从L2中摘除添加到L3表尾，更新L2，p2;

3）若p1的==p2的，那么将p2的结点从L1中摘除添加到L3表尾，删除p1的结点，更新L1，p1,L2，p2。4、若L1为空，则将L2所有结点追加到L3的表尾；将L2置空。5、若L2为空，则将L1所有结点追加到L3的表尾；将L1置空。6、删除L3的哨兵，L3求解完毕。;1、构建空L3；2、L3接管L1（L3=L1），将L1置空。3、从头开始遍历L2。每遍历到一个结点，进行以下工作：

1）将结点从L2中摘除，更新L2；

2）查验摘除结点的值是否已经存在L3中：存在则删除这个从L2摘下的点；不存在则将该点添加到L3的表首；4、对L3进行升序整理。5、L3求解完毕。假设有单向链表Lhead，结点类型为node,数据类型为dataType,现在有删除表中value值结点的代码：node*pre=nullptr,*p=Lhead;while(p&&p->data!=value){pre=p;p=p->next;}if(p){

if(pre)

pre->next=p->next;

elseLhead=p->next;

deletep;}下列说法正确的是：

答案:若要将该功能设计成函数，则可能的设计如下：node*

deleteValue(node*head,dataTypevalue){

node*pre=nullptr,*p=head;

while(p&&p->data!=value){pre=p;p=p->next;}

if(p){

if(pre)

pre->next=p->next;

elsehead=p->next;

deletep;

}

returnhead;}调用形式为Lhead=deleteValue(Lhead,x);//假设x为dataType类型的变量;若要将该功能设计成函数，则可能的设计如下：void

deleteValue(node*&head,dataTypevalue){

node*pre=nullptr,*p=head;

while(p&&p->data!=value){pre=p;p=p->next;}

if(p){

if(pre)

pre->next=p->next;

elsehead=p->next;

deletep;

}}调用形式为deleteValue(Lhead,x);//假设x为dataType类型的变量;若要将该功能设计成函数，则可能的设计如下：void

deleteValue(node**head,dataTypevalue){

node*pre=nullptr,*p=*head;

while(p&&p->data!=value){pre=p;p=p->next;}

if(p){

if(pre)

pre->next=p->next;

else*head=p->next;

deletep;

}}调用形式为deleteValue(&Lhead,x);//假设x为dataType类型的变量下列代码段能完成对链表Lhead的逆置工作的是：假设Lhead为链表的头指针，链表的结点类型为node,结点的数据类型为dataType，逆置后的链表仍然为Lhead。

答案:node*p=Lhead;Lhead=nullptr;while(p){

node*temp=p;

p=p->next;

temp->next=Lhead;

Lhead=temp;};node*other=nullptr;node*p=Lhead;whiel(Lhead){

Lhead=Lhead->next;

p->next=other;

other=p;

p=Lhead;}Lhead=other;;node*other=newnode,othertail=other;

othertail->next=nullptr;node*tail1,*tail2;while(Lhead){

for(tail2=nullptr,tail1=Lhead;tail1->next;tail2=tail1,tail1=tail1->next);

othertail->next=tail1;

othertail=tail1;

if(tail2)

tail2->next=nullptr;

elseLhead=nullptr;}Lhead=other->next;deleteother;对于链表删除某一个值和删除某一个特定位置的结点的描述正确的是：

答案:删除值需要先查找到该值所在的位置，然后再进行相应结点的删除处理；;删除某个特定位置的结点可以不必要知道结点中的值，只要做对应结点的删除处理。;对与删除某个特定值或者某个特定位置结点，只要这个值或者位置不是表首，那么我们都需要知道该值或者位置的前驱结点才可以做相应的删除动作。对代码段：node*pre=nullptr，*p=head;while(p&&p->next){pre=p;p=p->next;}描述正确的是

答案:当链表为空表时，该代码也不会出错;该代码的目标是定位p是链表的表尾结点，同时保存链表的倒数第二个结点。;该代码可能的情况有：链表为空，那么p也是空；链表只有一个结点，那么p就是这个结点。链表有两个结点，那么pre是表首结点。链表有两个以上的结点，那么p是表尾结点。下列能将value值从集合中删除的正确代码段是：（假设集合中最多包含一个value值）

答案:node*pos=head,*pre=nullptr;while(pos&&pos->data!=value){pre=pos;pos=pos->next;}if(pos){

if(pre==nullptr)

head=pos->next;

else

pre->next=pos->next;

deletepos;}假设数组和链表的已知如课程所示，那么下列代码可以实现往升序集合中添加最小元素value的是：

答案:node*p=head;if(head){

head=newnode;

head->data=value;

head->next=p;

}else{

head=newnode;

head->data=value;

head->next=nullptr;};node*Nnode=newnode;Nnode->data=value;Nnode->next=nullptr;node*p=head,*pre=nullptr;while(p&&p->datanext;

}if(pre){

pre->next=Nnode;Nnode->next=p;

}else{

Nnode->next=p;

head=Nnode;

}下列对数组和链表工作描述正确的是：

答案:对于数组表达的数据集合，最快向集合中添加元素的方法是添加在数据集的尾部；对于链表表达的数据集合，最快向集合中添加元素的方法是添加在数据集的头部；;若数组中的数据集是升序，那么向该数据集添加元素最差的情况是添加最小元素；若链表中的数据集是升序，那么向该数据集添加最小元素是最好的情况；;已知一个包含value值的集合分别用数组和链表存储，那么从数组中删除value比从链表中删除value麻烦，因为要涉及元素的移动。给定以head指示的链表，有下列对链表内值value的查找代码：node*pre=nullptr,p=head;while(p&&p->data!=value){pre=p;p=p->next；}针对代码执行后pre和p的描述正确的是：

答案:若p为空，且pre为空，表示链表为空;若p不为空，表示p->data就是value，且pre不为空则表示p不是链表的头结点。有数组inta[5]={1,2,3,4,5};下列代码建立的链表能让链表从表头head开始访问的输出结果为5,4,3,2,1的是：

答案:node*head=newnode,*p;inti=0;head->data=a[i];head->next=nullptr;while(i<4){

i++;

p=newnode;

p->data=a[i];

p->next=head;

head=p;};node*head=nullptr,*p;inti=0;while(i<5){

p=newnode;

p->data=a[i];p->next=head;

head=p;

i++;};node*head,*p=nullptr;inti=0;while(i<5){

head=newnode;

head->data=a[i];head->next=p;

p=head;

i++;}在单向链表中，head是表首，有定义：node*p=head->next;那么描述表的第三个结点的地址的是：

答案:head->next->next;p->next;下列对单向链表描述正确的是：

答案:链表和数组一样均可以用于批量数据的存储和处理;由于链表采用的是化整为零的策略，因此，在将刚好存放10个元素的链表或者数组，调整空间以适应12个元素的存储的要求下，链表比数组容易。模板类实例化是通过在声明对象时使用类名后加尖括号内指定具体的类型来实例化的，这个具体的类型不可以是模板类。即如：compare>这样的描述是不被允许的

答案:错如果一个类称为模板类，那么该类的所有成员函数自动的称为模板函数。类属参数必须出现在他们的形参类型描述中。

答案:错模板类定义的类属参数，可以使用在：

答案:类的数据成员的类型描述中;类的成员函数的返回类型描述中;类的成员函数的形参类型描述中下类对类型转换的实际应用描述正确的是：

答案:complexa;doubleb=2.3;a=b;这样的赋值可以工作的前提是在complex类内有构造函数：complex(doublex){real=x;image=0;};complexa(2,3);doubleb;b=a;这样的赋值可以工作的前提是在complex类内有类型转换函数：operatordouble(){

returnreal+image;};若在complex类内定义的类型转换函数如下：explicitoperatordouble(){

returnreal+image;}那么，complexa(2,3);doubleb;b=a;这样的赋值就不能工作。因为隐式类型转换被限制。下列对类类型转换描述正确的是：

答案:自定义的类类型A需要转换成其他类型，必须要在A的定义中添加一个类型转换的成员函数。;由于类型转换的成员函数定义时没有参数，所以该转换函数就没有重载形式，就是不能为类型定义两个相同的转换描述。比如在complex中写两个double型的转换函数是不可能的。;可以为自定义类型A定义多个类型转换函数来实现A向多个类型的转换。在--运算符重载中，带参的形式是后置运算形式重载，它的效率比前置的运算形式要好。

答案:错为vector重载的下标运算也可以这样实现vector声明参考课内）：intgarbage=INT_MAX;int&vector::operator[](unsignedindex){

if(index<0||index>=maxsize)returngarbage;

intresult(table[index]);

returnresult;}

答案:错下列对运算符的重载描述正确的是：

答案:赋值重载是类机制中唯一一个会缺省给与的运算符重载。它一定是类内的成员。;如果要为自定义类A设计下标运算符[]的重载，那么这个重载函数的返回类型可以根据使用的需要可以设计为void,A或者A&下列为复数类complex（complex的类声明参考课程）设计加运算，能完成3个complex对象的求和，如：complexa(3,4),b(2,4),c;可行的设想有：

答案:为complex设计类外函数operator+,并在complex中添加该函数的友元声明，函数实现为：

complexoperator+(complex

a,complexb){

complexresult(a.real+b.real,a.image+b.image);

returnresult;}使用形式：a+b+c;;为complex设计类外函数add,并在complex中添加该函数的友元声明，函数实现为：complexadd(constcomplex&a,constcomplex&b,constcomplex&c){

complexresult(a);

result.real+=b.real+c.real;

result.image+=b.image+c.image;

returnresult;}使用形式：add(a,b,c);下列运算符允许重载的有：

答案:+;++;[]友元不能传递的意思是指，如果在类型A中声明friendclassB;且在类型B中声明friendclassC；不等价于在A中声明friendclassC；

答案:对友元不是双向的，表示如果在类型A中声明了friendclassB；那么在类型B中就不能声明friendclass

A；

答案:错对于下列类型A来说：classA{public:

A(intvx):x(vx){

}

voidsetx(intvx){x=vx;}private:

intx;};只要在类B中添加声明friendclassA;

那么类B中的成员函数f就可以访问类型A对象的私有数据成员。

答案:错对于下列类型A来说：classA{public:

A(intvx):x(vx){

}

voidsetx(intvx){x=vx;}private:

intx;};由于没有给出访问其私有数据成员x的公有接口，所以定义在类以外的普通函数f无法访问类型A对象的私有数据成员，除非将这个函数f声明为A的友元函数。

答案:对classA{

public:

staticintf(){returnx;}private:

staticintx;};那么在主函数中，可以这样使用：intA::x=4;intmain(){

cout<答案:错类的静态成员函数可以读写类的任何数据成员，包括const数据成员，非const数据成员，非static数据成员，static数据成员。

答案:错static限定的数据成员若放在privte访问控制后，那么在main函数中也可以通过

类型：：这样的类域限定来访问该数据成员。

答案:错static可以用于修饰类的数据成员和类的成员函数

答案:对有定义classA{public：

A(intvx)：x（vx）{

}

intgetx(){returnx;}private:

intx;};下列用来保护对象数据的策略正确的是：

答案:将数据成员x限定为const以保证A的所有对象的数据都不被修改;定义A的实例对象的时候，定义constA这样的常对象就可以保护该对象的数据不被修改。;constA&或者constA*都可以设计为函数的形参类型以保护形参关联的A对象不会被函数修改。有以下定义：classA{public：

A(intvx){x=vx;}

voidf(intvx){x=vx;}

intgetx(){returnx;}private:

intx;};要为类型A设计类外的一个无返回值的函数fun,用于接收一个A类型的对象，如intmain(){

A

obj(3);

fun(obj);

return0;}先要求约束fun不能对obj的值做修改，那么下列可行的办法是

答案:声明obj时，声明为constAobj(3);就可以了。;将fun的形参设计为A就可以了，如void

fun（A

objx）;有以下定义：classA{public：

A(intvx){x=vx;}

intgetx(){returnx;}private:

intx;};那么下列用法错误的是:

答案:constAobj（3）；A&ra=obj；;Aobj(3);A*pa=&obj;constA*&rpa=pa;cout<<rpa->getx();下列对const在类A中的说法正确的是：classA{public:

A(intvx):x(vx){

}

intgetx(){returnx;}private:

intx;}

答案:可以使用const限定的类的数据成员x，称为常数据成员;可以使用const限定类的成员函数getx，称为常成员函数;可以使用const限定类型的声明，定义常对象，如：constAobj(3);;可以使用const限定指针的声明，定义常对象的指针，如：constA*

ptr；下列对于类内赋值重载运算的说法正确的是：

答案:若一个类的数据成员没有涉及动态申请的空间，那么哪怕这个类的数据成员有指针类型，缺省的赋值重载函数也足够使用了。;一个设定返回类型为类型引用的赋值重载运算，可以正确处理a=(b=c)和(a=b)=c这样的复合运算，也可以处理自赋值的情形。对于如下定义的类AclassA{}；下列说法正确的是：

答案:可以按如下方式声明这个类的对象obj;A

obj;因为系统会提供缺省的无参构造函数来实例化对象obj;可以按如下方式声明这个类的对象other;A

obj,other(obj);因为系统会提供缺省的拷贝构造函数来实例化对象other有以下类型的定义：classA{public：

A（intvx=0）：x(vx){

}

intgetx()const{returnx;}private:

intx;};并且有对象声明：A

a(3),b(4)，c;能完成以下执行语句，且保证b、c数据保持一致的赋值重载是：(c=a)=b;

答案:A&

A::operator=(constA&right){

x=right.x;

return*this;}下列对于类内的赋值运算成员函数说法错误的是：

答案:若有以下Box类的对象定义，那么Boxa(20,30,40)，b（a）;这里的对象b是采用拷贝构造实例化的;而使用Box

a(20,30,40),b=a;这里的对象b是使用赋值重载函数实例化的。阅读下列程序，写运行结果classFOO{public:

FOO();

FOO(constFOO&);

~FOO();};FOO::FOO(){cout<<"constructor"<答案:constructorconstructorcopyconstructordestructordestructordestructor阅读下列程序，写运行结果：#includeusingnamespacestd;

classFOO{public:

FOO(int);

FOO(constFOO&);

~FOO();

intget();private:

int*pointer;};FOO::FOO(inti){cout<<"constructor"<答案:constructorcopyconstructorcopyconstructor15destructordestructordestructor读下列程序写运行结果,请从程序中拷贝内容填写：#includeusingnamespacestd;

constunsignedlongMEGA_BYTE=(unsignedlong)1024*1024;classcomputer{public:

computer(unsignedlongmem,unsignedlonghd,intcd){

memory=mem;

hard_disk=hd;

cdrom=cd;

if(memory>(unsignedlong)16*MEGA_BYTE){

cout<<"你至少可以安装windows95及以上的操作系统!\n";

}else{

cout<<"你只能安装windows3.2的操作系统!\n";

}

if(hard_disk>(unsignedlong)800*MEGA_BYTE){

cout<<"你可以安装VisualC++!\n";

}else{

cout<<"你只能安装BorlandC++!\n";

}

if(cdrom>4)

cout<<"你可以看VCD!\n";

elsecout<<"你只能听CD!\n";}~computer(){

cout<<"你应该好好利用你的电脑!\n";}private:

unsignedlongmemory;

unsignedlonghard_disk;

unsignedlongcdrom;};

intmain(){

computermy_computer(32*MEGA_BYTE,1024*MEGA_BYTE,8);

cout<<"我有一台电脑!\n";

return0;}

答案:你至少可以安装windows95及以上的操作系统!你可以安装VisualC++!你可以看VCD!我有一台电脑!你应该好好利用你的电脑!拷贝构造函数的参数的类型必须设计为类的引用。

答案:对拷贝构造函数因为拷贝构造函数有参数，所以也可以为拷贝构造函数的参数指定默认参数值。

答案:对有类定义如下：classA{public:

A(intvx=0):value(vx){

}private:

intvalue;};那么在主函数中：A*p=newA[3]{A(9)};实际只申请了一个A类型的对象空间，所以使用delete

p;来回收空间是正确的。

答案:错若一个类的定义如下：classA{public:

A(intvx):value(vx){

}private:

intvalue;};那么在主函数中：A

obj[3]={A(3)};这样的声明是错误的。

答案:对每个对象都有一个this指针，对象使用类的接口实际是通过this指针来调用的。

答案:对若一个类中的数据成员a是整型指针，且在构造时使用a去申请了一个动态的数组空间，如果这个类的其他操作接口没有做该动态空间的回收，那么我们应该定制这个类的析构函数以便去释放这个动态的数组空间。

答案:对一个类可以有多个构造函数，却只能有一个析构函数的原因是析构函数不能设计参数，因此不允许重载。

答案:对析构函数和构造函数一样，不能指定返回类型。与构造不同，析构的使用表示对象声明的终结，因此在析构函数内放return是错误的，一个消失的对象不需要再回到程序中。

答案:错系统会为没有写析构函数的类提供缺省的析构函数，缺省析构函数的函数体为空。

答案:对析构函数的函数名和构造函数一样，也是使用了类定义的标识符，那么析构函数实际上是构造函数的重载形式。

答案:错有类定义如下：classA{public:A(int&a){x=&a;cout<答案:构造函数可以输出初始化值的地址;可以为这个类添加一个修改类外数据的操作，如：voidmod(){*x=6;}表示将该类的对象关联的外部数据修改为6;这个类一个可能的使用为：intage=16;A

obj(age);这是一个合理的类A对象的定义形式。有类定义：class

A{public:intgetx()const{returnvx;}intgety(){returnvy;}private:intvx,vy;};那么下列构造函数可以在这个类中正常工作的是：

答案:A(intvx,intvy):vx(vx),vy(vy){

};A(intx=0,inty=0):vx(x),vy(y){

};A(){

vx=2;

vy=3;return;

}下列对构造函数说法正确的是：

答案:构造函数的函数名必须和它的类名一样;构造函数可以有参数，也可以没有，根据对象的实例化需要而定有类定义：class

x{public:intgetx()const{returnvx;}intgety(){returnvy;}voidset(intx,inty):vx(x),vy(y){

}private:intvx,vy;};下列说法正确的是：

答案:这个类中，成员函数set对数据成员的值设置使用了初始化列表，这是错误的。下列对构造函数说法错误的是：

答案:构造函数不允许有返回值。那么我们在设计构造函数时，可以将它的返回类型设计为void。对于类的数据成员，我们可以叫它们：属性、特征，也可以叫它们：操作、行为。

答案:错若我们在程序中定义了一个游泳池类pool,但是没有声明游泳类实例，那么程序也会为pool类分配空间。

答案:错若我们定义了以下类型：class

A{public:

voidset_x(intval){x=val;}

intget_x(){returnx；}private:

intx;};那么下面说法正确的是：

答案:我们可以在主函数中声明A的数组,并配合有以下的使用，如：A

a[3];a[1].set_x(3);

;我们可以在主函数中声明A的指针，并配合有以下的使用，如：A

*pa=newA;pa->set_x(3);下列声明有语法错误的是：

答案:classPOINT{

public:

intget_x();

intget_y();private:

intx,y;};classLINE{

public:

intdraw();

intis_on_line(intx,inty);

private:

intstart_x=0,start_y=0;

intend_x,end_y;

};在C++的自定义类型机制中，使用class和使用struct关键字定义的类型我们都称为类类型。

答案:错一个类库构成包括类的声明和类的实现（类的成员函数的实现）

答案:对有以下声明：classA{public:voidfx()const;voidfy();private:intx,y;};那么下列用法没有语法错误的是：

答案:voidA::fy(){

x=3;

y=4;}下列对于类的访问控制描述错误的是：

答案:类的成员函数有特殊的访问控制字const下面对类的数据成员声明的描述，错误的是：

答案:类的数据成员在声明时若使用const指定为常量，那么必须在声明时初始化；//比如要把5个国家的名字放一起,金砖5国BRICS//Brazil,Russia,India,China,SouthAfrica//放在一起构建一个字符串集合dd，采用下列声明：char(*dd)[12];

请结合前面学过的知识，写一个表达式完成字符串集dd的构建。

答案:dd=newchar[5][12]{"Brazil","Russia","India","China","SouthAfrica"};在一个可能包含10个字符串的集合的使用需求下，下列存储设计均能满足该使用需求的是(假设集合中最长的字符串为“information”)：

答案:chara[10][20];;char*pa[10];for(inti=0;i<10;i++)

pa[i]=newchar[12];;chara[200];若需要我们为C风格的字符串写一个拷贝函数，则在声明：char

s[20];chart[20]="MynameisJack."；和使用输出语句：cout<答案:char*strcpy(chars1[],chars2[]);;char*strcpy(char*s1,char*s2);;char*strcpy(char*s1,constchar*s2);下列描述错误的是：

答案:对于C风格的字符串，我们可以实现字符串引用的概念。如：chara[]="ABCD"char*&ra=a;下列对于扩展类型string说法错误的是：

答案:string型数据使用自己的getline()接口来获得包含分隔符的输入。下列字符数组a,被初始化为字符串成功：使用cout<答案:chara[]={65,66,67,68,0,9};;chara[4]={'a','b','c'};;chara[5]={'a','\0',0x44,'b','c'};在声明：char

a[]="mynameisJennie.";constchar*pa=a;前提下，下列语句哪个是有语法错误的？

答案:*(pa+11)='F';有字符串缓存：chara[100];则下列想要读入"helloworld"内容的输入哪个是错误的？

答案:cin>>a;下列字符串a初始化方式错误的是：

答案:constchart[]="interesting";chara[]=t;有以下声明：chara[5]={'W','O','R','L','D'};charb[6]={'W','O','R','L','D'};shortc[5]={0x4142,0x4344,0x4546,0x4748};则下列说法错误的是：

答案:由于a不是字符串，因此cout<有声明:chara[5]={65,'a','b','c','0'};则下列说法正确的是：

答案:使用语句：a[3]=0;cout<有声明：chara[10]={0x48,0x41,'d','\0','h','i',0,'k','p','q'};下列输出操作可能显示乱码的是：

答案:cout<<(a+7)<有声明：chara[10]={0x48,0x41,'d','\0','h'};下列操作可以显示数组a所有内容的是：

答案:for(inti=0;i<10;i++)cout<有函数定义如下：1)

intf(inta=0,intb=0){

cout<

T

f(T

x,Ty){

cout<答案:如有函数调用：f();

则调用的是1）版本;如有函数调用f(3);则调用的是1）版本;如有函数调用f(3.6);则调用的是1)版本;如有函数调用f('a','b');则调用的是2)版本下列函数组，哪个不符合函数重载的要求？

答案:typedef

intFLOAT;int

f(int);FLOAT

f(FLOAT);;intf(int&);unsignedf(int&);下列对于模板函数的说法，错误的是：

答案:模板函数的形参类型可以不使用模板参数使用了哪个关键字可以看出来应用了模板机制：

答案:template有如下主函数描述：intmain(){

intp=2;

//ff(?)=3;函数ff调用

cout<答案:int&ff(int*x){

return*x;}调用ff(&p)=3;;int&ff(int&x){

returnx;}调用ff(p)=3;有如下主函数描述：intmain(){

int*p;

p=ff();

cout<<*p<答案:int*ff(){

int*x=newint(2);

returnx;}

;inta;int*ff(){

a=2;

return&a;}下列程序段的输出结果是：inta=5;intf();intmain();{

for(inti=1;i<=3;i++)

cout<答案:234下列对于函数返回值的说法错误的是：

答案:函数如果需要计算3个整型结果返回给调用方，可选的策略是返回一个数组，可能的原型描述为：int[3]

f();关于设计安全的参数（不能通过形参修改调用方的值），以下考虑正确的是：

答案:设计数组类型的参数时，为防止误改调用方的值，可以使用const限定参数：如：voidf(constint

a[]){

。。。。。。};设计指针类型参数时，为防止误改调用方的值，可以使用const限定参数：如：voidf(constint*a){

......};设计引用类型参数时，为防止误修改调用方值，可以使用const限定参数：如：voidf(constint&a){

......}有以下数组声明：inta[10]={1,2,3,4,5,6,7,8,9,10};intb[2][5]={{2,4,6,8,10},{12,14,16,18,20}};有以下求和的函数定义：intf(intx[],intsize){

intresult=0;

for(inti=0;i答案:f(b[1],5);;g(&b[1],1,5);有以下数组声明：inta[10]={1,2,3,4,5,6,7,8,9,10};intb[2][5]={{2,4,6,8,10},{12,14,16,18,20}};有以下求和的函数定义：intf(intx[],intsize){

intresult=0;

for(inti=0;i答案:f(