姓名:___________ 时间:___________
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．栈
，，，，，word,,,,,,资料下载可编辑
，，，，，专业参考资料
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< ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 { public: int f() const{return 3;} int f(){return 5;} }; int main() { VAC v1; const VAC v2; cout< 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对象，则下列表达式中正确的是：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_ 6 4 4 4 4 return *this _ Dog speak Voice 1.下列中a的值是___400_____ #define AAA 200 #define BBB AAA+100 int a= BBB*2 ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 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 ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 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< 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分 { ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 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) { ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 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) ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 { p3=p2->next; p2->next=p1; p1=p2; p2=p3; } head->next=NULL; p1=head; return head; } 5．从冒泡排序、直接插入排序、二分插入排序和选择排序四种排序算法中，选择其中一种算法，写出它的实现？(10) #include 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]=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] ，，，，，专业参考资料 return min; } void SelectSort(int *L,int N) { //选择 int i,j; int t; for(i=1;i 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] for(j=i-2;L[0] { // 对顺序表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.r[i]插入有序增量子表 L[0]=L[i]; // 暂存在L.r[0] for(j=i-dk;(j>0&&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 void ShellSort(int *L,int N) { //希尔 int t=(int)log(N); int k,*dlta; dlta=(int*)malloc(t*4); //产生增量序列 for(k=0;k 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(\"长度\|冒泡\|选择\|插入\|希尔\\n\"); printf(\"--------+-------------------------------------------------------------\"); for(j=0;N<100000;j++) { ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 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\\ for(k=0;k<4;k++) printf(\"| %d\\ N*=5; } printf(\"\\n\\n\"); } 6．一个类中，const类型成员函数的主要作用是什么？在该函数中可以调用该类的什么类型的成员变量和成员函数？该类的一个非const对象可以调用const成员函数吗？(10) （1）可以定义const常量，具有不可变性。 （2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) 编译器就会知道i是一个常量，不允许修改； ，，，，，word,,,,,,资料下载可编辑 ，，，，，专业参考资料 （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 ，，，，，word,,,,,,资料下载可编辑 因篇幅问题不能全部显示，请点此查看更多更全内容