C++笔试题目带答案.docx
《C++笔试题目带答案.docx》由会员分享，可在线阅读，更多相关《C++笔试题目带答案.docx（21页珍藏版）》请在冰点文库上搜索。
C++笔试题目带答案
姓名:
___________时间:
___________
DCCBBAADAD
一、选择题（1*10=10）
1．如果派生类以proctected方式继承基类，则原基类的protected和public成员在派生类的访问性分别是：
D
A．public和publicB．public和protected
C．protected和publicD．protected和protected
解析：
通过protected方式继承基类后，原基类的私有成员不可访问，而protected和public成员均变成protected成员。
答案：
D
2．有如下头文件：
intF1（）;
staticintF2（）;
classsCA
{
public:
intF3（）;
staticintF4（）;
};
在所描述的函数中，具有隐含this指针的是：
C
A．F1B．F2
C．F3D．F4
本题考查的是this指针。
this指针式一个隐含的指针，它隐含于每个类的非静态成员函数中，它明确地表示出了成员函数当前操作的数据所属的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋值给this指针，然后调用成员函数，每次成员函数存取数据成员时，则隐含使用this指针。
this指针是指向对象本身的指针，它只存在于类的非静态成员中。
f1，f2不是成员函数，不存在隐含指针；f4为静态成员函数，也不含有this指针；含有this指针的函数在调用时按thiscall调用约定调用。
故本题答案为C。
3．派生类的成员函数不能访问基类的：
C
A．共有成员和保护成员B．共有成员
C．私有成员D．保护成员
本题考查的是继承的类型。
类的继承方式有公有继承、保护继承和私有继承三种方式。
对于公有继承基类中的成员访问属性不变，对于保护和私有继承基类中的成员转换为相应的访问类型。
但是如果基类成员的访问属性为private的，则不能被继承。
故本题答案为C。
4．按照“后进先出”原则组织数据的数据结构是B
A．队列B．栈
C．双向链表D．二叉树
答案为B。
5．下列关于虚函数的说明中，正确的是：
B
A．从虚基类继承的函数都是虚函数B．虚函数不得是静态成员函数
C．只能通过指针或者引用调用虚函数D．抽象类中的中的成员函数都是虚函数。
答案为B。
6．已知Value是个类，value是Value的一个对象。
下列以非成员函数形式重载的运算符函数原型中，正确的是：
A
A．Valueoperator+（Valuev,inti）;B．Valueoperator+（Valuev=value,inti）;
C．Valueoperator+（Valuev,int=0）;D．Valueoperator+（Valuev=value,inti=0）;
7．有如下类的定义：
ClassMyClass
{
intvalue;
public:
MyClass（intn）:
value（n）{}
intgetValue（）const{returnvalue;}
};
则类Myclass的构造函数的个数是：
A
A．1个B．2个
C．3个D．4个
还有默认拷贝构造函数,应该选B
8．有如下类的定义：
classConstants
{
public:
staticdoubleGetPI（void）{return3.14159;}
};
Constantsconstants;
下列各组语句中，能输出3.14159的是：
B
A．cout<GetPI（）;和cout<:
GetPI（）;
B．cout<C．cout<GetPI（）;和cout<GetPI（）;
D．cout<:
GetPI（）;
9．有如下程序：
#include
usingnamespacestd;
classVAC
{
public:
intf（）const{return3;}
intf（）{return5;}
};
intmain（）
{
VACv1;
constVACv2;
cout<return0;
}
运行时的输出结果是：
A
A．53B．35
C．55D．33
10．有如下类声明：
classBase
{
protected:
intamount;
public:
Base（intn=0）:
amount（n）{}
intgetAmount（）const{returnamount;}
};
classDerived:
publicBase
{
protected:
intvalue;
public:
Derived（intm,intn）:
value（m）,Base（n）{}
intgetData（）const{returnvalue+amount;}
};
已知x是一个Derived对象，则下列表达式中正确的是：
B
A．x.value+x.getAmount（）;B．x.getData（）+x.getAmount（）;
C．x.getData（）–x.amount;D．x.value+x.amount;
二、填空题（8*2=16）
400_64444return*this_DogspeakVoice
1.下列中a的值是___400_____
#defineAAA200
#defineBBBAAA+100
inta=BBB*2
2.以下为WindowsNT下的32位C++程序，请计算sizeof的值。
charstr[]=“Hello”;
char*p=str;
intn=10;
请计算
sizeof（str）=____5_____
sizeof（p）=____4___
sizeof（n）=____4____
voidFunc（charstr[100]）
{
//请计算
sizeof（str）=___4______
}
void*p=malloc（100）;
//请计算
sizeof（p）=_____4____
3.补充完整下面的类定义：
classXCH{
char*a;
public:
XCH（char*aa）{//构造函数
a=newchar[strlen（aa）+1];
strcpy（a,aa）;
}
XCH&operator=（constXCH&x）{//重载赋值函数
delete[]a;
a=newchar[strlen（x.a）+1];
strcpy（a,x.a）;
______;
}
~XCH（）{delete[]a;}
};
____return*this______________
______________________________________________________
4.请写出下面程序的输出结果
#include
usingnamespacestd;
classAnimal{
public:
virtualchar*getType（）const{return"Animal";}
virtualchar*getVoice（）const{return"Voice";}
};
classDog:
publicAnimal{
public:
char*getType（）const{return"Dog";}
char*getVoice（）const{return"Woof";}
};
voidtype（Animal&a）{cout<voidspeak（Animala）{cout<intmain（）{
Dogd;type（d）;cout<<"speak";speak（d）;cout<return0;
}
______DogspeakVoice____________
__________________
三、问答题（5*10+9+15=74）
1.编写类String的拷贝构造函数和赋值函数（可以调用C++/C的字符串库函数）（15）。
已知类String的原型为：
classString
{
public:
String（constchar*str=NULL）;//普通构造函数
String（constString&other）;//拷贝构造函数
~String（void）;//析构函数
String&operate=（constString&other）;//赋值函数
private:
char*m_data;//用于保存字符串
};
请编写String的上述4个函数。
//String的析构函数
String:
:
~String（void）//3分
{
delete[]m_data;
//由于m_data是内部数据类型，也可以写成deletem_data;
}
//String的普通构造函数
String:
:
String（constchar*str）//6分
{
if（str==NULL）
{
m_data=newchar[1];//若能加NULL判断则更好
*m_data=‘\0’;
}
else
{
intlength=strlen（str）;
m_data=newchar[length+1];//若能加NULL判断则更好
strcpy（m_data,str）;
}
}
//拷贝构造函数
String:
:
String（constString&other）//3分
{
intlength=strlen（other.m_data）;
m_data=newchar[length+1];//若能加NULL判断则更好
strcpy（m_data,other.m_data）;
}
//赋值函数
String&String:
:
operate=（constString&other）//13分
{
//
（1）检查自赋值//4分
if（this==&other）
return*this;
//
（2）释放原有的内存资源//3分
delete[]m_data;
//（3）分配新的内存资源，并复制内容//3分
intlength=strlen（other.m_data）;
m_data=newchar[length+1];//若能加NULL判断则更好
strcpy（m_data,other.m_data）;
//（4）返回本对象的引用//3分
return*this;
}
2．不调用C++/C的字符串库函数，请编写函数strcmp的实现（10）。
3．
intstrcmp（constchar*src,constchar*dst）
char*strcpy（char*strDest,constchar*strSrc）
{
char*address=strDest;
while（*strDest++=*strSrc++）
NULL;
returnaddress;
}
4．F（n）=F（n-1）+F（n-2）,F（0）=1,F
（1）=1.分别用递归和循环求F（5）（10）。
5．
publicintR（intnum）{
if（num<=0）{
num=1;
}elseif（num==1）{
num=1;
}else{
num=R（num-1）+R（num-2）;
}
returnnum;
}
publicintc（intnum）{
inta=1;
intb=1;
intc=0;
for（inti=0;ic=a+b;
a=b;
b=c;
}
returnc;
}
6．写一算法，对单链表实现就地逆置（不要构造新结点）（10）。
7．
node*reserve（node*head）
{
node*p1,*p2,*p3;
if（（head==NULL）||（head->next==NULL））
returnhead;
p1=head;
p2=p1->next;
while（p2!
=NULL）
{
p3=p2->next;
p2->next=p1;
p1=p2;
p2=p3;
}
head->next=NULL;
p1=head;
returnhead;
}
8．从冒泡排序、直接插入排序、二分插入排序和选择排序四种排序算法中，选择其中一种算法，写出它的实现？
（10）
9．
#include
#include
#include
#include
voidBubbleSort（int*L,intN）
{//冒泡
inti,j;
intt;
for（i=1;i<=N;i++）
{
for（j=N;j>i;j--）
if（L[j]{
t=L[j];
L[j]=L[j-1];
L[j-1]=t;
}
}
}
intSelectMinKey（int*L,intN,intn）
{
inti,min=n;
for（i=n+1;i<=N;i++）
if（L[i]min=i;
returnmin;
}
voidSelectSort（int*L,intN）
{//选择
inti,j;
intt;
for（i=1;i{
j=SelectMinKey（L,N,i）;
if（i!
=j）
{
t=L[i];
L[i]=L[j];
L[j]=t;
}
}
}
voidInsertSort（int*L,intN）
{//插入
inti,j;
for（i=2;i<=N;i++）
{
if（L[i]{
L[0]=L[i];
L[i]=L[i-1];
for（j=i-2;L[0]L[j+1]=L[j];
L[j+1]=L[0];
}
}
}
voidShellInsert（int*L,intN,intdk）
{//对顺序表L作一趟希尔插入排序。
本算法对算法10.1作了以下修改：
//1.前后记录位置的增量是dk，而不是1；
//2.r[0]只是暂存单元，不是哨兵。
当j<=0时，插入位置已找到。
inti,j;
for（i=dk+1;i<=N;++i）
if（L[i]{//需将L.r[i]插入有序增量子表
L[0]=L[i];//暂存在L.r[0]
for（j=i-dk;（j>0&&L[0]L[j+dk]=L[j];//记录后移，查找插入位置
L[j+dk]=L[0];//插入
}
}//ShellInsert
voidShellSt（int*L,intN,intdlta[],intt）
{//算法10.5
//按增量序列dlta[0..t-1]对顺序表L作希尔排序。
for（intk=0;kShellInsert（L,N,dlta[k]）;//一趟增量为dlta[k]的插入排序
}//ShellSort
voidShellSort（int*L,intN）
{//希尔
intt=（int）log（N）;
intk,*dlta;
dlta=（int*）malloc（t*4）;//产生增量序列
for（k=0;kdlta[k]=（int）pow（2,t-k）-1;
ShellSt（L,N,dlta,t）;
}
intmain（）
{
intN=250;
inti,j,k;
intt;
intti[16];
int*L;
srand（time（NULL））;
printf（"长度\t|冒泡\t|选择\t|插入\t|希尔\n"）;
printf（"--------+-------------------------------------------------------------"）;
for（j=0;N<100000;j++）
{
L=（int*）malloc（（N+1）*4）;
t=0;
for（i=1;i<=N;i++）
L[i]=rand（）;
ti[t++]=clock（）;
BubbleSort（L,N）;
ti[t++]=clock（）;
for（i=1;i<=N;i++）
L[i]=rand（）;
ti[t++]=clock（）;
SelectSort（L,N）;
ti[t++]=clock（）;
for（i=1;i<=N;i++）
L[i]=rand（）;
ti[t++]=clock（）;
InsertSort（L,N）;
ti[t++]=clock（）;
for（i=1;i<=N;i++）
L[i]=rand（）;
ti[t++]=clock（）;
ShellSort（L,N）;
ti[t++]=clock（）;
printf（"\n%d\t",N）;
for（k=0;k<4;k++）
printf（"|%d\t",（ti[2*k+1]-ti[2*k]））;
N*=5;
}
printf（"\n\n"）;
}
10．一个类中，const类型成员函数的主要作用是什么？
在该函数中可以调用该类的什么类型的成员变量和成员函数？
该类的一个非const对象可以调用const成员函数吗？
（10）
11．
（1）可以定义const常量，具有不可变性。
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。
例如：
voidf（constinti）编译器就会知道i是一个常量，不允许修改；
（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。
同宏定义一样，可以做到不变则已，一变都变！
如
（1）中，如果想修改Max的内容，只需要：
constintMax=youwant;即可！
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。
还是上面的例子，如果在函数体内修改了i，编译器就会报错；例如：
voidf（constinti）
（5）为函数重载提供了一个参考。
classA{......
voidf（inti）//一个函数
voidf（inti）const//上一个函数的重载......
};
（6）可以节省空间，避免不必要的内存分配。
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7）提高了效率。
编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。
不能修改类的数据成员，不能在函数中调用其他不是const的函数.
1）const对象调用的是const成员函数。
2）非const成员函数可以调用const成员函数，这样做一般是用来避免代码重复，但引入了一个casting动作。
12．下面两个语句的执行效果相同吗？
为什么？
（9）
13．
语句1:
while（*p++）{};
语句2:
while（*p）{p++;}
区别在于退出循环后,p的值不一样
while（*p++）;//当*p=0时，退出循环，此时p++仍然执行了
while（*p）p++;//当*p=0时，退出循环，此时p++不再被执行
例如char*p="ABCD";执行完第一个while循环后，p指向的是'\0'后面的一个字节，*p的结果是未知的
而如果是执行第二个循环，则p指向的是'\0',也就是'D'后面的一字节，即*p='\0
升级会员 