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