C++笔试题目带答案.doc

C++笔试题目带答案

资料仅供参考
姓名:___________ 时间:___________
DCCBB AADAD
一、选择题(1*10=10)
1．如果派生类以proctected方式继承基类，则原基类的protected和public成员在派生类的访问性分别是：D
A．public和public B．public和protected
C．protected和public D．protected和protected
解析：经过protected方式继承基类后，原基类的私有成员不可访问，而protected和public成员均变成protected成员。
答案：D

2．有如下头文件：
int F1();
static int F2();
classs CA
{
public:
int F3();
static int F4();
};
在所描述的函数中，具有隐含this指针的是：C
A．F1 B．F2
C．F3 D．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．Value operator+(Value v, int i); B．Value operator+(Value v=value, int i);
C．Value operator+(Value v, int=0); D．Value operator+(Value v=value, int i=0);
7．有如下类的定义：
Class MyClass
{
int value;
public:
MyClass(int n):value(n){}
int getValue() const {return value;}
};
则类Myclass的构造函数的个数是：A
A．1个 B．2个
C．3个 D．4个
还有默认拷贝构造函数, 应该选B
8．有如下类的定义：
class Constants
{
public:
static double GetPI(void){return 3.14159;}
};
Constants constants;

下列各组语句中，能输出3.14159的是：B
A．cout<<constants->GetPI();和cout<<Constants::GetPI();
B．cout<<constants.GetPI();和cout<<Constants.GetPI();
C．cout<<constants->GetPI();和cout<<Constants->GetPI();
D．cout<<constants.GetPI();和cout<<Constants::GetPI();

9．有如下程序：
#include <iostream>
using namespace std;
class VAC
{
public:
int f() const{return 3;}
int f(){return 5;}
};
int main()
{
VAC v1;
const VAC v2;
cout<<v1.f()<<v2.f();
return 0;
}
运行时的输出结果是：A
A．53 B．35
C．55 D．33
10．有如下类声明：
class Base
{
protected:
int amount;
public:
Base(int n = 0):amount(n){}
int getAmount() const {return amount;}
};

class Derived:public Base
{
protected:
int value;
public:
Derived(int m, int n):value(m),Base(n){}
int getData() const {return value + amount;}
};
已知x是一个Derived对象，则下列表示式中正确的是：DB
A．x.value + x.getAmount(); B．x.getData() + x.getAmount();
C．x.getData() – x.amount; D．x.value + x.amount;

二、填空题(8*2=16)
400_ 6 4 4 4 4 return *this _ Dog speak Voice
1.下列中a的值是___400_____
#define AAA 200
#define BBB AAA+100
int a= BBB*2

2. 以下为Windows NT下的32位C++程序，请计算sizeof的值。
　　char str[] = “Hello” ;
char *p = str ;
int n = 10;

请计算
sizeof (str ) = ____5_____
sizeof ( p ) = ____4___
sizeof ( n ) = ____4____

void Func ( char str[100])
{
　 //请计算
　 sizeof( str ) =___4______

}

void *p = malloc( 100 );
//请计算
sizeof ( p ) =_____4____
3. 补充完整下面的类定义：
class XCH{
char* a;
public:
XCH(char* aa){ //构造函数
a=new char[strlen(aa)+1];
strcpy(a,aa);
}
XCH& operator=(const XCH& x){ //重载赋值函数
delete []a;
a=new char[strlen(x.a)+1];
strcpy(a,x.a);
______;
}
~XCH(){delete []a;}
};
____ return *this ______________
______________________________________________________

4. 请写出下面程序的输出结果
#include<iostream>
using namespace std;
class Animal {
public:
virtual char* getType() const {return "Animal";}
virtual char* getVoice() const {return "Voice";}
};
class Dog:public Animal{
public:
char* getType() const {return "Dog";}
char* getVoice() const { return "Woof";}
};
void type(Animal& a) {cout<<a.getType();}
void speak(Animal a) {cout<<a.getVoice();}
int main(){
Dog d;type(d);cout<<" speak ";speak(d);cout<<endl;
return 0;
}
______ Dog speak Voice ____________
__________________
三、问答题(5*10+9+15=74)
1.编写类String的拷贝构造函数和赋值函数(能够调用C++/C的字符串库函数)(15)。
已知类String的原型为：
class String
{
　public:
　　 String(const char *str = NULL); // 普通构造函数
　　 String(const String &other); // 拷贝构造函数
　　 ~ String(void); // 析构函数
　　 String & operate =(const String &other); // 赋值函数
private:
　　char *m_data; // 用于保存字符串
};

请编写String的上述4个函数。

// String的析构函数
String::~String(void) // 3分
{
delete [] m_data;
// 由于m_data是内部数据类型，也能够写成 delete m_data;
}

// String的普通构造函数
String::String(const char *str) // 6分
{
if(str==NULL)
{
m_data = new char[1]; // 若能加 NULL 判断则更好
*m_data = ‘\0’;
}
else
{
int length = strlen(str);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, str);
}
}
// 拷贝构造函数
String::String(const String &other) // 3分
{
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, other.m_data);
}
// 赋值函数
String & String::operate =(const String &other) // 13分
{
// (1) 检查自赋值 // 4分
if(this == &other)
return *this;

// (2) 释放原有的内存资源 // 3分
delete [] m_data;

// （3）分配新的内存资源，并复制内容 // 3分
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, other.m_data);

