**一、選擇題（每題
1分，共計27x1'=27分）**
1.下列關于類和對象的敘述中，錯誤的是
( )
A.一個類只能有一個對象
B.對象是類的具體實例
C.類是對某一類對象的抽象
D.類和對象的關系是一種數據類型與變量的關系
2.當將一個類A或函數f()說明為另一個類B的友元后，類A或函數f()能夠直接訪問類B的( )。
A.只能是公有成員
B.只能是保護成員
C.只能是除私有成員之外的任何成員
D.任何權限的成員
3.類中定義的成員默認為( )訪問屬性。
A.public B.private C.protected D.friend
4.一個類的友元不是該類的成員，與該類的關系密切，所以它( )。
A.有this指針，有默認操作的對象
B.沒有this指針，可以有默認操作的對象
C.有this指針，不能執行默認操作
D.沒有this指針，也就沒有默認操作的對象
5.假定AA為一個類，a為該類私有的數據成員，GetValue( )為該類公有函數成員，它返回a的值，x為該類的一個對象，則訪問x對象中數據成員a的格式為( )。
A.x.a B.x.a() C.x->GetValue() D.x.GetValue()
6.對于任一個類，用戶所能定義的構造函數的個數至多為( )
。
A.0 B.1 C.2 D.任意個
7.一個類的析構函數通常被定義為該類的( )成員。
A.私有
B.保護
C.公用
D.友元
8.有如下類聲明：class Foo｛int bar;｝;則Foo類的成員bar是 （ ）
A.公有數據成員
B.公有成員函數
C.私有數據成員
D.私有成員函數
9.關于封裝，下列說法中不正確的是( )。
A.通過封裝，對象的全部屬性和操作結合在一起，形成一個整體
B.通過封裝，一個對象的實現細節被盡可能地隱藏起來（不可見）
C.通過封裝，每個對象都成為相對獨立的實體
D.通過封裝，對象的屬性都是不可見的
10.假定AB為一個類，則執行 “AB *s=new AB(a,5);”語句時得到的一個動態對象為( )。 A.s B.s->a C.s.a D.*s 11.對于一個類的構造函數，其函數名與類名( )。
A.完全相同
B.基本相同
C.不相同
D.無關系
12.在一個類的定義中，包含有( )成員的定義。
A.數據
B.函數
C.數據和函數
D.數據或函數
13.假定AB為一個類，則執行AB x；語句時將自動調用該類的( )。
A.有參構造函數
B.無參構造函數
C.拷貝構造函數
D.賦值構造函數
14.若類X是類Y的友元類，則下列哪種訪問關系是正確的
A.類X的成員不能訪問類Y的私有成員
B.類X的成員可以訪問類Y的私有成員
C.類Y的成員可以訪類X的私有成員
D.只有類Y的公共成員才能訪問類X的私有成員
15.假定AB為一個類，則執行 “AB a, b(3), *p;”語句時共調用該類構造函數的次數為( )。
A.2 B.3 C.4 D.5
16.在C++中，當一個對象被創建后，它的每一個成員函數都含有一個系統自動生成的隱含的指針，稱之為( )指針。（2分）
A.對象
B.派生
C.基類
D.this
17.靜態數據成員的初始化是在( )中進行的。
A.構造函數
B.任何成員函數
C.所屬類
D.類體外
18.對于公有繼承，基類中的私有成員在派生類中將( )。
A.能夠直接使用成員名訪問
B.能夠通過成員運算符訪問
C.仍然是基類的私有成員
D.變為派生類的私有成員
19.建立包含有類對象成員的派生類對象時，自動調用構造函數的執行順依次為( )的構造函數。
A.自己所屬類、對象成員所屬類、基類
B.對象成員所屬類、基類、自己所屬類
C.基類、對象成員所屬類、自己所屬類
D.基類、自己所屬類、對象成員所屬類
20.派生類的成員函數可以直接訪問基類的（）成員。
A.所有
B.公有和保護
C.保護和私有
D.私有
21.在c++中，一個虛函數是通過關鍵字( )放在其基類說明的前面來加以說明的
.
A.virtual B.protected C.operator D.this
22.在C++中，對于基類的protected成員，當以protected方式派生一個新類時。該成員將成為派生類的( )成員.
A.private B.protected C.public D.非法
23.面向對象方法的多態性是指（）。
A.一個類可以派生出多個特殊類
B.一個對象在不同的運行環境中可以有不同的變體
C.針對一消息，不同的對象可以以適合自身的方式加以響應
D.一個對象可以是由多個其他對象組合而成的
24.抽象類是（）
A.不可以定義對象
B.可以定義對象
C.不可以派生新類
D.不可以輸出
25.假定k是一個double類型的變量，則關于變量p的正確定義語句為( )。
A.double p=&k; B.int *p=&k; C.double *p=&k; D.char *p=”Thank you!”;
26.若有定義：int aa[8];則以下表達式中不能代表數組元素aa[1]的地址的是( )。
A.&aa[0]+1 B.&aa[1] C.&aa[0]++ D.aa+1
27.假定指針變量p定義為“int *p=new int;”，要釋放p所指向的動態內存，應使用語句( )。
A.delete p; B.delete *p; C.delete &p; D.delete []p;
** 二.判斷(每題2分，共計12x2'=24分
)******
1.域運算符(::)描述的是類和成員之間的關系。
2.靜態成員函數只能訪問靜態成員變量。
3.構造函數和析構函數都可以重載。
4.在公有繼承中，基類中的公有成員和私有成員在派生類中都是可見的。
5. 抽象類不可以繼承，只能派生
6. 類的私有成員只能被類中的成員函數訪問，任何類以外的函數對它們的訪問都是非法的。
7. 友元函數的聲明不受訪問區域的影響。
8. 子類可以繼承父類的所有成員。
9. 使用new申請的內存，在程序執行結束時，必須使用delete釋放。
10. 類A是類B的友元，則類B一定是類A的友元。
11. 靜態成員變量每個對象都有一份拷貝。
12. 子類可以改造從父類繼承的成員。**
三、問答題（每題3分，共計6x3'=18分）
1. 什么是“引用”？申明和使用“引用”要注意哪些問題？將“引用”作為函數參數有哪些特點?
2、C++中的繼承有幾種形式？ 各種方式中的派生類對基類成員的訪問規則有什
3、舉一個多態的例子，并以C++的格式給于定義和實現。
4、派生類的構造函數和父類構造函數的執行順序？
5、什么是虛基類？他的作用是什么？
6、解釋：深拷貝，淺拷貝。
**四、看程序（每題1.5分，共計2x1.5'=3分）**題
1.分析以下程序的執行結果
#include<iostream.h>
class Sample
{
int A[10][10];
public:
int &operator()(int,int);
};
int &Sample::operator()(int x,int y)
{
return A[x][y];
}
void main()
{
Sample a;
int i,j;
for(i=0;i<10;i++)
for(j=0;j<10;j++)
a(i,j)=i+j;
for(i=0;i<10;i++)
cout<<a(i,1)<<" ";
cout<<endl;
}
題2. 回答問題：①該程序執行后的輸出結果是什么？為什么？
#include
class A
｛
public：
virtual void act1（）;
void act2（）
｛
act1（）;
｝
｝;
void A：：act1（）
｛
cout”A：：act1（） called。”
}
class B：public A
｛
public：
void act1（）;
｝
void B：：act1（）
｛
cout”B：：act1（） called。”
}
void main（）
｛
B b;
b.act2（）;
｝
《嵌入式C++高級編程》****機試試卷
一、已知
String類定義如下：（10分）
class String
{
public:
String(const char *str = NULL); //通用構造函數
String(const String &another); //拷貝構造函數
~ String(); //析構函數
String & operater =(const String &rhs); //賦值函數
private:
char *m_data; //用于保存字符串
};
寫出類的成員函數的具體功能實現代碼。
二、在Time類中設計如下重載運算符函數：時間：小時、分、秒
實現加法、減法、前++、后++重載。**（10分）**
三、使用文件相關的類，實現圖片或mp3等文件的復制。**（8分）**
例如：./copyfile a.mp3 b.mp3
a.mp3是已經存在的mp3音頻文件
,b.mp3是從a.mp3音頻文件復制之后得到的新文件。
答案
C++考試題4_參考答案
一，選擇
1. D 2. D 3. B 4. D 5. D 6. D 7. C 8. C 9. B 10. D
11. A 12. C 13. B 14. B 15. A 16. D 17. D 18. C 19. C 20. B
21. A 22. B 23. C 24. A 25. C 26. C 27. A
二，判斷 2,7,9,12 T
1. F 2. T 3. F 4. F 5. F 6. F 7. T 8. F 9. T 10. F
11. F 12. T
三，問答
1. C++中引用和指針的區別？
引用是對象的別名， 操作引用就是操作這個對象， 必須在創建的同時有效得初始化（引用一個有效的對象， 不可為NULL）， 初始化完畢就再也不可改變， 引用具有指針的效率， 又具有變量使用的方便性和直觀性， 在語言層面上引用和對象的用法一樣， 在二進制層面上引用一般都是通過指針來實現的， 只是編譯器幫我們完成了轉換。 之所以使用引用是為了用適當的工具做恰如其分的事， 體現了最小特權原則。
2、C++中的繼承有幾種形式？ 各種方式中的派生類對基類成員的訪問規則有什
派生繼承，虛擬繼承，多重繼承
有三種形式：
方式 public protected private
1,Public public protected private
2,Protected protected protected private
3,Private private private private
3、在C++程序中調用被C 編譯器編譯后的函數，為什么要加extern “C”？
首先，作為extern是C/C++語言中表明函數和全局變量作用范圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數和變量可以在本模塊或其它模塊中使用。 在c++的環境下使用c 的函數時，通常會出現編譯器無法找到 obj 模塊中的c 函數定義的問題，從而導致鏈接失敗。這時因為在c++ 中支持函數重載，編譯時會將函數名和參數列表連接起來，而c 語言不會，因此會造成鏈接失敗的情況，此時 c 函數就需要使用extern “C “ 來進行鏈接指定。
4、派生類的構造函數和父類構造函數的執行順序？
順序如下：
1， 虛基類構造函數
2， 非虛基類構造函數
3， 組合對象構造函數
4， 本身構造函數
5、什么是虛基類？他的作用是什么？
當繼承時，加上virtual關鍵字，就是所謂的虛擬繼承，該基類就是虛基類；
作用：當繼承重復時，會出現繼承模糊的問題，虛擬繼承會解決這個問題，即沒有繼承的時候繼承，如果繼承了則不需要再重復繼承。
6、解釋：深拷貝，淺拷貝。
淺拷貝：拷貝構造函數簡單地制作了一個該資源的復制，而不對指針指向的堆空間拷貝一個復本堆空間，這樣兩個對象共享同一個堆空間，當其中一個對象析構時，另一個對象的指針則變成野指針，并且堆空間將產生兩次delete的錯誤；
深拷貝：拷貝構造函數對指針屬性所指的堆空間，也進行深度的空間復制，這樣，兩個對象就有獨立的空間和資源，這是深拷貝。
四 閱讀
1. 答案：8
思路：將x轉化為2進制，看含有的1的個數。
2. 輸出B：：act1() called。
====== 機試
一
String::String(constchar*str)
{
if ( str == NULL ) // strlen在參數為NULL時會拋異常才會有這步判斷
{
m_data =newchar[1] ;
m_data[0] ='\\0' ;
}
else
{
m_data =newchar[strlen(str) +1];
strcpy(m_data,str);
}
}
String::String(const String &another)
{
m_data =newchar[strlen(another.m_data) +1];
strcpy(m_data,other.m_data);
}
String& String::operator=(const String &rhs)
{
if ( this==&rhs)
return*this ;
delete []m_data; //刪除原來的數據，新開一塊內存
m_data =newchar[strlen(rhs.m_data) +1];
strcpy(m_data,rhs.m_data);
return*this ;
}
String::~String()
{
delete []m_data ;
}
二
#include <iostream.h> //
using namespace std;
class Vector
{
int vec[10];
public:
Vector(int v[10]);
Vector();
Vector(Vector&);
Vector operator+(Vector&);
Vector operator-(Vector&);
friend ostream& operator<<(ostream& out, Vector&);
};
Vector::Vector(int v[10])
{
int i;
for(i=0;i<10;i++)vec[i]=v[i];
}
Vector::Vector()
{ int i; for(i=0;i<10;i++)vec[i]=0; }
Vector::Vector(Vector& v)
{ int i; for(i=0;i<10;i++)vec[i]=v.vec[i]; }
Vector Vector::operator+(Vector& v)
{
Vector z; int i;
for(i=0;i<10;i++)z.vec[i]=vec[i]+v.vec[i];
return z;
}
Vector Vector::operator-(Vector& v)
{
Vector z; int i;
for(i=0;i<10;i++) z.vec[i]=vec[i]-v.vec[i];
return z;
}
ostream& operator<<(ostream& out, Vector& v)
{ for(int i=0;i<10;i++) out<<v.vec[i]<<","; return out; }
void main()
{
int a[10]={-4,1,0,10,5,-9,8,13,6,2,};
int b[10]={-11,8,10,17,-6,9,6,7,12,5};
Vector v1(a),v2(b),v3,v4;
v3=v1+v2;
v4=v2-v1;
cout<<v3<<endl;
cout<<v4<<endl;
}
三
#include < iostream >
#include < fstream >
using namespace std;
void main()
{
char a[100];
ofstream writeFile("text.txt");
int i;
while(1)
{
cin>>a;
if(a[0] == ’$’)
return;
i = 0;
while(a[i] != ’\\0’)
{
if( a[i]>=65 && a[i]<=90 )
a[i]=a[i] + 32;
i++;
}
writeFile<< a<<" ";
}
}
