一、 填空題（25小題，共50分）
（以下每小題1分，共10分）
1． 在C++中，函數的參數有兩種傳遞方式，它們是值傳遞和 地址或指針或引用傳遞 。
2． 當一個成員函數被調用時，該成員函數的 this指針 指向調用它的對象。
3． 在基類和派生類中，派生類可以定義其基類中不具備的數據和操作。對兩個有相同名字的數據成員進行訪問時，如果沒有 作用域分隔符限定時 ，對此數據成員的訪問將出現歧義。
4． 拷貝構造函數使用 引用 作為參數初始化創(chuàng)建中的對象。
5． 在公有繼承的情況下，基類數據成員在派生類中的訪問權限 保持不變 。
6． 描述命題”A小于B或小于C”的表達式為 A<B||A<C 。
7． 用new申請某一個類的動態(tài)對象數組時，在該類中必須能夠匹配到 沒有形參的或缺省參數 構造函數，否則應用程序會產生一個編譯錯誤。
8． 靜態(tài)數據成員在類外進行初始化，且靜態(tài)數據成員的一個拷貝被類的所有對象 共享 。
9． 為了避免可能出現的歧義，C++對if…else語句配對規(guī)則規(guī)定為：else總是與 與最近的if 配對。
10． 設”int a=3,b=4,c=5;”，表達式”（a+b）>c&&b==c”的值是 0 。
（以下每小題2分，共20分）
11． 面向對象的程序設計有四大特征，它們是抽象、封裝、 繼承 、 多態(tài) 。
12． 在Visual C++中，定義重載函數時，應至少使重載函數的參數個數或參數類型 不同 ；在基類和派生類中，成員函數的覆蓋是指 派生類成員函數與在基類被覆蓋的成員函數名、參數個數、參數類型和返回值類型均相同 。
13． 構造函數與析構函數除功能不同外，在定義形式上，它們的區(qū)別還包括構造函數名與類名相同，而析構函數名是在類名前加一個~、 析構函數沒有參數 、 析構函數可以定義為虛函數 、無返回值、不能被重載、一個類中只有一個析構函數
14． 動態(tài)聯編要滿足兩個條件，它們是 被調用的成員函數是虛函數 、 用對象的指針或引用調用成員函數 。
15． 在C++類中，有一種不能定義對象的類，這樣的類只能被繼承，稱之為 抽象類 ，定義該類至少具有一個 純虛函數 。
16． 在C++類中，const關鍵字可以修飾對象和成員函數，const對象不能 被修改 ，const成員函數不能 修改類數據成員 。
17． 舉出C++中兩種用戶自定義的數據類型： 類 、 枚舉
18． C++中沒有字符串類型，字符串是通過 字符數組 來表示的，每一個字符串都有一個結尾字符 /0 。
19． C++中沒有輸入輸出語句，輸入輸出是通過 輸入輸出庫 實現的， 寫出一條打印整型變量n的輸出語句：cout<<n;
20． 舉出C++中兩種代碼復用的方式： 繼承 、 復用 。
（以下每小題4分，共20分）
21． 下面程序的運行結果是 3 。
#include <stdio.h>
void main()
{
char a=’a',b=’j';
float x;
x=(b-a)/('F’-'A’);
printf(“%d/n”,(int)(3.14*x));
}
22． 下面程序的運行結果是2 5 8 11 14。
#include “iostream.h”
void main( )
{
int i=1;
while (i<=15){
i++;
if (i%3!=2) continue;
else cout <<”i=”<<i<<endl;
}
}
23． 下面程序的運行結果是________。
#include “iostream.h”
class test
{
private:
int num;
float fl;
public:
test( );
int getint( ){return num;}
float getfloat( ){return fl;}
~test( );
};
test::test( )
{
cout << “Initalizing default” << endl;
num=0;fl=0.0;
}
test::~test( )
{
cout << “Desdtructor is active” << endl;
}
void main( )
{
test array[2];
cout << array[1].getint( )<< ” ” << array[1].getfloat( ) <<endl;
}
Initalizing default
Initalizing default
0 0
Desdtructor is active
Desdtructor is active
24． 下面程序的運行結果是________。
#include <iostream.h>
class A
{
public:
A(){cout<<”A::A() called./n”;}
virtual ~A(){cout<<”A::~A() called./n”;}
};
class B:public A
{
public:
B(int i){
cout<<”B::B() called./n”;
buf=new char;}
virtual ~B()
{
delete []buf;
cout<<”B::~B() called./n”;
}
private:
char *buf;
};
void fun(A *a)
{
delete a;
}
void main()
{
A *a=new B(15);
fun(a);
}
A::A() called.
B::B() called.
B::~B() called.
A::~A() called.
25． 下面程序的運行結果是________。
#include <stdio.h>
int a[ ]={1,3,5,7,9};
int *p[ ]={a,a+1,a+2,a+3,a+4};
void main( )
{
printf(“%d/t%d/t%d/n”,a[4],*(a+2),*p[1]);
printf(“%d/t%d/t%d/n”,**(p+1)+a[2],*(p+4)-*(p+0),*(a+3)%a[4]);
}
9 5 3
8 4 7
二、 問答題（每小題5分，共20分）
1 若程序員沒有定義拷貝構造函數，則編譯器自動生成一個缺省的拷貝構造函數，它可能會產生什么問題？
解答要點：缺省的拷貝構造函數只會拷貝存儲區(qū)的內容，如果其中有引用的話，它是不拷貝的，就造成了兩個類的實例引用了同一個對象，導致運行出錯
2簡述成員函數、全局函數和友元函數的差別。
解答要點：以下幾點必須說清楚：
成員函數：定義類的時候，定義了public訪問級的函數，可以訪問類的所有數據成員，也可以調用該類的其他成員函數；
全局函數：定義在主函數和類定義之外的函數，在任何地方允許被調用，但是過多的全局函數導致程序臃腫；
友元函數：由于通過類的實例并不能訪問到類的私有成員，如果在類定義之內定義友元函數，在類的實例中就可以通過友元函數訪問私有成員，該函數需要friend關鍵字聲明
3簡述結構化的程序設計、面向對象的程序設計的基本思想。
解答要點：結構化的程序設計將數據和對數據的操作分離，程序是由一個個的函數組成的，面向對象的程序設計將數據和操作封裝在一起，程序是由一個個對象組成的，對象之間通過接口進行通信，它能夠較好地支持程序代碼的復用。
4結構struct和類class有什么異同？
解答要點：struct和class都可以定義類，但是缺省訪問權限說明時，struct的成員是公有的，而class的成員是私有的。在C++中，struct可被class代替。
三、找出下面程序（或程序段）中的語法錯誤，并予以糾正（每小題4分，共8分）
（1）程序功能是倒序輸出各給定的字符串。
#include <stdio.h>
void main()
{
char str[5][ ]={“First”,”Second”,”Third”,”Forth”,”Fifth”};
char *cp[ ]={str[4],str[3],str[2],str[1],str[0]};
int i;
while(i<=5)
{
printf(“%c “,*(cp+i));
i++;
}
}
① “char str[5][ ]={“First”,”Second”,”Third”,”Forth”,”Fifth”};”應為
“char str[5][10 ]={“First”,”Second”,”Third”,”Forth”,”Fifth”};”
② “while(i<=5)”應為”while(i<5)”
③ “printf(“%c “,*(cp+i));”應為”printf(“%s”,*(cp+i));”
④ “int i;”應為”int i=0;”
（2）程序功能是將各個平方根值放入數組中。
#include <stdio.h>
void main()
{
int max,a,i;
scanf(“%d%d”,max,a);
double x[max];
for (i=0;i<max;i++)
x=sqrt(a*i);
}
① 增加”#include <math.h>”
② “scanf(“%d%d”,max,a);”應為”scanf(“%d%d”,&max,&a);”
③ “double x[max];”改為：
“double *x=new double[max];”
…
“delete []x;”
四、（8分）下列shape類是一個表示形狀的抽象類，area( )為求圖形面積的函數，total( )則是一個通用的用以求不同形狀的圖形面積總和的函數。請從shape類派生三角形類(triangle)、矩形類（rectangle），并給出具體的求面積函數
class shape{
public:
virtual float area( )=0;
};
float total(shape *s[ ],int n)
{
float sum=0.0;
for(int i=0;i<n;i++)
sum+=s->area( );
return sum;
}
class Triangle:public Shape
{
public:
Triangle(double h,double w){H=h;W=w;}
double Area() const{return H*W*0.5;}
private:
double H,W;
};
class Rectangle:public Shape
{
public:
Rectangle(double h,double w){H=h;W=w;}
double Area()const{return H*W;}
private:
double H,W;
};
一、選擇題（50分，每小題2分）
下列各題A）、B）、C）、D）四個選項中，只有一個選項是正確的。
（1）下列有關內聯函數的敘述中，正確的是 （ D ）
A）內聯函數在調用時發(fā)生控制轉移 B）使用內聯函數有利于代碼重用
C）必須通過關鍵字inline來定義 D）是否最后內聯由編譯器決定
（2）下列情況中，哪一種情況不會調用拷貝構造函數 （ B ）
A）用派生類的對象去初始化基類對象時
B）將類的一個對象賦值給該類的另一個對象時
C）函數的形參是類的對象，調用函數進行形參和實參結合時
D）函數的返回值是類的對象，函數執(zhí)行返回調用者時
（3）以下哪一關鍵字可用于重載函數的區(qū)分（ C ）
A）extern B）static C）const D）virtual
（4）下列有關數組的敘述中，正確的是（ B ）
A）C++中數組的存儲方式為列優(yōu)先存儲
B）數組名可以作為實參賦值給指針類型的形參
C）數組下標索引從1開始，至數組長度n結束
D）數組指針的語法形式為：類型名 *數組名[下標表達式];
（5）下列有關繼承和派生的敘述中，正確的是( C )
A）派生類不能訪問通過私有繼承的基類的保護成員
B）多繼承的虛基類不能夠實例化
C）如果基類沒有默認構造函數，派生類就應當聲明帶形參的構造函數
D）基類的析構函數和虛函數都不能夠被繼承，需要在派生類中重新實現
（6）實現運行時多態(tài)的機制是（ A ）
A）虛函數 B）重載函數 C）靜態(tài)函數 D）模版函數
（7）下列字符串中，正確的C++標識符是（ D ）
A）enum B）2b C）foo-9 D）_32
（8）若有下面的函數調用：
fun(a+b, 3, max(n-1, b));
其中實參的個數是（ A ）
A）3 B）4 C）5 D）6
（9）以下哪個關鍵字對應的屬性破壞了程序的封裝性（ B ）
A）const B）friend C）public D）protected
（10）以下哪個符號（或組合）是作用域限定符（ C ）
A）-> B）. C）:: D）[]
（11）下列關于this指針的說法正確的是（ B ）
A）this指針存在于每個函數之中
B）在類的非靜態(tài)函數中this指針指向調用該函數的對象
C）this指針是指向虛函數表的指針
D）this指針是指向類的函數成員的指針
（12）在下列關于C++函數的敘述中，正確的是（ C ）
A）每個函數至少要有一個參數 B）每個函數都必須返回一個值
C）函數在被調用之前必須先聲明 D）函數不能自己調用自己
（13）下列運算符中，不能重載的是 （ C ）
A）&& B）!= C）. D）->
（14）對于類的常成員函數的描述正確的是（ A ）
A）常成員函數不修改類的數據成員
B）常成員函數可以對類的數據成員進行修改
C）常成員函數只能由常對象調用
D）常成員函數不能訪問類的數據成員
（15）使用如setw()的操作符對數據進行格式輸出時，應包含的頭文件是（ D ）
A）iostream B）fstream C）stdio D）iomanip
（16）若有以下類定義
class MyClass {
public:
MyClass() { cout << 1; }
};
則執(zhí)行語句MyClass a,b[2],*p[2];后，程序的輸出結果是（ B ）
A）11 B）111 C）1111 D）11111
（17）下面程序的輸出結果是（ B ）
#include <iostream>
using namespace std;
int i = 0;
int fun(int n)
{
static int a = 2;
a++;
return a+n;
}
void main()
{
int k = 5;
{
int i = 2;
k += fun(i);
}
k += fun(i);
cout << k;
}
A）13 B）14 C）15 D）16
（18）下面程序的輸出結果是（ A ）
#include <iostream >
using namespace std;
void swap1( int &v1, int &v2)
{
int tmp = v2;v2 = v1;v1 = tmp;
}
void swap1( int *v1, int *v2)
{
int tmp= *v2;*v2 = *v1;*v1 = tmp;
}
void main()
{
int i = 10, j = 20; swap1(i,j); swap1(&i,&j);
cout<<i<<”,”<<j<<endl;
}
A）10,20 B）20,10 C）10,10 D）20,20
（19）下面的程序段的運行結果為（ D ）
char str[] = “job”, *p = str;
cout << *(p+2) << endl;
A）98 B）無輸出結果 C）字符’b’的地址 D）字符’b’
（20）下面程序的輸出結果是（ C ）
#include <iostream>
using namespace std;
class A
{
public:
A (int i) { x = i; }
void dispa () { cout << x << “,”; }
private :
int x ;
};
class B : public A
{
public:
B(int i) : A(i+10) { x = i; }
void dispb() { dispa(); cout << x << endl; }
private :
int x ;
};
void main()
{
B b(2);
b.dispb();
}
A）10,2 B）12,10 C）12,2 D）2,2
（21）下面程序的輸出結果是（ C ）
#include <iostream>
using namespace std;
class Base
{
public:
Base(int i) { cout << i; }
~Base () { }
};
class Base1: virtual public Base
{
public:
Base1(int i, int j=0) : Base(j) { cout << i; }
~Base1() {}
};
class Base2: virtual public Base
{
public:
Base2(int i, int j=0) : Base(j) { cout << i; }
~Base2() {}
};
class Derived : public Base2, public Base1
{
public:
Derived(int a, int b, int c, int d) : mem1(a), mem2(b), Base1(c),
Base2(d), Base(a)
{ cout << b; }
private:
Base2 mem2;
Base1 mem1;
};
void main() { Derived objD (1, 2, 3, 4); }
A）134122 B）123412 C）14302012 D）143212
（22）以下程序對一維坐標點類Point進行運算符重載，輸出結果是（ A ）
#include <iostream>
using namespace std;
class Point {
public:
Point (int val) { x = val; }
Point operator ++() { x++; return *this; }
Point operator ++(int) { Point old = *this; ++(*this); return old; }
Point operator +(Point a) { x += a.x; return *this; }
int GetX() const { return x; }
private:
int x;
};
int main()
{
Point a(10);
cout << (++a).GetX();
cout << a++.GetX();
}
A）1111 B）1011 C）1112 D）1010
（23）下面程序的輸出結果是（ C ）
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f() { cout << “f0+”; }
void g() { cout << “g0+”; }
};
class Derived : public Base
{
public:
void f() { cout << “f+”; }
void g() { cout << “g+”; }
};
void main() { Derived d; Base *p = &d; p->f(); p->g(); }
A）f+g+ B）f0+g+ C）f+g0+ D）f0+g0+
（24）下面程序的輸出結果是（ C ）
#include <iostream>
using namespace std;
int countp=0;
class Point
{
int X,Y;
public:
Point(int x=0,int y=0) { X=x; Y=y;}
Point(Point &p){X=p.X;Y=p.Y;countp++;}
friend Point myfun(Point p1 ,Point p2 ,const Point &p3);
};
Point myfun(Point p1,Point p2,const Point &p3)
{
Point tmp(p1.X+p2.X+p3.X,p1.Y+p2.Y+p3.Y);
return tmp;
}
void main()
{
Point pp0,pp1(1,2),pp2(1);
myfun(pp0,pp1,pp2);
std::cout<<countp<<endl;
}
A）0 B）4 C）3 D）6
（25）下面程序的輸出結果是（ C ）
#include <iostream>
using namespace std;
class Sample
{
friend long fun (Sample s)
{
if (s.x < 2) return 1;
return s.x * fun(Sample(s.x-1));
}
public:
Sample (long a) { x = a; }
private:
long x;
};
void main()
{
int sum = 0;
for (int i=0; i<6; i++)
{
sum += fun(Sample(i));
}
cout << sum;
}
A）120 B）16 C）154 D）34
二、填空題（20分，每空2分）
（1）以下程序是用來計算小于16的整數的階乘，請補充完整。
#include<iostream>
using namespace std;
const int ArSize =16;
void main()
{
double fac[ArSize];
fac[1] =fac[0] =1.0;
for(int i=2;i<ArSize;i++)
fac = i*fac[i-1] ;
}
（2）下面是個Cat類的聲明與使用，請補充完整。
#include <iostream>
using namespace std;
class Cat
{
static int count;
public:
Cat() { count++; cout << “Now cat number is” <<count << endl; }
~Cat() { count–; cout << ” Now cat number is ” << count << endl; }
};
int Cat::count =0;
int main()
{
Cat a, b, c;
return 0;
}
（3）將下面的MyPoint類定義補充完整，使得程序的輸出結果是（10，10）（5，5）
#include <iostream>
class MyPoint
{
public:
MyPoint(int xx=5, int yy=5)
{ X = xx;
Y = yy;
std::cout<<”(“<<X<<”,”<<Y<<”) “;}
private:
int X, Y;
} ;
void main()
{
MyPoint a(10,10),b;
}
（4）已知文件之間具有以下的包含關系（用#include指令）：point.cpp 包含 point.h，point.cpp 包含 line.h，line.h包含 point.h。那么如下的point.h文件缺少什么語句，請補充完整。
// Point類的聲明，point.h
#ifndef _POINT_H_
#define _POINT_H_
class Point
{
…
} ;
#endif
（5）下列函數的功能是判斷字符串str是否對稱，對稱則返回true，否則返回false。請在橫線處填上適當內容，實現該函數。
bool fun (char *str)
{
int i=0, j=0;
while (str[j]) j++;
for(j–; i<j && str==str[j]; i++, j–);
return i>=j ;
}
（6）請將下列程序補充完整，使得輸出結果為“Destructor Derived Destructor Base”。
#include <iostream>
using namespace std;
class Base
{
public:
virtual ~Base () { cout << “Destructor Base”<< endl; }
};
class Derived : public Base
{
public:
~Derived(){ cout << “Destructor Derived” << endl; }
}；
void main ()
{
Base *pBase = new Derived;
delete pBase ;
}
（7）如有下列程序：
#include <iostream>
using namespace std;
class Demo
{
public:
Demo(){cout<<”default constructor\n”;}
Demo(const Demo &x){cout<<”copy constructor\n”;}
};
Demo userCode(Demo b){Demo c(b);return c;}
void main()
{
Demo a,d;
cout<<”calling userCode()\n”;
d = userCode(a);
}
執(zhí)行上面的程序的過程中，構造函數Demo()和Demo(const Demo &x)被調用的次數分別是 2 和 3 次。
三、程序題（30分，每題10分）
（1）程序改錯
每個注釋“// ERROR”所在的一行語句存在錯誤。請改正這些錯誤，使程序的輸出結果為：
00:00:00
01:37:19
注意：只需修改注釋“// ERROR”所在的那一行語句，不要改動程序中的其他內容。
#include<iostream>
#include<iomanip>
using namespace std;
class StopWatch //”秒表”類
{
int hours; //小時
int minutes; //分鐘
int seconds; //秒
public:
StopWatch():hours(0), minutes (0), seconds(0){}
void reset(){hours=minutes=seconds=0;}
//前進1秒
StopWatch& operator++() // ERROR ①
{
if(seconds==60) // ERROR ②
{
seconds=0;
if(++minutes==60)
{
minutes=0;
++hours;
}
}
return *this;
}
friend void show(StopWatch);
};
void show(StopWatch watch)
{
cout<<setfill(‘*’); // ERROR ③
cout<<setw(2)<<watch.hours<<’:’
<<setw(2)<<watch.minutes<<’:’
<<setw(2)<<watch.seconds<<endl;
}
int main()
{
StopWatch sw;
show(sw);
for(int i=0;i<5839;i++)
sw++;
show(sw);
return 0;
}
解答：
①： StopWatch& operator++(int) (4分)
②： if(++seconds==60) （3分）
③： cout<<setfill(’0′); （3分）
（2）語句填空
下面的程序設計了一個寵物類，請你在空行上填入合適的語句，使程序完整。（每空2分）
#include <iostream>
enum Pets_type{dog,cat,bird,fish};
class Pets
{
private:
char *name;
Pets_type type;
public:
Pets(const char *n=”sonny”,int type1 = 0);
Pets(const Pets &s);
Pets& operator=(const Pets &s);
~Pets();
};
Pets::Pets(const char *n,int type1) //構造函數
{
name = new char[strlen(n) + 1];
strcpy(name,n);
type = Pets_type(type1);
}
Pets::Pets(const Pets &s) //拷貝構造函數
{
name = new char[strlen(s.name) + 1] ;
strcpy(name,s.name);
type = s.type;
}
Pets::~Pets() //析構函數
{
delete[] name ;
}
Pets& Pets::operator =(const Pets &s)
{
if (this==&s) //確保不要向自身賦值
return *this;
delete [] name;
name = new char[strlen(s.name) + 1];
strcpy(name,s.name);
type = s.type;
return *this ;
}
void main()
{
Pets mypet1,mypet2(“John”,1),hispet(“Danny”,2);
Pets youpet(hispet);
mypet1 = youpet;}
3） 編寫程序段
補充編制下列程序，其功能是從鍵盤讀取任意長度的文本內容，將文本存放到Doc類的對象myDoc中。然后在顯示器輸出。
請在//******* begin ******和//******* end *******之間補充程序。
#include<iostream>
#include<iomanip>
#include<cstring>
using namespace std;
class Doc
{
private:
static const int MaxLength; // 可能的最大文本字符串長度
char *str; // 文本字符數組首地址指針
int length; // 文本字符串長度
public:
Doc(const char *s = “”); // 構造函數
~Doc(); // 析構函數
// 重載istream的提取運算符
friend istream& operator>>(istream& is, Doc& doc);
// 重載ostream的插入運算符
friend ostream& operator<<(ostream& os, Doc& doc);
};
const int Doc::MaxLength=256; // 可能的最大文本字符串長度
//重載提取運算符，從輸入流is提取字符串，存入參數doc中
istream& operator>>(istream& is, Doc& doc)
{
//提示：使用is.getline函數可以從is流提取字符串，包括空格。
//********************** begin *************************
char buffer[Doc::MaxLength];
is.getline(buffer, Doc::MaxLength);
int inLen = (int)strlen(buffer);
if (inLen > doc.length) {
delete [] doc.str;
doc.str = new char[inLen+1];
}
strcpy(doc.str, buffer);
doc.length = inLen;
return is;
//******************** end *****************************
}
ostream& operator<<(ostream& os, Doc& doc)
{
os << doc.str;
return os;
}
Doc::Doc(const char *s) : length((s!=NULL) ? (int)strlen(s) : 0)
{
str = new char[length + 1];
if (s != NULL)
strcpy(str, s);
else
str[0] = ‘\0′;
}
Doc::~Doc()
{
delete [] str;
}
void main()
{
Doc myDoc(“Initial String”);
cin >> myDoc;
cout<< myDoc;