// （4）返回本对象的引用 // 3分
return *this;
}

2． 不调用C++/C的字符串库函数，请编写函数strcmp的实现(10)。
int strcmp ( const char * src, const char * dst )

char *strcpy(char *strDest, const char *strSrc)
{

char *address = strDest;
while (*strDest++ = * strSrc++)
NULL ;
return address ;
}

3． F(n)=F(n-1)+F(n-2),F(0)=1,F(1)=1.分别用递归和循环求F(5)(10)。

public int R(int num){
if(num<=0){
num=1;
}else if(num==1){
num=1;
}else{
num=R(num-1)+R(num-2);
}
return num;
}

public int c(int num) {
int a = 1;
int b = 1;
int c = 0;

for (int i = 0; i < num- 2; i++) {
c = a + b;
a = b;
b = c;
}
return c;
}

4． 写一算法，对单链表实现就地逆置(不要构造新结点)(10)。

node *reserve(node*head)
{
node*p1,*p2,*p3;
if((head==NULL)||(head->next==NULL))
return head;

p1=head;
p2=p1->next;
while(p2!=NULL)
{
p3=p2->next;
p2->next=p1;
p1=p2;
p2=p3;
}
head->next=NULL;
p1=head;
return head;
}

5． 从冒泡排序、直接插入排序、二分插入排序和选择排序四种排序算法中，选择其中一种算法，写出它的实现？(10)

#include<stdio.h>
#include<time.h>
#include<math.h>
#include<malloc.h>

void BubbleSort(int *L,int N)
{ //冒泡
int i,j;
int t;

for(i=1;i<=N;i++)
{
for(j=N;j>i;j--)
if(L[j]<L[j-1])
{
t=L[j];
L[j]=L[j-1];
L[j-1]=t;
}
}
}

int SelectMinKey(int *L,int N,int n)
{
int i,min=n;

for(i=n+1;i<=N;i++)
if(L[i]<L[min])
min=i;

return min;
}

void SelectSort(int *L,int N)
{ //选择
int i,j;
int t;

for(i=1;i<N;i++)
{
j=SelectMinKey(L,N,i);
if(i!=j)
{
t=L[i];
L[i]=L[j];
L[j]=t;
}
}
}

void InsertSort(int *L,int N)
{ //插入
int i,j;

for(i=2;i<=N;i++)
{
if(L[i]<L[i-1])
{
L[0]=L[i];
L[i]=L[i-1];
for(j=i-2;L[0]<L[j];j--)
L[j+1]=L[j];
L[j+1]=L[0];
}
}
}

void ShellInsert(int *L,int N, int dk)
{ // 对顺序表L作一趟希尔插入排序。本算法对算法10.1作了以下修改：
// 1. 前后记录位置的增量是dk，而不是1；
// 2. r[0]只是暂存单元，不是哨兵。当j<=0时，插入位置已找到。
int i,j;
for(i=dk+1;i<=N;++i)
if(L[i]<L[i-dk])
{ // 需将L.r[i]插入有序增量子表
L[0]=L[i]; // 暂存在L.r[0]
for(j=i-dk;(j>0&&L[0]<L[j]);j-=dk)
L[j+dk]=L[j]; // 记录后移，查找插入位置
L[j+dk]=L[0]; // 插入
}
} // ShellInsert

void ShellSt(int *L,int N, int dlta[], int t)
{ // 算法10.5
// 按增量序列dlta[0..t-1]对顺序表L作希尔排序。
for(int k=0;k<t;++k)
ShellInsert(L,N, dlta[k]); // 一趟增量为dlta[k]的插入排序
} // ShellSort

void ShellSort(int *L,int N)
{ //希尔
int t=(int)log(N);
int k,*dlta;

dlta=(int*)malloc(t*4); //产生增量序列
for(k=0;k<t;k++)
dlta[k]=(int)pow(2,t-k)-1;

ShellSt(L,N,dlta,t);
}

int main()
{
int N=250;
int i,j,k;
int t;
int ti[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");
}

6． 一个类中，const类型成员函数的主要作用是什么？在该函数中能够调用该类的什么类型的成员变量和成员函数？该类的一个非const对象能够调用const成员函数吗？(10)
（1）能够定义const常量，具有不可变性。
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) 编译器就会知道i是一个常量，不允许修改；
（3）能够避免意义模糊的数字出现，同样能够很方便地进行参数的调整和修改。 同宏定义一样，能够做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！
（4）能够保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如：
void f(const int i)
（5） 为函数重载提供了一个参考。
class A { ......
void f(int i) //一个函数
void f(int i) const //上一个函数的重载 ......
};
（6） 能够节省空间，避免不必要的内存分配。
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，因此，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7） 提高了效率。 编译器一般不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

不能修改类的数据成员，不能在函数中调用其它不是const的函数.
1）const对象调用的是const成员函数 。
2）非const成员函数能够调用const成员函数，这样做一般是用来避免代码重复，但引入了一个casting动作。

7． 下面两个语句的执行效果相同吗？为什么？(9)
语句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