C/C++開發工程師面試題目（一）（附答案分析）
推薦：自己根據在面試中碰到做過的一些題目以及總結的題目，希望對面試的同學有所幫助。
一、 選擇題
1． 下列類中( )不是輸入輸出流類iostream的派生類。
A、 fstream B、 ofstream C、 strstream D、 ostrstream
答案：BD
解析：ofstream和ostrstream派生自ostream，而不是iostream。
2． 在下列選項中( )不是ostream類的對象。
A、 cin B、 cerr C、 clog D、 cout
2 答案：A
解析：cin是istream對象。
3．read函數的功能是從輸入流中讀取（）。
A、一個字符 B、當前字符 C、一行字符 D、指定若干個字節
3 答案：D
解析：read函數可以通過指定參數的方式讀取若干個字符。
4．下列選項中，用於清除基數格式位設置以十六進制輸出的語句是（ ）。
A、cout<<setf(ios::dec,ios::basefield);
B、cout<<setf(ios::hex,ios::basefield);
C、cout<<setf(ios::oct,ios::basefield);
D、cin>>setf(ios::hex,ios::basefield);
答案：B
解析：
1.使用控制符控制輸出格式
控制符 作用
dec 設置整數的基數為10
hex 設置整數的基數為16
oct 設置整數的基數為8
setbase(n) 設置整數的基數為n(n只能是16，10，8之一)
setfill(c) 設置填充字符c，c可以是字符常量或字符變量
setprecision(n) 設置實數的精度為n位。在以一般十進制小數形式輸出時，n代表有效
數字。在以fixed(固定小數位數)形式和scientific(指數)形式輸出時， n為小數位數。
setw(n) 設置字段寬度為n位。
setiosflags(ios::fixed) 設置浮點數以固定的小數位數顯示。
setiosflags(ios::scientific) 設置浮點數以科學計數法(即指數形式)顯示。
setiosflags(ios::left) 輸出數據左對齊。
setiosflags(ios::right) 輸出數據右對齊。
setiosflags(ios::shipws) 忽略前導的空格。
setiosflags(ios::uppercase) 在以科學計數法輸出E和十六進制輸出字母X時，以大寫 表示。
setiosflags(ios::showpos) 輸出正數時，給出“+”號。
resetiosflags 終止已設置的輸出格式狀態，在括號中應指定內容。
2.用流對象的成員控制輸出格式
流成員函數 與之作用相同的控制符 作用
precision(n) setprecision(n) 設置實數的精度為n位。
width(n) setw(n) 設置字段寬度為n位。
fill(c) setfill(c) 設置填充字符c。
setf( ) setiosflags( ) 設置輸出格式狀態，括號中應給出格式狀態，內容與控制符setiosflags括號中內容相同
ubsetf( ) resetiosflags( ) 終止已設置的輸出格式狀態。
cout.width(10);
cout.setf(ios::hex);
3.設置格式狀態的格式標志
格式標志 作用
ios::left 輸出數據在本域寬范圍內左對齊
ios::right 輸出數據在本域寬范圍內右對齊
ios::internal 數值的符號位在域寬內左對齊，數值右對齊，中間由填充字符填充
ios::dec 設置整數的基數為10
ios::oct 設置整數的基數為8
ios::hex 設置整數的基數為16
ios::showbase 強制輸出整數的基數(八進制以0打頭，十六進制以0x打頭)
ios::showpoint 強制輸出浮點數的小點和尾數0
ios::uppercase 在以科學計數法輸出E和十六進制輸出字母X時，以大寫表示
ios::showpos 輸出正數時，給出“+”號。
ios::scientific 設置浮點數以科學計數法(即指數形式)顯示
ios::fixed 設置浮點數以固定的小數位數顯示
ios::unitbuf 每次輸出后刷新所有流
ios::stdio 每次輸出后清除stdout，stderr
以小數形式，保留三位小數輸出：
cout<<setprecision(3)<<setiosflags(ios::fixed)<<3.1415926<<endl;
5．下列格式控制符，在iostream.h中定義的是（ ），在iomanip.h中定義的是（ ）。
A、endl B、 setfill C、 setw D、 oct
答案：AD 、BC
6．包含類fstream定義的頭文件是（ ）。
A、fstream.h B、 ofstream.h C、 ifstream.h D、 iostream.h
7．要求可打開文件 “D:\file.dat”寫入數，正確的語句是（ ）。
A、 ifstream infile(“D:\file.dat”,ios::in);
B、 ifstream infile(“D:\\file.dat”,ios::in);
C、 ofstream infile(“D:\file.dat”,ios::out);
D、 fstream infile(“D:\\file.dat”,ios::in | ios::out);
8．假定已定義浮點型變量 data ，以二進制方式把 data 的值寫入輸出文件對象 outfile中去，正確的
語句是（）。
A、outfile.write((float *)&data, sizeof(float));
B、outfile.write((float *)&data, data);
C、outfile.write((char *)&data, sizeof(float));
D、outfile.write((char *)&data, data);
9. 系統為每個類提供一個this指針，在類的成員函數內，通過this指針可以間接訪問這個類的（ ）。
A、在public段中聲明的友元
B、所有成員
C、友元類的public成員
D、所有派生類中的public成員
10. 關於動態分配的對象，下面的說法（）是正確的？
A、對於數組A[N]，如果是靜態分配,N必須是常量；如果是動態分配，N可以是變量。
B、動態分配的對象必須由同類型的指針指出，不管該指針是局部的還是全局的，動態分配對象的生命周期隨指針的生命期結束而結束。
C、靜態和動態分配的對象在生命期結束時，都自動調用析構函數進行析構。
D、如果在某個函數內動態分配了一個對象，那么這個對象只有在這個函數內才能被訪問。
11. 在繼承關系中，虛基類的作用是（）。
A、實現重載
C、消除二義性
D、使得派生類可以再也不必考慮二義性問題
12. 對於有繼承關系的父類的構造函數，下面的（）是正確的。
A、構造函數可以通過虛基類的形式被繼承。
B、public的構造函數可以被繼承。
D、構造函數必須定義成非私有成員。
13. 對於指針，下（）是正確的。
A、聲明為void類型的指針可以指向任何類型的對象，並且通過該指針可以間接訪問它所指向的對象。
B、如果兩個指針的類型不是同一個類型，它們就不能相互賦值。（void類型的指針可以與其它類型的指針相互賦值）
C、一個int 類型的指針既可以指向int類型的對象，又可以指向int類型的函數。
D、數組名就是指針。
14. 有關析構函數的錯誤的說法是（ ）。
A、一個類的析構函數有且只有一個。
B、析構函數無函數類型。
C、析構函數和構造函數一樣，可以有形參。
D、析構函數的作用是在對象生命期結束時，收回分配給其的內存空間。
15. 對於操作符重載，下面（）的說法是正確的。
A、用戶每定義一個類，系統會自動提供一個賦值運算符重載函數，所以完全不必考慮重載賦值運算符函數。
B、運算符重載函數可能既不是成員函數，也不是友元函數。
C、運算符如果被重載為非成員函數，那么對象就不能利用這個運算符重載函數進行操作。
16. 關於類的友元函數的下述描述中，（）是正確的。
A、友元函數可以被繼承。
B、一個類的友元函數可以訪問這個類的所有成員。
C、一個類的友元函數必須在這個類中定義成內聯函數。
D、一個類的友元函數的返回類型必須是這個類的類型標識符。
答案：B
17. 類B的數據成員中“有一個”A類的對象，這種類之間的關系是 （ ）。
A、繼承關系 B、間接關系
C、復合關系 D、直接關系
答案：C
18. 下列C++標點符號中表示行注釋開始的是( )。
A、# B、;
C、// D、}
答案：C
19. 下列字符串中可以用作C++標示符的是（ ）。
A、_256 B、class
C、delete D、5char
答案：A
解析：B、C是關鍵字，D不能以數字開頭
20. 下列關於C++函數的描述中正確的是（ ）。
A、主函數是程序的入口，它是由用戶定義的函數調用。
B、函數是C++中面向對象程序設計框架的基本組成元素。
C、函數在調用前必須先被聲明。
D、每個用戶定義函數只能被其他函數調用一次。
答案：C
解析：A運行時庫會調用主函數
B 類
D 可以被隨意調用
21. 下列關於C++關鍵字的說法中正確的是（ ）。
A、關鍵字是用戶為程序中各種需要命名的“元素”所起的名字。
B、關鍵字是對程序中的數據進行操作的一類單詞。
C、關鍵字是在程序中起分割內容和界定范圍作用的一類單詞。
D、關鍵字是C++中預先定義並實現一定功能得一類單詞。
答案：D
22. 每個C++程序都必須由且僅有一個（ ）。
A、預處理命令 B、主函數
C、函數 D、語句
答案：B
23. 下面關於對象概念的描述中，（ ）是錯誤的。
A、對象就是C語言中的結構變量
B、對象代表着正在創建的系統中的一個實體
C、對象是一個狀態和操作（或方法）的封裝體
D、對象之間的信息傳遞是通過消息進行的
答案：A
24. C++對C語言做了很多改進，下列描述中（ ）使得C語言發生了質變，即從面向過程變成面向對象。
A、增加了一些新的運算符
B、允許函數重載，並允許設置默認參數
C、規定函數說明必須用原型
D、引進類和對象的概念
答案：D
25. 下面關於類概念的描述中，( )是錯誤的。
A、類是抽象數據類型的實現
B、類是具有共同行為的若干對象的統一描述體
C、類是創建對象的樣板
D、類就是C語言中的結構體類型
答案：D
解析：參見C++類和C結構體之間的區別
26. C++語言是以( )語言為基礎逐漸發展而演變而成的一種程序設計語言。
A、Pascal B、C
C、Basic D、Simula67
答案：B
27. C++語言中規定函數的返回值的類型是由（ ）。
A、return語句中的表達式類型所決定的
B、調用該函數式的主調用函數類型所決定的
C、調用該函數式系統臨時確定的
D、在定義該函數式所指定的數據類型所決定的
答案：D
28. 下列關於C++與C語言關系的描述中錯誤的是（ ）。
A、C++是C語言的超集
B、C++是C語言進行了擴充
C、C++是C語言都是面向對象的程序設計語言
D、C++包含C語言的全部語法特征
答案：C
解析：C語言是面向過程的程序設計語言
29. 下列字符串中可以用做C++標示符的是（ ）。
A、 521 B、computer~1 C、case D、3var
答案：A
30. 面向對象程序設計思想的主要特征中不包括( )。
A、封裝性 B、多態性
C、繼承性 D、功能分解，逐步求精
答案：D
31. 下列C++標點符號中表示一條預處理命令開始的是 A 。
A、# B、// C、} D、；
答案：A
32. 下列關於C++類的描述中錯誤的是（ ）。
A、類與類之間可以通過一些手段進行通信和聯絡
B、類用於描述事物的屬性和對事物的操作
C、類與類之間必須是平等的關系，而不能組成層次關系
D、類與類之間可以通過封裝而具有明確的獨立性
答案：C
33. 下列C++標點符號中表示一條語句結束的是（ ）。
A、；
B、//
C、#
D、{
答案：A
34. 下列C++標點符號中表示復合語句結束的標記符是（ ）。
A、#
B、//
C、}
D、；
答案：C
35. 下列C++標點符號中表示復合語句開始的標記符是( )。
A、{
B、//
C、}
D、；
答案：A
36. 下列關鍵字中，（ ）即在C語言中使用，又在C++語言中使用。
A、inline
B、break
C、private
D、public
答案：B
37. 下列字符串中不可以用作C++標示符的是（ ）。
A、 521
B、computer123
C、int
D、flower
答案：C
38. 下列不正確的選項是() 。
A、C++語言是一種面向對象的程序設計語言，它支持面向對象思想中的3個主要特征
B、標點符號是在程序中起分割內容和界定范圍作用的一類單詞
C、iostream 是一個標准的頭文件，定義了一些輸入輸出流對象
D、類與類之間不可以進行通信和聯絡
答案：D
39. 下列不正確的選項是
A、封裝是一種信息隱藏技術
B、標識符是由字母、數字、下划線組成的字符串，必須以數字或下划線開頭
C、編譯是由源程序文件轉換到目標文件的過程
D、一個C++程序可以認為是函數串
答案：B
40. 下列與流程控制有關的關鍵字是（ ）。
A、goto
B、static
C、int
D、sizeof
答案：A
41. 下列正確的選項是（ ）。
A、繼承是創建一個具有別的類的屬性和行為的新類的能力
B、C語言支持面向對象的程序設計
C、空白符是一種可以被編譯的符號
D、標示符不宜過長，一般設定為16個字符
答案：A
解析：C 空白符被忽略掉
D 標識符具體支持的長度根據編譯器的不同而不同
42. 下列關於C++語言的發展說法錯誤的是（ ）。
A、C++語言起源於C語言
B、C++語言最初被稱為“帶類的C”
C、在1980年C++被命名
D、在1983年C++被命名
答案：C
43. 下面說法錯誤的選項是（ ）。
A、引用表達式是一個左值表達式，因此它可以出現在形參和實參的任何一方
B、若一個函數返回了引用，那么該函數的調用也可以被賦值
C、所有函數都可以返回引用
D、引用返回值時，不生成值的副本
答案：C
解析：比如析構函數
44. 下列表示引用的方法中，（ ）是正確的。
已知：int k=1000;
A、int &x=k; B、char &y; C、int &z=1000; D、float &t=&k;
答案：A
解析：B聲明引用時必須賦值
C非const引用不能用常量賦值
D 類型不同
45. 下列程序的執行結果為（ ）。
#include<iostream.h>
void mian()
{
int n=10;
int* pn=&n;
int* &rn=pn;
(*pn)++;
cout<<"n="<<n<<endl;
(*rn)++;
cout<<”n=”<<n<<endl;
}
A、 n=11 n=12
B、 n=11 n=11
C、 n=10 n=11
D、 n=11 n=10
答案：A
解析：(*pn)++ 相當於 n++ ，所以n的值被修改為11
接下來，同理，(*rn)++ 相當於再一次的n++，所以n的值被修改為12
46. 下列引用的定義中，（ ）是錯誤的。
A、int i; int &j=i;
B、int i; int &j; j=i;
C、float i; float &j=i;
D、char d; char &k=d;
答案：B
解析：引用被聲明時必須初始化
47. （ ）是給對象取了一個別名，他引入了對象的同義詞。
A、指針
B、引用
C、枚舉
D、結構
答案：B
48. 下列表示引用的方法中，（ ）是正確的。
已知：int m=10;
A、int &x=m;
B、int &y=10;
C、int &z;
D、float &t=&m;
答案：A
解析：同樣是對引用的考察
49. 下面程序的運行結果是（ ）。
#include<iostream.h>
void fun(int &a,int &b)
{
int p;
p=a;
a=b;
b=p;
}
void exchange(int &a,int &b,int &c)
{
if(a<b)fun(a,b);
if(a<c)fun(a,c);
if(b<c)fun(b,c);
}
void main()
{
int a,b,c;
a=12;
b=639;
c=78;
exchange(a,b,c);
cout<<"a="<<a<<",b="<<b<<",c="<<c<<endl;
}
A、a=639,b=78,c=12
B、a=12,b=639,c=78
C、a=639,b=12,c=78
D、a=78,b=12,c=639
答案：A
解析：fun()函數交換傳入的兩個參數的值
exchange()函數把傳入的參數按照從大到小的順序排列
50. 下面的程序輸出結果為（ ）。
#include<iostream.h>
void main()
{
int *ir;
int i;
ir=&i;
i=17;
cout<<"int i="<<i<<endl;
cout<<"int ir="<<*ir<<endl;
}
A、int i=17 int ir=0
B、int i=0 int ir=17
C、int i=17 int ir=17
D、程序語法錯誤，沒有輸出結果
答案：C
解析：對指針的簡單考察
51. 對定義重載函數的下列要求中，( )是錯誤的。
A、要求參數的個數不同
B、要求參數中至少有一個類型不同
C、要求參數個數相同時，參數類型不同
D、要求函數的返回值不同
答案：D
解析：重載規則：
1）必須在同一作用域中
2）基於形參表不同而構成重載。
3）基於指針（或引用）形參是否為const也可以構成重載
4）在類中，基於成員函數是否為const可以構成重載（成員函數的const就是把隱含
的this指針const了）
52. 下面函數調用語句中實參的個數是()。
xxx((v1,v2),(v3,v4,v5),v6);
A、3 B、4 C、5 D、6
答案：A
解析：括號操作符
53. 系統在調用重載函數時往往根據一些條件確定哪個重載函數被調用，在下列選項中，不能作為依據
的是（ ）。
A、參數個數 B、參數的類型 C、函數名稱 D、函數的類型
答案：D
54. 若要定義一個只允許本源文件中所有函數使用的全局變量，則該變量需要使用的存儲類別是()
A、extern B、register C、auto D、static
答案：D
55. 在C++中，關於下列設置參數默認值的描述中，正確的是()
A、不允許設置設置參數的默認值
B、設置參數默認值只能在定義函數時設置
C、設置參數默認值時，應該實現設置右邊的再設置左邊的
D、設置參數默認值時，應該全部參數都設置
答案：C
56. 若有下面函數調用語句：
fun(a+b,(x,y),fun(n+k,d,(a+b)));
在此函數調用語句中實參的個數是( )。
A、3 B、4 C、5 D、6
答案：A
57. 下列對重載函數的描述中，( )是錯誤的。
A、重載函數中不允許使用默認參數
B、重載函數中編譯時根據參數表進行選擇
C、不要使用重載函數來描述毫無相干的函數
D、構造函數重載將會給初始化帶來多種方式
答案：A
58. 在函數聲明時，下列（ ）項是不必要的。
A、函數的類型 B、函數參數類型 C、函數的名字 D、返回值表達式
答案：D
59. 在函數的返回值類型與返回值表達式的類型的描述中，錯誤的是（）。
A、函數返回值的類型是在定義函數時確定，在函數調用時是不能改變的
B、函數返回值的類型就是返回值表達式的類型
C、函數返回值表達式類型與返回值類型不同時，函數表達式類型應轉換成返回值類型
D、函數返回值類型確定了返回值表達式的類型
答案：B
解析：可隱式轉換的類型
60. 下面變量和函數說明：
#include<iostream.h>
char ch='*';
void sub(int x,int y,char ch,double *z)
{
switch(ch)
{
case '+':*z=x+y;break;
case '-':*z=x-y;break;
case '*':*z=x*y;break;
case '/':*z=x/y;break;
}
}
下面合法的函數調用語句是( ) 。
A、sub(10,20,ch,y);
B、sub(1.2+3.2,'+',&z);
C、sub(sub(1,2,'+',&y),sub(3,4,'+',&x),'-',&y);
D）sub(a,b,&x,ch);
答案：B
解析：A，最后一個參數應該傳指針
C 前兩個參數是函數的返回值，sub函數的返回值是void
D 參數錯亂
61. 下列程序的輸出結果是( )。
#include<iostream.h>
void sub1(char a,char b)
{
char c;
c=a;
a=b;
b=c;
}
void sub2(char *a,char b)
{
char c;
c=*a;
*a=b;
b=c;
}
void sub3(char *a,char *b)
{
char c;
c=*a;
*a=*b;
*b=c;
}
void main()
{
char a,b;
a='A';
b='B';
sub1(a,b);
putchar(A);
putchar(b);
a='A';
b='B';
sub2(&a,b);
putchar(a);
putchar(b);
a='A';
b='B';
sub3(&a,&b);
putchar(a);
putchar(b);
putchar('\n');
}
A、ABABAB B、ABBBBA C、ABBABA D、ABABBA
答案：B
解析：考察指針值傳遞和地址傳遞問題
62. 下面程序的正確執行結果為。
＃include<iostream.h>
int f(int);
void main()
{
int a=2,i;
for(i=0;i<3;i++)
cout<<f(A)<<" ";
cout<<endl;
}
int f(int A)
{
int b=0;
static int c=3;
b++;
c++;
return (a+b+c);
}
A、7 7 7 B、7 10 13 C、7 9 11 D、7 8 9
答案：D
解析：static的變量的聲明周期問題，生命周期一直到程序結束
63. 下面程序的正確執行結果為( )。
＃include<iostream.h>
void fun(char **m)
{
m++;
cout<<*m<<endl;
}
void main()
{
static char *a[]={"MORNING","AFTERNOON","EVENING"};
char **n;
n=a;
fun(n);
}
A、為空 B、MORNING C、AFTERNOON D、EVENING
答案：C
解析：m++相當於a+1，指向數組的下一個元素
64. 下面程序的輸出結果（ ）。
＃i nclude<iostream.h>
int fun(char *s)
{
char *p=s;
while(*p!='\0')
p++;
return (p-s);
}
void main()
{
cout<<fun("ABCDEF")<<endl;
}
A、3 B、6 C、8 D、0
答案：B
解析：函數fun的作用是：傳入一個帶有’\0’的字符串，然后獲取字符個數
65. 當一個函數無返回值時，函數的類型應定義為( )。
A、void B、任意 C、int D、無
答案：A
66. 下面敘述中不正確的是（ ）。
A、在函數中，通過return語句傳回函數值
B、在函數中，可以有多條return語句
C、主函數名main()后面的一對圓括號中也可以帶有形參
D、調用函數必須在一條獨立的語句中完成
答案：D
解析：可以在任意地方完成函數調用
67. 下列( )的調用方式是引用調用。
A、形參是指針，實參是地址值
B、形參和實參都是變量
C、形參是數組，實參是變量
D、形參是引用，實參是變量
答案：D
解析：函數參數是引用時，傳遞類型相同的實參時，相當於給實參起了一個別名
68. 在C++中，函數原型不能標識( )。
A、函數的返回類型
B、函數參數的個數
C、函數參數類型
D、函數的功能
答案：D
解析：函數可以先聲明，不實現
69. 下列標識符中，（ ）是文件級作用域的。
A、函數形參
B、語句標號
C、外部靜態類標識符
D、自動類標識符
答案：C
70. 在傳值調用中，要求( )。
A、形參和實參類型任意，個數相等
B、實參和形參類型都完全一致，個數相等
C、實參和形參對應的類型一致，個數相等
D、實參和形參對應的類型一致個數任意
答案：C
71. 有一個int型變量，在程序中頻繁使用，最好定義它為( )。
A、register B、auto C、extern D、static
答案：A
72. 考慮下面的函數原型：void testDefaulParam(int a,int b=7,char z='*');
下面函數調用中不合法的( )。
A、testDefaulParam(5);
B、testDefaulParam(5,8);
C、testDefaulParam(5,'#');
D、testDefaulParam(0,0,'*');
答案：C
解析：因為有默認參數，所以調用testDefaulParam函數時只需要傳遞一個實參就可以了。如果傳遞
了更多的參數，仍然需要遵守參數傳遞原則。
73. 采用函數重載的目的在於。
A、實現共享 B、減少空間 C、提高速度 D、使用方便，提高可靠性
答案：D
74. 要求通過函數來實現一種不太復雜的功能，並且要加快執行速度，選用()。
A、內聯函數 B、重載函數 C、遞歸函數 D、嵌套函數
答案：A
解析：注意內聯函數所實現的功能應該盡量簡單，太復雜的功能不適合用內聯函數
75. 下面程序的輸出結果是( )。
＃i nclude<iostream.h>
void fun(int i);
int main()
{
int n=2;
fun(n);
return 0;
}
void fun(int i)
{
static int x=1;
int y=1;
if(i>0)
{
++x;
++y;
cout<<x<<' '<<y<<' ';
fun(i-1);
}
}
A、語法錯誤，不能輸出正確結果
B、2 2 2 2
C、2 2 3 3
D、2 2 3 2
答案：D
解析：static變量的生命周期
76. 下面程序的輸出結果為( )。
＃i nclude<iostream.h>
void prt(int *x,int *y,int *z)
{
cout<< ++*x << "," << ++*y << "," << *(z++) << endl;
}
int a=10;
int c=20;
int b=40;
void main()
{
prt(&a,&b,&c);
prt(&a,&b,&c);
}
A、11,42,31 12,21,41 B）11,41,20 12,42,20
C、11,21,40 11,21,41 D、11,41,21 12,42,22
答案：B
解析：每一次輸出都是先自加1后再輸出
77. 下面程序的正確運行結果為( )。
＃include<iostream.h>
fun(int a,int B)
{
static int m=1,i=2;
i+=m+1;
m=i+a+b;
return(m);
}
void main()
{
int k=5,m=2,p;
p=fun(k,m);
cout<<p<<",";
p=fun(k,m);
cout<<p<<endl;
}
A、11,22 B、12,23 C、11,23 D、10,23
答案：C
解析：static變量的生命周期問題
78. 下面程序的輸出結果是( )。
＃include<iostream.h>
void fun(int *s,int *y)
{
static int t=3;
*y=s[t];
t--;
}
void main()
{
int a[]={1,2,3,4};
int i,x=10;
for(i=0;i<4;i++)
{
fun(a,&x);
cout<<x<<",";
}
cout<<endl;
}
A、1,2,3,4 B、0,0,0,0 C、4,4,4,4 D、4,3,2,1
答案：D
解析：static變量的生命周期問題。
79. 下面程序的輸出結果是( )。
＃include<iostream.h>
int fun(char *s)
{
char *p=s;
while(*p!='\0')
p++;
return (p-s);
}
void main()
{
cout<<fun("ABCDEFGHIJKLMNIPQRST")<<endl;
}
A、20 B、6 C、19 D、0
答案：A
解析：函數fun的作用時，傳入一個帶有’\0’的字符串，然后獲取字符個數
80. 下面程序的輸出結果是( )。
＃i nclude<iostream.h>
int x=10;
void fun(int c);
void main()
{
fun(x);
cout<<"x="<<x<<endl;
}
void fun(int x)
{
x=1;
}
A、x=0 B、x=1 C、x=10 D、語法錯誤，不能輸出正確結果
答案：C
解析：值傳遞不會修改傳入的實參的值
81. 下面程序的執行結果是( )。
＃include<iostream.h>
void main()
{
void swap();
extern int a,b;
a=3;
b=10;
swap();
cout<<"a="<<a<<",b="<<endl;
}
int a,b;
void swap()
{
int temp;
temp=a;
a=b;
b=temp;
}
A、a=3,b=10 B、a=10,b=3 C、a=temp,b=temp D、語法錯誤，不能輸出正確結果
答案：B
解析：函數swap是無參，所以修改是是main()函數下面的的a,b的值，而不是main()函數體內
a，b的值
82. 下列程序的輸出結果是（ ）。
＃include<iostream.h>
void f()
{
static int i=15;
i++;
cout<<"i="<<i<<endl;
}
void main()
{
for(int k=0;k<2;k++)
f();
}
A、i=16 i=17
B、i=16 i=15
C、i=15 i=16
D、i=15 i=17
答案：A
解析：static變量的生命周期
83. 在橫線處填上適當的語句( )，使下面程序執行結果是13，18，23。
＃include<iostream.h>
int add(int x,int y=8);
void main()
{
;
cout<<add(a)<<",";
cout<<add(a,add(a)<<",";
cout<<add(a,add(a,add(a))<<endl;
}
int add(int a,int B)
{
int s=a+b;
return s;
}
A、int a=3 B、int b=3 C、int a=5 D、int b=5
答案：C
解析：在參數中調用函數時，實參是函數的返回值
83. 在橫線處填上適當的語句（ ），使下面的程序的執行結果是19 24 30 37 45。
＃i nclude<iostream.h>
int fun(int A)
{
static int x=10;
int y=1;
x+=a;
a++;
y++;
return(x+y+A);
}
void main()
{
int i=3;
while(i<8)
;
cout<<endl;
}
A、cout<<fun(i++)<<" "
B、cout<<fun(i)<<" "
C、cout<<fun(i++)<<" ,"
D、cout<<fun(i)<<" ,"
答案：A
解析：static變量的生命周期
84. 在C++語言中，局部變量的隱含存儲類型是( )。
A、auto B、static C、extern D、無存儲類型
答案：D
85. 下面程序的輸出結果為（）
＃include<iostream.h>
int fun(char *s);
int main()
{
cout<<fun("hello");
return 0;
}
int fun(char *s)
{
char *t=s;
while(*t!='\0')
t++;
return(t-s);
}
A、語法錯，不能輸出正確結果 B、0 C、6 D、5
答案：D
解析：傳入一個帶有’\0’的字符串，然后獲取字符個數
86． 有關類的說法不正確的是( )。
A、類是一種用戶字定義的數據類型.
B、只有類中的成員函數才能存取類中的私有成員.
C、在類中，如果不做特別說明，所指的數據均為私有類型.
D、在類中，如果不做特別說明,所指的成員函數均為公有類型。
答案：D
解析：class聲明的類的成員默認是private權限，struct聲明的類默認是public權限
87. 類A是類B的友元,類B是類C的友元,則( )是正確的.
A、類B是類A的友元
B、類C是類A的友元
C、類A是類C的友元
D、以上都不對
答案：D
88. 有下面類的說明，有錯誤的語句是（ ）。
class X
{
A、 int a=2;
B、 X();
public:
C、 X(int val):
D、 ~X();
};
答案：A
解析：類定義中不能給成員變量賦值
88. 有關析構函數的說法不正確的是( )。
A、 析構函數有切僅有一個
B、 析構函數和構造函數一樣可以有形參
C、 析構函數的功能是用來釋放一個對象
D、 析構函數無任何函數類型
答案：B
解析：析構函數不能有形參
89. 已知一個類X, ( )是定義指向類X成員函數的指針,假設類有3個公有成員: void f1(int), void f2(int)和int a.
A、X*P
B、 int X::*pc=&X::a
C、 void(X::*pA)()
D、X*p[10]
答案：C
90. 下列的各類函數中，( )不是類的成員函數
A、構造函數
B、析構函數
C、友元函數
D、拷貝構造函數
答案：C
91. 下列定義中，X是一個類, ( )是定義指向對象數組的指針p.
A、x*p[4]
B、x(*p)[4]
C、(x*)p[4]
D、x*p[]
答案：B
解析：
數組指針的定義方法：
第一步：寫一個該類型的數組
第二步：把數組名前面加上*
第三步：把*和數組名一起用小括號括起來
92. 已知p是一個指向類X數據成員m的指針,s是類X的一個對象。如果要給m賦值為3,( )
是正確的.
A、s.p=3
B、s - >p=3
C、s.*p=3
D、*s.p=3
答案：C
93. 已知f1(int)是類X的公有成員函數,p是指向成員f1()的指針，采用它賦值, ( )是正
確的.
A、p=f1
B、p=X::f1
C、p=x::f1
D、p=f1()
答案：B
解析：需要指定類作用域
94. 已知類X中的一個成員函數說明如下:
Void Set(X &a);
其中,X&a的含義是( ).
A、指向類X的指針為a
B、將a的地址賦給變量Sst
C、a是類X的對象引用，用來做為Set()的形參
D、變量X是a按位相與作為函數Set()的參數
答案：C
95. 一個類的友元函數能夠訪問該類的( ).
A、私有成員
B、保護成員
C、公有成員
D、所有成員
答案：D
96. 有關類和對象的說法不正確的是( ).
A、對是類的一個實例
B、一各類只能有一個對象
C、任何一個對象只能屬於一個具體的類
D、類與對象的關系和數據類型和變量的關系相似
答案：B
97. 下列靜態數據成員的特性中，( )是錯誤的.
A、說明靜態數據成員時前邊要加關鍵字static來修飾
B、靜態數據成員在類體外進行初始化
C、引用靜態數據成員時,要在靜態數據成員名前加<類名>和作用域運算符
D、靜態數據成員不是所有對象所共有的
答案：D
98. 類模板的使用實際上是類模板實例化成一個具體的( ).
A、類
B、對象
C、函數
D、模板類
答案：A
99. 通常拷貝構造函數的參數表是( ).
A、某個對象名
B、某個對象的成員名
C、某個對象的引用名
D、某個對象的指針名
答案：C
解析：防止遞歸調用死循環
100. 關於常數據成員的說法不正確的是( ).
A、常數據成員的定義形式與一般常量的定義形式相同，只不過常數據成員的定義必須出現在類體中.
B、常數據成員必須進行初始化,並且不能被更新
C、常數據成員通過構造函數的成員初始化列表進行初始化
D、常數據成員可以在定義時直接初始化
答案：D
101. 已知X類.則當程序執行到語句
X array[3];時,調用了（ ）次構造函數.
A、0
B、1
C、2
D、3
答案：D
解析：每一個數組元素都會調用類的構造函數
102. 類模板的模板參數( ).
A、只可作為數據成員的類型
B、只可作為成員函數的返回類型
C、只可作為成員函數的參數類型
D、以上三者皆可
答案：D
103. 下列（ ）不是構造函數的特征
A、構造函數的函數名與類名相同
B、構造函數可以重載
C、構造函數可以設置默認參數
D、構造函數必須指定類型說明
答案：D
104. 下列程序中說明的公有成員是( ).
class Location{
int X;
public:
void init(int initX,int initY);
private:
int Y;
public:
int GetX();
int GetY();
}
A、X
B、init(int initX,int initY)
C、GetX(),GetY()
D、B、和C、都是
答案：D
解析：只要有public訪控屬性的成員都是共有成員，跟在類定義中的位置沒有任何關系。
105. 類定義的內容允許被其他對象無限制地存取是( C ).
A、private 部分
B、protected 部分
C、public 部分
D、以上都不對
答案：C
106. 關於下面程度段說法正確的是( ).
class X
{
private:
int n;
punblic:
X(X&);
}
X::X(X&x)
{n=x.n}
X obj1,obj2;
obj2(obj1);
A、語句obj2（obj1）；的功能是用對象obj1初始化具有相同類類型的對象obj2
B、語句obj2（obj1）；的功能是用對象obj2初始化具有相同類類型的對象obj1
C、 X(X&x)也可以不使用引用參數而仍然是拷貝構造函數
D、 X(X&x)不能訪問對象的私有成員
答案：A
107. this指針是C++實現( )的一種機制.
A、抽象
B、封裝
C、繼承
D、重載
答案：B
108． 下面程序段中是內聯函數的是（ ）。
chass location
{
private:
int x ,y;
public:
void init(int initx,int inity)
{
x=initx;
y=inity;
}
int getx(){return x;}
int gety();
};
inline int location::gety(){return y;}
A、 init (int initx,int inity)
B、 getx(),gety()
C、 A和B都是
D、 A和getx()
答案：C
解析:在類定義時實現的成員函數，默認為inline函數
109． 關於對象成員的構造函數的調用順序，說法正確的是( C )。
A、與他們在成員初始化列表中給出的順序相同
B、與折構函數的調用順序相同
C、與他們在類中說明順序相同
D、以上說法都不對
答案：C
110． 類摸板trmplate<class T>classX{……},其中，友元函數f()成為該類模板實例化的每個模板類的友元，則其說明應為( ).
A、friend voidf()
B、frieng void f(X<T>&);
C、friend void A::f();
D、friend void C<T>::f(X<T>&);
答案：A
111.運算符—>*的功能是( )。
A、用來表示指向對象指針對指向類成員指針的操作。
B、用來表示對象類成員的操作。
C、用來表示指向對象指針對類成員的操作。
D、用來表示對象指向類成員指針的操作。
答案：A
112.下列說明中
const char * ptr;
ptr 應該是( )。
A、指向字符的指針
B、指向字符的常量指針
C、指向字符串常量的指針
D、指向字符串的常量指針
答案：C
113.下面關於友元的描述中，錯誤的是( )。
A、友元函數可以訪問該類的私有數據成員。
B、一個類的友元類中的成員函數都是這個類的友元函數。
C、友元可以提高程序的運行效率。
D、類與類之間的友元關系可以繼承。
答案：D
114．一個( )允許擁護為類定義一種模式，使得類中的某些數據成員、某些成員函數底參數和
返回值可以取任意數據類型。
A、函數模板
B、模板函數
C、類模板
D、模板類
答案：C
115．有關構造函數說法不正確的是( )
A、構造函數的名字和類的名字一樣。
B、在創建對象時，系統自動調用構造函數
C、構造函數無任何函數類型
D、構造函數有且只有一個
答案：D
116．下面對模板的聲明，正確的是（ ）
A、template<T>
B、template<class T1,T2>
C、template<classT1,classT2>
D、template<classT1;classT2>
答案：C
117. （ ）是析構函數的特征。
A、析構函數可以有一個或多個參數
B、析構函數定義只能在類體內
C、析構函數名與類名不同
D、一個類中只能定義一個析構函數
答案：D
118．類模板template<class T>class X{…..};,其中友元函數f對特定類型T（如 int），使函數f(X<int>&)成為X<int>模板類的友元，則其說明應為（）
A、friend coid f();
B、friend coid f(X<T>&);
C、friend coid A::f();
D、friend coid C<T>::f(X<T>&);
答案：B
119. 若函數是在運行激活的，則該函數稱為（ ）
A、內聯函數
B、非內聯函數
C、成員函數
D、靜態成員函數
答案：B
120．在C++程序中，對象之間的象話通信通過（ ）
A、繼承實現
B、調用成員函數實現
C、封裝實現
D、函數重載實現
答案：B
121．在類的定義形式中，數據成員、成員函數和（ ）組成了類定義體。
A） 成員的訪問控制信息
B） 公有消息
C） 私有消息
D）保護消息
答案：A
122．對於任意一個類，析構函數的個數最多為（ ）
A） 0
B） 1
C） 2
D）3
答案：B
123．（ ）的功能是對對象進行初始化。
A） 析構函數
B） 數據成員
C） 構造函數
D）靜態數據成員
答案：C
124．友元關系不能（ ）
A） 繼承
B） 是類與類之間是關系
C） 是一個類的成員函數與另一個類的關系
D）提高程序的運行效率
答案：A
繼承是類與類之間的關系
125．（ ）只能訪問靜態成員變量，靜態成員函數和類以外的函數和數據不能訪問類中的非靜態成員變量。
A） 靜態函數
B） 虛函數
C） 構造函數
D）析構函數
答案：A
126．下面說法正確的是（ ）
A） 內聯函數在運行時是將該函數的目標代碼插入每個調用該函數的地方
B） 內聯函數在編譯時是將該函數的目標代碼插入每個調用該函數的地方
C） 類的內聯函數必須在類體內定義
D）類的內聯函數必須在類體外關鍵字inline定義
答案：B
127.下列關於成員訪問權限的描述中，不正確的是（ ）
A） 公有數據成員和公有成員函數都可以被類對象直接處理
B） 類的私有數據成員只能被公有成員函數以及該類的任何友元類或友元函數訪問
C） 保護成員在派生類中可以被訪問，而私有成員不可以
D）只有類或派生類的成員函數和友元類或友元函數可以訪問保護成員
答案：B
128．局部變量可以隱藏全局變量，那么在有同名全局變量和局部變量的情形時，可以用（ ）
提供對全局變量的訪問
A） 域運算符
B） 類運算符
C） 重載
D）引用
答案：A
129．缺省析構函數的函數體是（ ）
Ａ）不存在
Ｂ）隨機產生的
Ｃ）空的
Ｄ）無法確定的、
答案：C
130．在下列關鍵字中，用以說明類中共有成員的是（ ）
A） public
B） private
C） protected
D）friend
答案：A
131．下面說法中正確的是（ ）
A） 一個類只能定義一個構造函數，但可以定義多哥析構函數
B） 一個類只能定義一個析構函數，但可以定義多個構造函數
C） 構造函數與析構函數同名，知識名字前加了一個求反符號（~）
D）構造啊函數可以指定返回類型，而析構函數不能指定任何返回類型，即使是void類型也不可以
答案：B
132．關於delete 運算符的下列描述中，（ ）是錯誤的。
A） 它必須用語new返回的指針
B） 它也適用於空指針
C） 對一個指針可以使用多次該運算符
D）指針名前只用一隊方括號符，不管所刪除數組的維數
答案：C
133．關於成員函數的特征的下述描述中，錯誤的是（ ）
A） 成員函數一定是內聯函數
B） 成員函數可以重載
C） 成員函數可以設置參數的默認值
D）成員函數可以是靜態的
答案：A
134．假定x為一個類，執行Xa[3],*p[2];語句時會只動調用該類的構造函數（ ）次
A） 2
B） 3
C） 4
D）5
答案：B
135．由於數據隱藏的需要，靜態，數據成員通常被說明為（ ）
A） 私有的
B） 公有的
C） 保護的
D）不可訪問的
答案：A
136．假定X為一個類，則該類的拷貝構造函數的聲明語句為（ ）
A） My Class(My Class x)
B） My Class&(My Class x)
C） My Class(My Class &x)
D）My Class(My Class *x)
答案：C
137．Main()函數在執行之前不可以調用其構造函數的（ ）
A） 全局對象
B） 靜態對象
C） 在main()函數體內說明的對象
D）全局對象數組
答案：C
138．對於常成員函數，下列描述正確的是（ ）
Ａ）常成員函數只能修改常數據成員
B）常成員函數只能修改一般數據成員
C）常成員函數不能修改任何數據成員
D、_成員函數只能通過常對象調用
答案：C
139．友元的作用是（ ）
Ａ）提高程序是運行效率
B）加強類的封裝性
C）實現數據的隱藏性
D、增加成員函數的種類
答案：A
140.一個類的友元函數或友元類能夠通過成員操作符訪問該類的（ ）
A） 私有成員
B） 公有成員
C） 保護成員
D）公有成員、保護成員和私有成員
答案：D
141．下面說法中正確的是（ ）
A） 當聲明的內容不同時，聲明同一個名字的兩個類是允許的
B） 不完全生命的類也可以實例化
C） 聲明同一個名字的兩個類時，要求聲明的內容也相同
D）生命同一個名字的兩個類是錯誤的
答案：D
142．下面對靜態數據成員的描述中，正確的是（ ）
A） 靜態數據成員是類的所有對象共享的數據
B） 類的沒個對象都有自己的靜態數據成員
C） 類的不同對象有不同的靜態數據成員值
D）靜態數據成員不能通過類的對象調用
答案：A
143．下列關於對象數組的描述中，錯誤的是（ ）
A） 對象數組的下標是從0開始的
B） 對象數組的數組名是一個常量指針
C） 對象數組的沒個元素是同一個類的對象
D）對象數組只能賦初值，而不能在定義后賦值
答案：D
144．對於下面定義的類A在函數f()中將對象成員n的值修改為60的語句應該是（ ）
class A
{
public:
A(int x){n=x;}
coid SetNum(int n1){n=n1;}
private
int n;
}
int f()
}
a*ptr=new A(60);
}
A） A(60)
B） SetNum(60)
C） Ptr->SetNum(60)
D）Ptr->n=60
答案：C
145.關於使用const關鍵字修飾的對象的說法正確的是（ ）
A） 不能用一般的成員函數來訪問
B） 可以用一般的成員函數來訪問
C） 可以訪問const成員函數及colatile成員函數
D）不能訪問const 成員函數
答案：A
146．下面是類MyClass的定義，對定義 中各語句描述正確的是（ ）
class MyClass
{
private:
int X,y,Z;
public;
coid MyClass(int A、{X=a;} file://①
int f(int a,int B) file://②
{
X=a;
Y=b;}
Int f(int a,int b,int c=0) file://③
{a;
Y=b;
Z=c;}
Static coid g() {X=10;} file://④
A） 語句①是類MyClass的構造函數定義
B） 語句②和語句③實現類成員函數的重載
C） 語句④實現對類成員變量X的更新操作
D）語句①②③和④都不正確
答案：D
63．友元訪問類的對象的成員時使用（ ）
A） 類的成員名
B） this指針指向成員名
C） “類名：：成員名”的形式
D）“對象名.成員名”的形式
答案：D
147.下列程序輸出的結果正確的是（ ）
＃i nclude<iostream.h>
coid fun()
{static int n=10;
n++;
cout <<”n=”<<n<<endl;
}
void main()
{
for (int I=1;I<3;I++)
cun();
}
A）n=11 n=11
B、 n=11 n=12
C、 n=10 n=11
D、 n=10 n=10
答案：B
148. 下面類模板的定義中，不正確的是（ ）
A） tempate<class T>
class A{T x,y;};
B） tempate<class T>
class A{private:t x;};
C） tempate<class T>
class A{public:T x;};
D）tempate<class T>
class A{protected:t x;};
答案：C
149. 靜態成員遵循類的其他成員所遵循的訪問限制，除了（ ）
A） 靜態成員函數
B） 靜態數據成員初始化
C） 私有靜態數據成員
D）公有靜態成員函數
答案：B
150. 空類的聲明（ ）是正確
A） class類名；
B） class類名{}；
C） class類名{}
D）class類名
答案：B
151. 可以用“px->*p”來訪問類A的對象a 的數據成員，則下面正確的是（ ）
A） px是指向類數據成員的指針
B） p是指向類數據成員的指針
C） p是指向類的對象的指針
D）無法確定指針類型
答案：B
152. 關於類中數據成員的生存期的說法正確的是（ ）
A） 與對象的生存期無關
B） 比對象的生存期長
C） 比對象的生存期短
D）有對象的生存期決定
答案：D
153. 類example 的析構函數為（ ）
Ａ）example（）；
Ｂ）example（）
Ｃ）~example（）；
D）~example（）
答案：D
154. 以知AA是一個類，則執行語句Aaa；后（ ）
Ａ）自動調用無參構造函數
B）自動調用有參構造函數
C、 自動調用拷貝構造函數
D、產生一個對象a,但不調用任何函數
答案：A
155.對於類模板tanytemp,執行語句tanytemp<int>iobject(23,32);后( )
A、產生的模板類為 tanytemp
B、產生的模板類為 iobject
C、產生的模板類為 tanytemp<int>
D、類模板實例化對象
答案：C
156. 下列說法正確的是( )
Ａ）類定義中只能說明函數成員的函數頭，不能定義函數體
B、類中的函數成員只能可以在類體內定義,不可能在類體外定義
C、類中的函數成員在類體外定義時必須要與類聲明在同一文件中
D、在類體外定義的函數成員不能操作該類的私有數據成員
答案：C
157.類的構造函數被自動調用執行的情況是在定義該類的( )
A、 成員函數時
B、 數據成員時
C、 對象時
D、 友元函數時
答案：C
158.說明友元函數使用關鍵字( )
A、 friend
B、 static
C、 const
D、 colatile
答案：A
159. 有關類的作用域.下了說法中不正確的是( )
A、 說明類時所使用的一對花括號形成所謂的類作用域
B、 類作用域不
C、 包含類匯總成員函數的作用域
D、 類作用域中說明的標E) 識符只在類中可見
F) 在可能出現兩義性的情況下,必須使用作用域限定符”::”
答案：B
160. 類的靜態成員( )
A、 是指B、 靜態數據成員
C、 是指D、 靜態函數成員
E) 為該類的所有對象共享
F) 遵循類的其他成員做遵循的所有訪問權限
答案：C
161. 允許訪問類的所有對象的私有成員,公有成員和保護成員的是( )
A、 友元函數
B、 成員函數
C、 內聯函數
D、 重載函數
答案：A
162. 形如X::X(X&)的構造函數稱為( )
A、 拷貝函數
B、 復
C、 制函數
D、 初始化函數
E) 拷貝初始化構造函數
答案：D
163.以知example是已定義的類,則程序結束前,共存在( )個對象.
＃i nclude<example.h>
main()
{example x(5); example arr[2]={1,2};
x=10;
x.print();
x=example(15);
x.print();
}
A、 3
B、 4
C、 7
D、 8
答案：B
164. 所有在函數中定義的變量,連同形式參數,都屬於( )
A、 全局變量
B、 局部變量
C、 靜態變量
D、 寄存器變量
答案：B
165.在C++中,封狀是借助於( )達到的.
A、 結構
B、 類
C、 數組
D、 函數
答案：B
166. 下面不屬於類的存取權限的是( )
A、 public
B、 static
C、 protected
D、 pricate
答案：B
167. 指向類X中類型為type的數據成員的指針的說明形式為( )
A、 type X::*pointer
B、 x::type*pointer
C、 type *X::pointer
D、 X::*tyoe pointer
答案：A
168. 已知:print()函數是一個類的常成員函數,它無返回值,下列表示中,( )是正確的
A、 coid print() const
B、 const coid print()
C、 viod const print()
D、 coid print(const)
答案：A
169. 關於new運算符的下列描述中,( )是錯誤的.
A、 它可以用來動態創建對象和對象數組
B、 使用它創建對象或對象數組,可以使用運算符DELETE刪除
C、 使用它創建對象時要調用構造函數
D、 使用它調用對象數組時不E) 許指F) 定初始值
答案：D
170. 下列關於構造函數的描述中,錯誤的是( )
A、 構造函數可以設置默認參數
B、 構造函數在說明類變量時自動執行
C、 構造函數可以對靜態數據成員進行初始化
D、 夠找函數可以重載
答案：C
172. 運算符delete刪除一個動態對象時( )
A、 首先為該動態對象調用構造函數,在釋放其占用的內存
B、 首先釋放該動態對象占用的內存,在為其調用構造函數
C、 首先為該動態對象調用析構函數,在釋放其占用的內存
D、 首先釋放動態對象占用的內存,在為其調用析構函數
答案：C
174． 下面關於純虛函數和抽象類的描述中，（ ）是錯誤的。
A） 純虛函數是一種特殊的虛函數，B） 它沒有具體意義
C） 一個基類中說明有純虛函數，D） 該基類的派生類一定不E） 再是抽象類
F） 抽象類只能作為基類來使用，G） 其純虛函數的定義由派生類給出
H） 抽象類是指I） 具有純虛函數的類
答案：B
175． 對虛函數的調用（ ）。
A） 一定使用動態聯編
B） 一定使用靜態聯編
C） 必須使用動態聯編
D） 不一定使用動態聯編
答案：D
176． 若類A和類B的定義如下：
class A
{
int i,j;
public:
void get();
file://…
};
class B:A//默認為私有派生
{
int k;
public;
void make();
file://…
};
void B:: make()
{
k=i*j;
}
則上述定義中，（ ）是非法的表達式。
A）void get();
B）int k;
D）void make();
D）k=i*j;
答案：D
177．下列描述中，（ ）是抽象類的特性。
A）可以說明虛函數
B）可以定義友元函數
C）可以進行構造函數重載
D）不能說明其對象
答案：D
178．在多繼承中，公有私生和私有派生對於基類成員的派生類中的可訪問性與單繼承的規則（ ）。
A）完全相同
B）完全不同
C）部分相同，部分不同
D）以上都不對
答案：A
179．（ ）是一個在基類中說明虛函數，它在該基類中沒有定義，但要求任何派生類中的可訪問性的規定是相同的。
A）純虛函數
B）虛析構函數
C）虛構造函數
D）靜態成員函數
答案：A
180．下列對派生類的描述中，（ ）是錯誤的。
A）一個派生類可以作另一個派生類的基類
B）派生類至少有一個基類
C）派生類的成員除了它自己的成員外， 包含了它的基類的成員
D）派生類中繼承的基類成員的訪問權限到派生類保持不變
答案：D
181．實現運行時的多態性要使用（ ）。
A）構造函數
B）析構函數
C）重載函數
D）虛函數
答案：D
182．派生類的對象對它的基類成員中（ ）是可以訪問的。
A）公有繼承的公有成員
B）公有繼承的私有成員
C）公有繼承的保護成員
D）私有繼承的公有成員
答案：A
183．關於函數的描述中，（ ）是正確的。
A）派生類的虛函數與基類的虛函數具有不同的參數個數和類型
B）基類中說明了虛函數后，派生類中其對應的函數一定要說明為虛函數
C）虛函數是一個成員函數
D）虛函數是一個static類型的成員函數
答案：C
184．對基類和派生類的關系描述中，（ ）是錯誤的。
A）派生類是基類的具體化
B）派生類是基類的子集
C）派生類是基類定義的延續
D）派生類是基類的組合
答案：B
185．關於動態聯編的下列敘述中，（ ）是錯誤的。
A）動態聯編是以虛函數為基礎的
B）動態聯編調用虛函數操作是指向對象的指針或引用
C）動態聯編是在運行時確定所調用的函數代碼的
D）動態聯編是在編譯時確定操作函數的
答案：D
186．派生類的構造函數的成員初始化列表中，不能包含（ ）。
A）基類的構造函數
B）派生類中子對象的初始化
C）基類的子對象初始化
D）派生類中一般數據成員的初始化
答案：C
187．如果一個類至少有一個純虛函數，那么就稱該類為（ ）。
A）抽象類
B）派生類
C）純基類
D）以上都不對
答案：A
188．設置虛基類的目的是（ ）。
A）簡化程序
B）消除二義性
C）提高運行效率
D）減少目標代碼
答案：B
189．在下面程序中，編譯時出現的錯誤是（ ）。
class A file://(1)
{
public; file://(2)
A()
{
func(); file://(3)
}
virtual void func()=0; file://(4)
};
A）(1)
B）(2)
C）(3)
D）(4)
答案：C
190．關於多繼承二義性的描述中，錯誤的是（ ）。
A）一個派生類的基類中都有某個同名成員，在派生類中對這個成員的訪問可能出現二義性
B）解決二義性的最常用的方法是對成員名的限定法
C）基類和派生類同時出現的同名函數，也存在二義性問題
F） 一個派生類是從兩個基類派生出來的，G） 而H） 這兩個基類又有一個共同I） 的基類，J） 對該基類成員進行訪問時，K） 可能出現二義性
答案：C
191．用於類中虛成員函數說明的關鍵字（ ）
A．virtual B．public C．protected D．private
答案：A
192．下列對派生類的描述中，錯誤的是（ ）
A． 派生類的缺省繼承方式是PRIVATE
B． 派生類至少有一個基類
C． 一個派生類可以作為另一個派生類的基類
D． 派生類只繼承了基類的公有成員和保密成員
答案：D
193．編譯時的多態性通常使用（ ）獲得。
A．繼承 B．虛函數 C．重載函數 D．析構函數
答案：C
194．下列說法中錯誤的是（ ）
A． 公有繼承時基類中的public成員在派生類中是public的
B． 公有繼承時基類中的private成員在派生類中是private的
C． 私有繼承時基類中的public成員在派生類中是private的
D． 私有繼承時基類中的public成員在派生類中是protected的
答案：D
195．下面哪個基類中的成員函數表示純虛函數（ ）
A． virtual void vf(int) B．void vf(int)=0 C．virtual void vf( )=0 D．virtual void vf(int)
答案：C
196．下面敘述不正確的是（ ）
A． 基類的公有成員在派生類中仍然是公有的
B． 派生類一般都用公有派生
C． 對基類成員訪問必須是無二義性的
D． 賦值兼容規則也使用於多重繼承的組合
答案：C
197．下列虛基類的聲明中正確的是（ ）
A． class virtual B:public A B．virtual class B:public
B． class B:public A virtual D．class B: virtual public A
答案：D
198．下面敘述不正確的是（ ）
A． 基類的保護成員在派生類中仍然是保護的
B． 基類的保護成員在公有派生類中仍然是保護的
C． 基類的保護成員在私有派生類中仍然是私有的
D． 對基類成員的訪問必須是無兩義性
答案：A
199．帶有虛基類的多層派生類構造函數的成員初始化列表中都要列出虛基類構造函數，這樣將對虛基類的子對象初始化（ ）
A．與虛基類下面的派生類個數有關 B．多次 C．二次 D．一次
答案：D
200．關於保護成員的說法正確的是（ ）
A． 在派生類中仍然是保護的
B． 具有私有成員和公有成員的雙重角色
C． 在派生類中是私有的
D． 在派生類中是公有的
答案：B
201．下列關於子類型的描述中，錯誤的是（ ）
A． 子類型關系是可逆的
B． 公有派生類的對象可以初始化基類的引用
C． 只有在公有繼承下
D． 派生類是基類的子類型
E． 子類型關系是可傳遞的
答案：A
202．若要強制C++對虛函數的調用使用靜態聯編，則在調用中對該函數使用（ A ）
A．成員名限定 B． 指針 C．引用 D．VIRTUAL關鍵字
答案：A
204.下面（ ）的敘述不符合賦值兼容規則。
A.派生類的對象可以賦值給基類的對象
B.基類的對象可以賦值給派生類的對象
C.派生類的對象可以初始化基類的對象
D.派生類的對象的地址可以賦值給指向基類的指針
答案：B
205.C++有（ ）種聯編。
A.1
B.2
C.3
D.4
答案：B
靜態聯編和動態聯編
206.對於下列程序段，沒有二義性的表達式是（ ）
class A{public:int f();};
class B{public:int g();int f();};
class C:public A,public B{ public : int g( ) ; h( ) ; } ;
C obj;
A.obj .f( )
B.obj .A : : g( )
C.obj .B : : f( )
D.obj .B : : h( )
答案：C
207.下面敘述錯誤的是（ ）
A.派生類可以使用private派生
B.對基類成員的訪問必須是無二義性的
C.基類成員的訪問能力在派生類中維持不變
D.賦值兼容規則也適用於多繼承的組合
答案：C
208.派生類的對象與基類的對象的關系是（ ）
A.屬於前者而不屬於后者
B.屬於前者，不一定屬於后者
C.不屬於前者則一定屬於后者
D.屬於前者則一定屬於后者
答案：D
209.對於下面程序段，表達式正確的是（ ）
class Base {public:int b;};
class Base1:public base{ };
class Base2:public base{ };
class Derived:public base1,public base2{public:int fun ( );};
Derived d;
A. d. Base1::b
B. d. Base ::b
C. d.b
D. d. Base :: fun( )
答案：A
210.下列程序中橫線處正確的語句應該是（ ）
＃i nclude<iostream>
using namespace std;
class Base
{
public;
void fun( ){cout< < “Base : : fun” < < endl;}
};
class Derived : public Base
{
public:
void fun( )
{
_________//顯示調用基類的函數fun( )
cout < < “Derived : : fun” < < endl;
}
};
Afun( ).
B.Base.fun( )
C.Base : : fun( )
D.Base - >fun( )
答案：C
211.虛函數必須是類的（ ）
A.成員函數
B.友元函數
C.構造函數
D.析構函數
答案：A
212.不能說明為虛函數的是（ ）
A.析構函數
B.構造函數
C.類的成員函數
D.以上都不對
答案：B
213.不同的對象可以調用相同名稱的函數，並可導致完全不同的行為的現象稱為（ ）
A.多態性
B.抽象
C.繼承
D.封裝
答案：A
214. 若析構函數是虛函數，則delete對析構函數的調用采用（ ）
A.靜態聯編
B.動態聯編
C.重載函數
D.多重函數
答案：B
215. 關於虛函數，下列表述正確的是（ ）
A.如果在重定義虛函數時使用virtual，則該重定義函數仍然是虛函數
B.虛函數不得聲明為靜態函數
C.虛函數不得聲明為另一個類的友元函數
D.派生類必須重新定義基類的虛函數
答案：B
216.下列程序段中具有相同值的是（ ）
class Base {int b;};
class Base1:virtual public base{int b1;};
class Base2:virtual public base{int b2;};
class derived:publiic base 1,public base 2{int b3;};
derived d;
A.d.b與 d.base1::b
B. d.base1::b與 d.base1::b1
C. d.b與 d. b3
D. d.base:2:b與 d.base2::b2
答案：A
虛表的理解。
217.對於公有派生，它的“訪問控制“是（ ）
A.private
B.public
C.protected
D.inaccessible
答案：B
218.關於純虛函數，下列表述正確的是（ ）
A.純虛函數是給出實現版本（即無函數體定義）的虛函數
B.純虛函數的聲明總是“=0”結束
C.派生類必須實現基類的純虛函數
D.含有純虛函數的類一定是派生類
答案：B
219.若派生類中沒有對基類的虛函數進行重定義，則它繼承基類中的（ ）
A.訪問權限
B.保護成員
C.虛函數
D.成員函數
答案：C
220.基類和派生類可以分別叫做（ ）
A.“大類”和“小類”
B.“父類”和“子類”
C.“小類”和“大類”
D.“子類”和“父類”
答案：B
221.多態調用的指（ ）
A.以任何方式調用一個虛函數
B.以任何方式調用一個純虛函數
C.借助於指向對象的基類指針或引用調用一個虛函數
D.借助於指向對象的基類指針或引用調用一個純虛函數
答案：C
多態，父類指針指向子類對象
222.若派類的成員函數不能直接訪問基類中繼承來的某個成員，則該成員一定是基類中的（ ）
A.私有成員
B.公有成員
C.保護成員
D.保護成員或私有成員
答案：A
223.對基類和派生類的描述中錯誤的是（ ）
A.派生類是基類的具體化
B.基類繼承了派生類的屬性
C.派生類是基類定義的延續
D.派生類是基類的特殊化
答案：B
224.關於抽象類，下列表述正確的是（ ）
A.抽象類的成員函數中至少有一個沒有實現的函數（即無函數體定義的函數）
B.派生類必須實現作為基類的抽象類中的純虛函數
C.派生類不可能成為抽象類
D.抽象類不能用於定義對象
答案：D
225.類B是類A的公有派生類，類A和類B中都定義了虛函數func()，p是一個指向類A對象的指針，則p->A::func()將（ ）
A.調用類A中是函數func()
B.調用類B中是函數func()
C.根據P所指的對象類型而確定調用A中或類B中的函數func()
D.既調用類A中函數，也調用類B中的函數
答案：A
p->A::func()手動指定了調用函數
226.對於類定義
class A{
public:
virtual void funcl(){}
void func2(){}
};
class B:public A{
PUBLIC:
Void func1(){cout<<”class Bfunc1”<<endl;}
Cirtual void func2(){cout<<”class B func2”<<endl;}
};
下面正確的敘述是（ ）
A.A：：func2()和B：：func1()都是虛函數
B.A：：func2()和B：：func1()都不是虛函數
C.B：：func1()是虛函數，A：：func2()不是虛函數
D.B：：func1()不是虛函數，A：：func2()是虛函數
答案：C
227.對於多重繼承，有（ ）
A.一個派生類只能有一個基類
B.一個基類只能產生一個派生類
C.一個基類必須產生多個派生類
D.一個派生類可有多個基類
答案：D
228.下列程序段中，錯誤的語句是（ ）
class A{
public:virtual void f()=0; file://(1)
void g(){f();} file://(2)
A(){f();} file://(3)
}
A.（1）
B.（2）
C.（3）
D.（1）和（2）
答案：C
在構造函數內部調用純虛接口。
229.下面程序段中，說法正確的是（ ）
class location{
public :
int GetX();
};
class rectangle:private location {
public:
int GetW();
};
A.類rectangle私有派生類 location
B.類rectangle中的public成員在類 location中是私有的
C.類location中的public成員在類 rectangle中是不可訪問的
D. viod f( ) {
Rectangle r;
Int X=r .GetX( );
}
其中int X = r .GetX( );是非法語句
答案：D
類rectangle私有派生類 location錯誤，是類location私有派生類rectangle
類rectangle中的public成員在類 location中是私有的錯誤，類location內部沒有類rectangle中的成員。
類location中的public成員在類rectangle中是不可訪問的錯誤，是不可以在類外部公開訪問的。
230.在公有派生情況下，有關派生類對象和基類對象的關系的關系，不正確的敘述是（ ）
A.派生類的對象可以賦給基類對象
B.派生類的對象可以初始化基類的引用
C.派生類的對象可以直接訪問基類的成員
D.派生類的對象的地址可以賦給指向基類的指針
答案：C
派生類的對象可以直接訪問基類的成員是錯誤的，派生類只可以訪問自身的，而不是基類的。他只是具有基類的某種性質。
231.可以用p.a的形式訪問派生類對象p 的基類成員a其中a是（ ）
A.私有繼承的公有成員
B.公有繼承的私有成員
C.公有繼承的保護成員
D.公有繼承的公有成員
答案：D
子類可以訪問的父類成員對象必須是公開繼承並且在父類中是公開的。
232.建造新的派生類是（ ）的實質。
A.派生
B.抽象
C.繼承
D.封裝
答案：C
利用繼承機制，新的類可以從已有的類中派生。那些用於派生的類稱為這些特別派生出的類的“基類”。
233.動態聯編所支持的多態性稱為（ ）
A.虛函數
B.繼承
C.編譯時的多態性
D.運行時的多態性
答案：D
編譯程序在編譯階段並不能確切知道將要調用的函數，只有在程序運行時才能確定將要調用的函數，為此要確切知道該調用的函數，要求聯編工作要在程序運行時進行，這種在程序運行時進行聯編工作被稱為動態聯編。
234．下列運算符中，（ ）運算符在C++中不能重載。
A）？：
B）+
C）-
D）〈=
答案：A
C++並不是所有的操作符都能被重載。除了. ，.* ，:: ，? : ，sizeof，typeid這幾個運算符不能被重載，其他運算符都能被重載。
235．在C++中，打開一個文件就是將這個文件與一個（ ）建立關聯；關閉一個文件就是取消這種關聯。
A）流
B）類
C）結構
D）對象
答案：A
C++中，輸入和輸出全部都是輸入流和輸出流。
236．下列關於運算符重載的描述中， （ ）是正確的。
A）運算符重載可以改變操作數的個數
B） 運算符重載可以改變優先級
C）運算符重載可以改變結合性
D）運算符重載不可以改變語法結構
答案：D
運算符重載不可以改變語法結構。語法結構是語言本身決定的，用戶無法進行改變。
237．若定義cin>>str;
當輸入
Microsoft Visual Studio 6.0!
所得的結果是str=（ ）。
A、 Microsoft Visual Studio 6.0!
B、 Microsoft
C、 Microsoft Visual
D、 Microsoft Visual Studio 6.0
答案：B
以空格作為一次有效輸入，Microsoft Visual Studio 6.0!默認為4次有效輸入。
238．有元運算符obj1〉obj2被C++編譯器解釋為（ ）。
A）operator>（obj1,obj2）
B） >(obj1,obj2)
C）jobj2.operator>(obj1)
D）obj1.operator(obj2)
答案：A
友員解釋為operator > (obj1, obj2)
成員解釋為obj1.operator>(obj2)
239．進行文件操作時需要包含（ ）頭文件。
A、 iostream
B、 fstream
C、 stdio
D、 stdlib
答案：B
fstream是文件操作的最高父類，他又包括兩個子類：ifstream和ofstream。
240．當使用ifstream流類定義一個流對象並打開一個磁盤文件時，文件的隱含打開方式為（ ）。
A）ios::in
B） ios::out
C）ios::trunc
D）ios::binary
答案：A
fstream有兩個子類：ifstream(input file stream)和ofstream(outpu file stream)，ifstream默認以輸入方式打開文件，而ofstream默認以輸出方式打開文件。
241．使用如setw()的操作符對數據進行格式輸出時，應包含（ ）文件。
A）iostream
B）fstream
C）stdio
D）iomanip
答案：D
io代表輸入輸出，manip是manipulator（操縱器）的縮寫。
iomanip的作用:
主要是對cin,cout之類的一些操縱運算子，比如setfill,setw,setbase,setprecision等等。它是I/O流控制頭文件,就像C里面的格式化輸出一樣。