《面向物件程式設計》綜合練習一（單選題）

單選題
1. C++源程式檔案的預設副檔名為(    )。
A. cpp       B. exe       C. obj       D. lik
2. 由C++源程式檔案編譯而成的目標檔案的預設副檔名為(    )。
A. cpp       B. exe       C. obj       D. lik
3. 由C++目標檔案連線而成的可執行檔案的預設副檔名為(    )。
A. cpp       B. exe       C. obj       D. lik
4. 編寫C++程式一般需經過的幾個步驟依次是(      )。
A. 編譯、編輯、連線、除錯
B. 編輯、編譯、連線、除錯
C. 編譯、除錯、編輯、連線
D. 編輯、除錯、編輯、連線
5. 以下識別符號中不全是保留字的是（    ）。
A. case    for    int
B. default  then   while
C. bool    class   long
D. goto   return  char
6. 能作為C++程式的基本單位是(    )。
A. 字元      B. 語句     C. 函式     D. 源程式檔案
7. 程式中主函式的名字為（    ）。
A. main      B. MAIN      C. Main      D. 任意識別符號
8. C++程式的基本模組為（    ）。
A. 表示式      B. 識別符號      C. 語句      D. 函式
9. 可用作C++語言使用者識別符號的一組識別符號是(    )。
A. void    define    +WORD
B. a3_b3    _123     YN
C. for      -abc      Case
D. 2a      DO      sizeof
10. 儲存以下資料，佔用儲存位元組最多的是（    ）。
A. 0      B. ‘0’      C. “0”      D. 0.0
11. 程式執行中需要從鍵盤上輸入多於一個數據時，各資料之間應使用(    )符號作為分隔符。
A. 空格或逗號      B. 逗號或回車      C. 逗號或分號      D. 空格或回車
12. 設”int a=12;”，則執行完語句”a+=a*a;”後，a的值是(    )。
A. 12      B. 144      C. 156      D. 288
13. 假設在程式中 a、b、c 均被定義成整型，所賦的值都大於1，則下列能正確表示代數式 的表示式是(    )。
A. 1.0/a*b*c    B. 1/(a*b*c)    C. 1/a/b/(float)c    D. 1.0/a/b/c
14. 設”int a=15,b=26;”，則”cout<<(a,b);”的輸出結果是(    )。
A. 15      B. 26,15      C. 15,26      D. 26
15. 設x是一個bool型的邏輯量，y的值為10，則表示式 x && y的值為（    ）。
A. 1      B. 0      C. 與x值相同      D. 與x值相反
16. x>0 && x<=10的相反表示式為（    ）。
A. x<=0 || x>10        B. x<=0 && x>10
C. x<=0 || x<=10       D. x>0 && x>10
17. x>0 || y==5的相反表示式為（    ）。
A. x<=0 || y!=5        B. x<=0 && y!=5
C. x>0 || y!=5         D. x>0 && y==5
18．設x和y均為bool量，則x && y為真的條件是(    )。
A. 它們均為真      B. 其中一個為真   
C. 它們均為假      D. 其中一個為假
19．設x和y均為bool量，則x || y為假的條件是(    )。
A. 它們均為真      B. 其中一個為真
C. 它們均為假      D. 其中一個為假
20. 字串”a+b=12/n”的長度為（    ）。
A. 6      B. 7      C. 8      D. 9
21. 假定下列x和y均為int型變數，則不正確的賦值為（    ）。
A. x+=y++      B. x++=y++      C. x=++y      D. ++x=++y
22. 下列的符號常量定義中，錯誤的定義是（    ）。
A. const M=10;         B. const int M=20;
C. const char ch;      D. const bool mark=true;
23. 迴圈語句“for(int i=0; i<n; i++) cout<<i*i<<’ ’;”中迴圈體執行的次數為(    )。
A. 1      B. n-1      C. n     D. n+1
24. 在下面迴圈語句中迴圈體執行的次數為（    ）。
for(int i=0; i<n; i++)
if(i>n/2) break;
A. n/2      B. n/2+1      C. n/2-1      D. n-1
25. 在下面迴圈語句中內層迴圈體S語句的執行總次數為（    ）。
for(int i=0; i<n; i++)
for(int j=i; j<n; j++) S;
A. n2      B. (n+1)/2      C. n(n-1)/2      D. n(n+1)/2
26. 在下面迴圈語句中迴圈體執行的次數為（    ）。
int i=0,s=0; while(s<20) {i++; s+=i;}
A. 4      B. 5      C. 6      D. 7
27. 在下面迴圈語句中迴圈體執行的次數為（    ）。
int i=0; do i++; while(i*i<10);
A. 4      B. 3      C. 5      D. 2
28. 當處理特定問題時的迴圈次數已知時，通常採用（    ）來解決。
A. for迴圈      B. while迴圈      C. do迴圈      D. switch語句
29. 迴圈體至少被執行一次的語句為（    ）。
A. for迴圈      B. while迴圈      C. do迴圈      D. 任一種迴圈
30. switch語句能夠改寫為（    ）語句。
A. for      B. if      C. do      D. while
31. do語句能夠改寫為（    ）語句。
A. 複合      B. if      C. switch     D. while
32. 在下面的一維陣列定義中，哪一個有語法錯誤。（    ）
A. int a[]={1,2,3};      B. int a[10]={0};
C. int a[];              D. int a[5];
33. 在下面的字元陣列定義中，哪一個有語法錯誤。（    ）。
A. char a[20]=”abcdefg”;      B. char a[]=”x+y=55.”;
C. char a[15];                D. char a[10]=’5’;
34. 在下面的二維陣列定義中，正確的是(    )。
A. int a[5][];                  B. int a[][5];     
C. int a[][3]={{1,3,5},{2}};    D. int a[](10);
35. 假定一個二維陣列的定義語句為“int a[3][4]={{3,4},{2,8,6}};”，則元素a[1][2]的值為（    ）。
A. 2      B. 4      C. 6      D. 8
36. 假定一個二維陣列的定義語句為“int a[3][4]={{3,4},{2,8,6}};”，則元素a[2][1]的值為（    ）。
A. 0      B. 4      C. 8      D. 6
37. 若定義了函式 double *function(), 則函式function的返回值為（    ）。
A. 實數型    B.實數的地址    C.指向函式的指標    D.函式的地址
38. 以下說法中正確的是（    ）。 
A. C++程式總是從第一個定義的函式開始執行
B. C++程式總是從main函式開始執行
C. C++函式必須有返回值，否則不能使用函式
D. C++程式中有呼叫關係的所有函式必須放在同一個程式檔案中
39. 以下敘述中不正確的是（    ）。
A. 在一個函式中，可以有多條return語句
B. 函式的定義不能巢狀，但函式的呼叫可以巢狀
C. 函式必須有返回值
D. 不同的函式中可以使用相同名字的變數
    40. 函式過載是指（    ）。
        A. 兩個或兩個以上的函式取相同的函式名，但形參的個數或型別不同
        B. 兩個以上的函式取相同的名字和具有相同的引數個數，但形參的型別可以不同
        C. 兩個以上的函式名字不同，但形參的個數或型別相同
        D. 兩個以上的函式取相同的函式名，並且函式的返回型別相同
    41. 以下關於函式模板敘述正確的是（    ）。
        A. 函式模板也是一個具體型別的函式
        B. 函式模板的型別引數與函式的引數是同一個概念
        C. 通過使用不同的型別引數，函式模板可以生成不同型別的函式
        D. 用函式模板定義的函式沒有型別
    42. 下列（    ）的呼叫方式是引用呼叫。
        A. 形參和實參都是變數          B.形參是指標，實參是地址值
        C. 形參是引用，實參是變數      D.形參是變數，實參是地址值
    43. 為了提高程式的執行速度，可將不太複雜的功能用函式實現，此函式應選擇（    ）。
        A. 行內函數  B.過載函式  C.遞迴函式  D.函式模板
    44. 函式原型語句正確的是（    ）。
        A. int Function(void a);     B.void Function (int);
        C. int Function(a);          D.void int(double a);
    45. C++中函式返回值的型別是由（    ）決定的。
        A. return語句中表達式的型別   B.該函式定義時的型別
        C.呼叫函式時的呼叫語句         D.系統根據結果
    46. 以下函式的返回結果是（    ）。
        int function(char *x) {
            char *p=x; while(*p++); return(p-x-1);
        }
        A. 求字串的長度               B.將字串x連線到字串p後面
        C. 將字串x複製到字串p中   D.將字串x反向存放
    47. 函式呼叫func((exp1,exp2),(exp3,exp4,exp5))中所含實參的個數為(    )個。
        A.  1     B.  2     C.  4     D.  5
    48. 設有如下函式定義
    int f(char *s) {
        char *p=s;
        while(*p!=’/0’) p++;
        return(p-s);
    }
    在主函式中用cout<<f(“good”)呼叫上述函式, 則輸出結果為（    ）。
        A. 3        B. 4        C. 5        D. 6
    49. 以下正確的函式原型語句是(    )。
        A. double fun(int x,int y)
        B. double fun(int x;int y)
        C. double fun(int,int);
        D. double fun(int x,y);
    50. 以下正確的說法是（    ）。
        A. 使用者呼叫標準庫函式前，必須重新定義
        B. 使用者可以重新定義標準庫函式，若如此，該函式將失去原有含義
        C. 系統不允許使用者重新定義標準庫函式
        D. 使用者呼叫標準庫函式前，不必使用預編譯命令將該函式所在檔案包括到使用者原始檔中
    51. 函式呼叫不可以（    ）。 
        A. 出現在一個表示式中
        B. 出現在執行語句中
        C. 作為一個函式的實參
        D. 作為一個函式的形參
    52. 以下正確的描述是（    ）。
        A. 函式的定義可以巢狀，函式的呼叫不可以巢狀
        B. 函式的定義不可以巢狀，函式的呼叫可以巢狀
        C. 函式的定義和函式的呼叫均可以巢狀
        D. 函式的定義和函式的呼叫均不可以巢狀
    53. 若用陣列名作為函式呼叫的實參，傳遞給形參的是（    ）。
        A. 陣列的首地址        B. 陣列中第一個元素的值
        C. 陣列全部元素的值    D. 陣列元素的個數
    54. 以下錯誤的描述是（    ）。
        A. 被呼叫函式中可以不用return語句
        B. 被呼叫函式中可以用多個return語句
        C. 被呼叫函式中，如果有返回值，就一定要有return語句
        D. 被呼叫函式中，一個return語句可返回多個值給呼叫函式
    55. 以下正確的描述是（    ）。
        A. 不允許設定引數的預設值
        B. 設定引數的預設值只能在定義函式時設定
        C. 設定引數的預設值時，應該設定右邊的引數
        D. 設定引數的預設值時，應該全部引數都設定
    56. 採用過載函式的目的是（    ）。
        A. 實現共享        B. 減少空間
        C. 提高速度        D. 使用方便，提高可讀性
    57. 將兩個字串連線起來組成一個字串時，選用（    ）函式。
        A. strlen()    B. strcap()    C. strcat()    D. strcmp()
    58. 以下敘述中正確的是(    )。
        A. 使用#define可以為常量定義一個名字，該名字在程式中可以再賦另外的值
        B. 使用const定義的常量名有型別之分，其值在程式執行時是不可改變的
        C. 在程式中使用行內函數使程式的可讀性變差
        D. 在定義函式時可以在形參表的任何位置給出預設形參值
    59. 下面的識別符號中，(    )是檔案級作用域。
        A. 函式形參  B.語句標號  C.外部靜態類識別符號  D.自動類識別符號
    60. 以下敘述不正確的是(    )。
        A. 巨集替換不佔用執行時間               B. 巨集名無型別
        C. 巨集替換隻是字元替換                 D. 巨集名必須用大寫字母表示
    61. C++語言的編譯系統對巨集命令的處理是(    )。
        A. 在程式執行時進行
        B. 在程式連線時進行
        C. 和C++程式的其它語句同時進行編譯
        D. 在對源程式中其它成分正式編譯之前進行
    62. 當#include後面的檔名用雙引號括起來時，尋找被包含檔案的方式是(    )。
        A. 直接按系統設定的標準方式搜尋目錄
        B. 先在源程式所在目錄搜尋，再按系統設定的標準方式搜尋目錄
        C. 僅僅搜尋源程式所在目錄
        D. 搜尋當前邏輯盤上的所有目錄
    63. 當#include後面的檔名用尖括號括起來時，尋找被包含檔案的方式是(    )。
        A. 直接按系統設定的標準方式搜尋目錄
        B. 先在源程式所在目錄搜尋，再按系統設定的標準方式搜尋目錄
        C. 僅僅搜尋源程式所在目錄
        D. 搜尋當前邏輯盤上的所有目錄
    64. 在下面儲存類中， (    ) 物件的可見性與生存期不一致。
        A. 外部類      B. 自動類      C. 內部靜態類      D. 暫存器類
    65. 在下面儲存類中，（    ）的物件不是區域性變數。
        A. 外部靜態類  B. 自動類      C. 函式形參        D. 暫存器類
    66. 關於區域性變數，下面說法正確的是(    )。
        A. 定義該變數的程式檔案中的函式都可以訪問
        B. 定義該變數的函式中的定義處以下的任何語句都可以訪問
        C. 定義該變數的複合語句中的定義處以下的任何語句都可以訪問
        D. 定義該變數的函式中的定義處以上的任何語句都可以訪問
    67. 檔案包含命令中被包含的檔案的副檔名（    ）。
        A. 必須是.h    B. 不能是.h    C. 可以是.h或.cpp    D. 必須是.cpp
    68. 預處理命令在程式中都是以(    )符號開頭的。
        A. *       B. #      C. &      D. @
    69. 設array為一個數組，則表示式sizeof(array)/sizeof(array[0])的結果為(    )。
        A. array陣列首地址
        B. array陣列中元素個數
        C. array陣列中每個元素所佔的位元組數
        D. array陣列佔的總位元組數
    70. 用new運算子建立一個含10個元素的一維整型陣列的正確語句是(    )。
        A. int *p=new a[10];      B. int *p=new float[10];
        C. int *p=new int[10];    D. int *p=new int[10]={1,2,3,4,5}
    71. 下列給字元陣列賦初值時，正確的是(    )。
        A. char s1[]=”abcdef”;            B. char s2[4]=”abcd”;
        C. char s3[2][3]={“abc”,”xyz”};   D. char s4[4][]={‘a’,’x’,’s’,’t’};
    72. 設有定義“static int data[5][6];”，設該陣列在靜態儲存區中的起始地址為十進位制的100，若每個int型數佔4個位元組，則陣列元素data[2][3]的地址為(    )。
        A. 115        B.124       C.130        D.160
    73. 假定變數m定義為“int m=7;”，則定義變數p的正確語句為（   ）。
        A.  int p=&m;       B.  int *p=&m;      C.  int &p=*m;     D.  int *p=m;
    74. 假定k是一個double型別的變數，則關於變數p的正確定義語句為（   ）。
        A. double p=&k;         B. int *p=&k;  
        C. double &p=*k;        D. char *p=”Thank you!”;
    75. 變數s的定義為“char *s=”Hello world!”;”，要使變數p指向s所指向的同一個字串，則應選取（   ）。
        A. char *p=s;    B. char *p=&s;    C. char *p;p=*s;   D. char *p; p=&s;
    76. 關於void 指標，下列說法正確的是（   ）。
        A. void 指標就是未指向任何資料的指標
        B. void 指標就是已定義而未初始化的指標
        C. 指向任何型別資料的指標可直接賦值給一個void 指標
        D. void 指標值可直接賦給一個非void 指標
    77. 假定一條定義語句為“int a[10], x, *pa=a;”，若要把陣列a中下標為3的元素值賦給x，則不正確的語句為（   ）。
        A. x=pa[3];      B. x=*(a+3);     C. x=a[3];       D. x=*pa+3;
    78. 假定有定義“int b[10]; int *pb;”，則不正確的賦值語句為（   ）。
        A. pb=b;       B. pb=&b[0];       C. *pb=new int;       D. pb=b[5];
    79. 假定p是具有double型別的指標變數，則表示式++p使p的值（以位元組為單位）增加（   ）。
        A. 1        B. 4        C. sizeof(double)        D. sizeof(p)
    80. 假定p指向的字串為”string”，則cout<<p+3的輸出結果為（    ）。
        A. string    B. ring       C. ing        D. i
    81. 假定p指向的字串為”string”，若要輸出這個字串的地址值，則使用（    ）。
        A. cout<<*s;  B. cout<<s;   C. cout<<&s;    D. cout<<(void *)s;
    82. 定義p並使p指向動態空間中的包含30個整數的陣列所使用的定義語句為（   ）。
        A. int *p=new int[30];        B. int *p=new int(30); 
        C. int *p=new [30];           D. *p=new int[30];
    83. 假定p是具有int**型別的指標變數，則給p賦值的正確語句為（    ）。
        A. p=new int;    B. p=new int*;    C. p=new int**;    D. p=new int[10];
    84. 要使語句“p=new int[10][20];”能夠正常執行，p應被事先定義為（   ）。
        A. int *p;   B. int **p;    C. int *p[20];    D. int(*p)[20];
    85. 假定有“struct BOOK{char title[40]; float price;}; BOOK *book=new BOOK;”，則正確的語句為（   ）。
        A. strcpy(book->title,”Wang Tao”);  B. strcpy(book.title,”Wang Tao”);   
        C. strcpy(*book.title,”Wang Tao”);  D. strcpy((*book)->title,”Wang Tao”);
    86. 假定有“struct BOOK{char title[40]; float price;}; BOOK *book;”，則不正確的語句為（   ）。
        A. BOOK *x=new book;       B. BOOK x={"C++ Programming",27.0};   
        C. BOOK *x=new BOOK;       D.  BOOK *x=book;
    87. 假定有“struct BOOK{char title[40]; float price;}book;”，則正確的語句為（   ）。
        A. BOOK &x= &book;         B. BOOK &x=book;   
        C. BOOK &x=new BOOK;       D. BOOK &x=BOOK;
    88. 下列對引用的陳述中不正確的是（   ）。
        A. 每一個引用都是其所引用物件的別名,因此必須初始化
        B. 形式上針對引用的操作實際上作用於它所引用的物件
        C. 一旦定義了引用，一切針對其所引用物件的操作只能通過該引用間接進行
        D. 不需要單獨為引用分配儲存空間
    89. 假定變數a和pa定義為“double a[10], *pa=a;”，要將12.35賦值給a中的下標為5的元素，不正確的語句是（    ）。
        A. pa[5]=12.35;      B. a[5]=12.35;
        C. *(pa+5)=12.35;    D. *(a[0]+5)=12.35;
    90. 假定變數b和pb定義為“int b[10], *pb=b;”，要將24賦值給b[1]元素中，不正確的語句是（    ）。
        A. *(pb+1)=24;     B. *(b+1)=24;    C. *++b=24;       D. *++pb=24;
    91. 假定指標變數p定義為“int *p=new int(100);”，要釋放p所指向的動態記憶體，應使用語句（    ）。
        A. delete p;     B. delete *p;     C. delete &p;     D. delete []p;
    92. 假定指標變數p定義為“int *p=new int[30];”，要釋放p所指向的動態記憶體，應使用語句（    ）。
        A. delete p;     B. delete *p;     C. delete &p;     D. delete []p;
    93. 假定變數x定義為“int x=5;”，要使rx成為x的引用（別名），rx應定義為（   ）。
        A. int rx=x;     B. int rx=&x;     C. int *rx=&x;    D. int &rx=x;
    94. 關於訊息，下列說法中不正確的是（   ）。
        A. 傳送訊息的物件請求服務，接受訊息的物件提供服務
        B. 訊息的傳送者必須瞭解訊息的接收者如何相應訊息
        C. 在C++中，訊息的傳送具體體現為對接收訊息的物件的某個函式的呼叫
        D. 每個物件只能接收某些特定格式的訊息
    95. 關於封裝，下列說法中不正確的是（   ）。
        A. 通過封裝，物件的全部屬性和操作結合在一起，形成一個整體
        B. 通過封裝，一個物件的實現細節被儘可能地隱藏起來（不可見）
        C. 通過封裝，每個物件都成為相對獨立的實體
        D. 通過封裝，物件的屬性都是不可見的
    96. 面向物件方法的多型性是指（   ）。
        A. 一個類可以派生出多個特殊類
        B. 一個物件在不同的執行環境中可以有不同的變體
        C. 針對一訊息，不同的物件可以以適合自身的方式加以響應
        D. 一個物件可以是由多個其他物件組合而成的
    97. 軟體產品在需求發生變化、執行環境發生變化或發現軟體產品本身的錯誤或不足時進行相應的軟體更新的難易程度叫做軟體的（    ）。
        A. 可維護性    B. 可複用性    C. 相容性        D. 正確性
    98. 軟體產品可被全部或部分地再用於新的應用的能力叫做軟體的（    ）。
        A. 可維護性    B. 可複用性    C. 相容性        D. 正確性
    99. 軟體產品與其他軟體產品組合成一個整體的難易程度叫做軟體的（    ）。
        A. 可維護性    B. 可複用性    C. 相容性        D. 正確性
    100. 軟體產品準確執行軟體需求規格說明書中所規定的任務的能力叫做軟體的（    ）。
        A. 可維護性    B. 可複用性    C. 相容性        D. 正確性
    101. 面向物件軟體開發中使用的OOA表示（   ）。
        A. 面向物件分析    B. 面向物件設計   
        C. 面嚮物件語言    D. 面向物件方法
    102. 面向物件軟體開發中使用的OOD表示（   ）。
        A. 面向物件分析    B. 面向物件設計   
        C. 面嚮物件語言    D. 面向物件方法
    103. 關於面向物件系統分析，下列說法中不正確的是（    ）。
        A. 術語“面向物件分析”可以用縮寫OOA表示
        B. 面向物件分析階段對問題域的描述比實現階段更詳細
        C. 面向物件分析包括問題域分析和應用分析兩個步驟
        D. 面向物件分析需要識別物件的內部和外部特徵
    104. 在一個類的定義中，包含有（   ）成員的定義。
        A. 資料      B. 函式      C. 資料和函式      D. 資料或函式
    105. 在類作用域中能夠通過直接使用該類的（   ）成員名進行訪問。
        A. 私有      B. 公用      C. 保護      D. 任何
    106. 在關鍵字public後面定義的成員為類的（   ）成員。
        A. 私有      B. 公用      C. 保護      D. 任何
    107. 在關鍵字private後面定義的成員為類的（   ）成員。
        A. 私有      B. 公用      C. 保護      D. 任何
108. 假定AA為一個類，a為該類公有的資料成員，x為該類的一個物件，則訪問x物件中資料成員a的格式為（   ）。
        A. x(a)      B. x[a]      C. x->a      D. x.a
109. 假定AA為一個類，a()為該類公有的函式成員，x為該類的一個物件，則訪問x物件中函式成員a()的格式為（   ）。
        A. x.a      B. x.a()      C. x->a      D. x->a()
110. 假定AA為一個類，a為該類公有的資料成員，px為指向該類物件的一個指標，則訪問px所指物件中資料成員a的格式為（   ）。
        A. px(a)      B. px[a]      C. px->a      D. px.a
111. 假定AA為一個類，a為該類私有的資料成員，GetValue()為該類公有函式成員，它返回a的值，x為該類的一個物件，則訪問x物件中資料成員a的格式為（   ）。
        A. x.a      B. x.a()      C. x->GetValue()      D. x.GetValue()
    112. 假定AA為一個類，int a()為該類的一個成員函式，若該成員函式在類定義體外定義，則函式頭為（   ）。
        A. int AA::a()      B. int AA:a()
        C. AA::a()          D. AA::int a()
    113. 假定AA為一個類，a為該類公有的資料成員，若要在該類的一個成員函式中訪問它，則書寫格式為（   ）。
        A. a      B. AA::a      C. a()      D. AA::a()
    114. 若需要把一個類外定義的成員函式指明為行內函數，則必須把關鍵字（   ）放在函式原型或函式頭的前面。
        A. in      B. inline      C. inLine      D. InLiner
    115. 在多檔案結構的程式中，通常把類的定義單獨存放於（   ）中。
        A. 主檔案      B. 實現檔案      C. 庫檔案      D. 標頭檔案
    116. 在多檔案結構的程式中，通常把類中所有非行內函數的定義單獨存放於（   ）中。
        A. 主檔案      B. 實現檔案      C. 庫檔案      D. 標頭檔案
    117. 在多檔案結構的程式中，通常把含有main()函式的檔案稱為（   ）。
        A. 主檔案      B. 實現檔案      C. 程式檔案      D. 標頭檔案
    118. 一個C++程式檔案的副檔名為（   ）。
        A. .h      B. .c      C. .cpp      D. .cp
    119. 在C++程式中使用的cin識別符號是系統類庫中定義的（   ）類中的一個物件。
        A. istream      B. ostream      C. iostream      D. fstream
    120. 在C++程式中使用的cout識別符號是系統類庫中定義的（   ）類中的一個物件。
        A. istream      B. ostream      C. iostream      D. fstream
    121. 假定AA是一個類，abc是該類的一個成員函式，則引數表中隱含的第一個引數的型別為（   ）。
        A. int      B. char      C. AA      D. AA*
    122. 假定AA是一個類，abc是該類的一個成員函式，則引數表中隱含的第一個引數為（   ）。
        A. abc      B. *this      C. this      D. this&
    123. 假定AA是一個類，“AA& abc();”是該類中一個成員函式的原型，若該函式存在對*this賦值的語句，當用x.abc()呼叫該成員函式後，x的值（   ）。
        A. 已經被改變       B. 可能被改變
        C. 不變             D.不受函式呼叫的影響
    124. 假定AA是一個類，“AA* abc()const;”是該類中一個成員函式的原型，若該函式返回this值，當用x.abc()呼叫該成員函式後，x的值（   ）。
        A. 已經被改變       B. 可能被改變
        C. 不變             D. 受到函式呼叫的影響
    125. 類中定義的成員預設為（   ）訪問屬性。
        A. public      B. private      C. protected      D. friend
    126. 結構中定義的成員預設為（   ）訪問屬性。
        A. public      B. private      C. protected      D. friend
    127. 當類中一個字元指標成員指向具有n個位元組的儲存空間時，它所能儲存字串的最大長度為(   )。
        A. n      B. n+1      C. n-1      D. n-2
    128. 在一個用陣列實現的佇列類中，假定陣列長度為MS，隊首元素位置為first，佇列長度為length，則隊尾（即最後一個）元素的位置為(   )。
        A. length+1                  B. first+length
        C. (first+length-1)%MS       D. (first+length)%MS
    129. 在一個用陣列實現的佇列類中，假定陣列長度為MS，隊首元素位置為first，佇列長度為length，則隊尾的後一個位置為(   )。
        A. length+1                  B. first+length
        C. (first+length-1)%MS       D. (first+length)%MS
    130. 在一個用陣列實現的佇列類中，假定陣列長度為MS，隊首元素位置為first，佇列長度為length，則隊首的後一個位置為(   )。
        A. first+1            B. (first+1)%MS
        C. (first-1)%MS       D. (first+length)%MS
    131. 在一個用連結串列實現的佇列類中，假定每個結點包含的值域用elem表示，包含的指標域用next表示，鏈隊的隊首指標用elemHead表示，隊尾指標用elemTail表示，若鏈隊非空，則進行插入時必須把新結點的地址賦給(   )。
        A. elemHead                      B. elemTail
        C. elemHead->next和elemHead     D. elemTail->next和elemTail
    132. 在一個用連結串列實現的佇列類中，假定每個結點包含的值域用elem表示，包含的指標域用next表示，鏈隊的隊首指標用elemHead表示，隊尾指標用elemTail表示，若鏈隊為空，則進行插入時必須把新結點的地址賦給(   )。
        A. elemHead                B. elemTail
        C. elemHead和elemTail     D. elemHead或elemTail
    133. 佇列具有（   ）的操作特性。
        A. 先進先出      B. 先進後出      C. 進出無序      D. 進出任意
    134. 棧具有（   ）的操作特性。
        A. 先進先出      B. 先進後出      C. 進出無序      D. 進出任意
    135. 對於一個類的建構函式，其函式名與類名(    )。
        A. 完全相同      B. 基本相同      C. 不相同      D. 無關係
    136. 對於一個類的解構函式，其函式名與類名(    )。
        A. 完全相同      B. 完全不同      C. 只相差一個字元      D. 無關係
    137. 類的建構函式是在定義該類的一個(    )時被自動呼叫執行的。
        A. 成員函式      B. 資料成員      C. 物件      D. 友元函式
    138. 類的解構函式是一個物件被(    )時自動呼叫的。
        A. 建立      B. 撤消      C. 賦值        D. 引用
    139. 一個類的建構函式通常被定義為該類的(    )成員。
        A. 公用      B. 保護      C. 私有      D. 友元
    140. 一個類的解構函式通常被定義為該類的(    )成員。
        A. 私有      B. 保護      C. 公用      D. 友元
    141. 假定AB為一個類，則執行 “AB x;”語句時將自動呼叫該類的(    )。
        A. 帶參建構函式  B. 無參建構函式   C. 拷貝建構函式   D. 賦值過載函式
    142. 假定AB為一個類，則執行 “AB x(a,5);”語句時將自動呼叫該類的(    )。
        A. 帶參建構函式  B. 無參建構函式   C. 拷貝建構函式   D. 賦值過載函式
    143. 假定AB為一個類，則執行 “AB *s=new AB(a,5);”語句時得到的一個動態物件為_______。
        A. s        B. s->a        C. s.a        D. *s
    144. 假定AB為一個類，則執行 “AB r1=r2;”語句時將自動呼叫該類的(    )。
        A. 無參建構函式  B. 帶參建構函式   C. 賦值過載函式   D. 拷貝建構函式
    145. 若需要使類中的一個指標成員指向一塊動態儲存空間，則通常在(    )函式中完成。
        A. 析構      B. 構造      C. 任一成員      D. 友元
    146. 當類中的一個整型指標成員指向一塊具有n*sizeof(int)大小的儲存空間時，它最多能夠儲存(    )個整數。
        A. n         B. n+1       C. n-1      D. 1
    147. 假定一個類的建構函式為 “A(int aa, int bb) {a=aa; b=aa*bb;}”，則執行 “A  x(4,5);”語句後，x.a和x.b的值分別為(    )。
        A. 4和5     B. 5和4      C. 4和20      D. 20和5
    148. 假定一個類的建構函式為 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，則執行 “A x(4);”語句後，x.a和x.b的值分別為(    )。
        A. 1和0     B. 1和4      C. 4和1       D. 4和0
    149. 假定AB為一個類，則(    )為該類的拷貝建構函式的原型說明。
        A. AB(AB x);    B. AB(AB& x);     C. void AB(AB& x);     D. AB(int x);
    150. 假定一個類的建構函式為 “B(int ax, int bx): a(ax), b(bx) {}”，執行 “B x(1,2),y(3,4);x=y;”語句序列後x.a的值為(    )。
        A. 1      B. 2      C. 3      D. 4
    151. 假定一個類AB只含有一個整型資料成員a，當用戶不定義任何建構函式時，系統為該類定義的無參建構函式為(    )。
        A. AB() {a=0;}            B. AB(int aa=0): a(aa) {}
        C. AB(int aa): a(aa) {}   D. AB() {}
    152. 假定一個類AB只含有一個整型資料成員a，使用者為該類定義的帶參建構函式可以為(    )。
        A. AB() {}                   B. AB(): a(0){}
        C. AB(int aa=0) {a=aa;}      D. AB(int aa) {}
    153. 對於任一個類，使用者所能定義的建構函式的個數至多為(    )。
        A. 0      B. 1      C. 2      D. 任意個
    154. 對於任一個類，使用者所能定義的解構函式的個數至多為(    )。
        A. 0      B. 1      C. 2      D. 任意個
    155. 假定AB為一個類，則執行 “AB *px=new AB[n];”語句時將(    )。
        A. 動態分配一個數組      B. 動態分配一個物件
        C. 靜態分配一個數組      D. 靜態分配一個物件
    156. 設px是指向一個類物件的指標變數，則執行 “delete px;”語句時，將自動呼叫該類的(    )。
        A. 無參建構函式    B. 帶參建構函式    C. 解構函式    D. 拷貝建構函式
    157. 當一個類物件離開它的作用域時，系統自動呼叫該類的(    )。
        A. 無參建構函式    B. 帶參建構函式    C. 拷貝建構函式  D. 解構函式
    158. 假定一個類物件陣列為A[n]，當離開它定義的作用域時，系統自動呼叫該類解構函式的次數為(    )。
        A. 0      B. 1      C. n      D. n-1
    159. 假定AB為一個類，則執行 “AB a[10];”語句時呼叫該類無參建構函式的次數為(    )。
        A. 0      B. 1      C. 9      D. 10
    160. 假定AB為一個類，則執行 “AB *px=new AB[n];”語句時呼叫該類無參建構函式的次數為(    )。
        A. n      B. n-1      C. 1      D. 0
    161. 假定AB為一個類，則執行 “AB a, b(3), *p;”語句時共呼叫該類建構函式的次數為(    )。
        A. 2      B. 3      C. 4      D. 5
    162. 假定AB為一個類，則執行 “AB a(2), b[3], *p[4];”語句時共呼叫該類建構函式的次數為(    )。
        A. 3      B. 4      C. 5      D. 9
    163. 假定AB為一個類，則執行“AB a, b(2), c[3], *p=&a;”語句時共呼叫該類無參建構函式的次數為(    )。
        A. 5      B. 6      C. 3      D. 4
    164. 假定AB為一個類，則執行“AB *p=new AB(1,2);”語句時共呼叫該類建構函式的次數為(    )。
        A. 0      B. 1      C. 2      D. 3
    165. 假定AB為一個類，px為指向該類的一個含有n個物件的動態陣列的指標，則執行“delete []px;”語句時共呼叫該類解構函式的次數為(    )。
        A. 0      B. 1      C. n      D. n+1
    166. 對類物件成員的初始化是通過建構函式中給出的(    )實現的。
        A. 函式體      B. 初始化表      C. 引數表      D. 初始化表或函式體
    167. 對類中常量成員的初始化是通過建構函式中給出的(    )實現的。
        A. 函式體      B. 引數表        C. 初始化表      D. 初始化表或函式體
    168. 對類中引用成員的初始化是通過建構函式中給出的(    )實現的。
        A. 函式體      B. 引數表        C. 初始化表      D. 初始化表或函式體
    169. 類的建構函式可以帶有(    )個引數。
        A. 0      B. 1      C. 2      D. 任意
    170. 類的解構函式可以帶有(    )個引數。
        A. 0      B. 1      C. 2      D. 任意
    171. 一個類的靜態資料成員所表示屬性 (   )。
        A. 是類的或物件的屬性          B. 只是物件的屬性
        C. 只是類的屬性                D. 類和友元的屬性
    172. 類的靜態成員的訪問控制（   ）。
        A. 只允許被定義為private
        B. 只允許被定義為private或protected 
        C. 只允許被定義為public  
        D. 可允許被定義為private、protected或public
    173. 靜態成員函式對類的資料成員訪問（    ）。
        A. 是不允許的                  B. 只允許是靜態資料成員
        C. 只允許是非靜態資料成員      D. 可允許是靜態資料成員或非靜態資料成員
    174. 被非靜態成員函式訪問的類的資料成員(  )。
        A. 可以是非靜態資料成員或靜態資料成員    B. 不可能是類的靜態資料成員
        C. 只能是類的非靜態資料成員              D. 只能是類的靜態資料成員
    175. 靜態資料成員的初始化是在（    ）中進行的。
        A. 建構函式                  B. 任何成員函式
        C. 所屬類                    D. 全域性區
    176. 當將一個類A或函式f()說明為另一個類B的友元后，類A或函式f()能夠直接訪問類B的（    ）。
        A. 只能是公有成員                      B. 只能是保護成員
        C. 只能是除私有成員之外的任何成員      D. 具有任何許可權的成員
    177. 引入友元的主要目的是為了（    ）。
        A. 增強資料安全性             B. 提高程式的可靠性
        C. 提高程式的效率和靈活性     D. 保證類的封裝性
    178. 一個類的成員函式也可以成為另一個類的友元函式，這時的友元說明（    ）。
        A. 需加上類域的限定            B. 不需加上類域的限定
        C. 類域的限定可加可不加        D. 不需要任何限定
    179. 一個類的友元不是該類的成員，與該類的關係密切，所以它（    ）。
        A. 有this指標，有預設操作的物件  
        B. 沒有this指標，可以有預設操作的物件
        C. 有this指標，不能執行預設操作
        D. 沒有this指標，也就沒有預設操作的物件
    180. 在過載一個運算子時，其引數表中沒有任何引數，這表明該運算子是（    ）。
        A. 作為友元函式過載的1元運算子         B. 作為成員函式過載的1元運算子
        C. 作為友元函式過載的2元運算子         D. 作為成員函式過載的2元運算子
    181. 在成員函式中進行雙目運算子過載時，其引數表中應帶有（    ）個引數。
        A. 0      B. 1      C. 2      D. 3
    182. 雙目運算子過載為普通函式時，其引數表中應帶有（    ）個引數。
        A. 0      B. 1      C. 2      D. 3
    183. 如果表示式a+b中的“+”是作為成員函式過載的運算子，若採用運算子函式呼叫格式，則可表示為（    ）。
        A. a.operator+(b)     B. b.operator+(a)
        C. operator+(a,b)     D. operator(a+b)
    184. 如果表示式a==b中的“==”是作為普通函式過載的運算子，若採用運算子函式呼叫格式，則可表示為（    ）。
        A. a.operator==(b)     B. b.operator==(a)
        C. operator==(a,b)     D. operator==(b,a)
    185. 如果表示式a++中的“++”是作為普通函式過載的運算子，若採用運算子函式呼叫格式，則可表示為（    ）。
        A. a.operator++()     B. operator++(a)
        C. operator++(a,1)     D. operator++(1,a)
    186. 如果表示式++a中的“++”是作為成員函式過載的運算子，若採用運算子函式呼叫格式，則可表示為（    ）。
        A. a.operator++(1)     B. operator++(a)
        C. operator++(a,1)     D. a.operator++()
    187. 關於運算子過載，下列說法正確的是（   ）。
        A. 過載時，運算子的優先順序可以改變。
        B. 過載時，運算子的結合性可以改變。
        C. 過載時，運算子的功能可以改變。
        D. 過載時，運算子的運算元個數可以改變。
    188. 關於運算子過載，下列說法正確的是（   ）。
        A. 所有的運算子都可以過載。
        B. 通過過載，可以使運算子應用於自定義的資料型別。
        C. 通過過載，可以創造原來沒有的運算子。
        D. 通過過載，可以改變運算子的優先順序。
    189. 一個程式中陣列a和變數k定義為“int a[5][10],k;”，且程式中包含有語句“a(2,5)=++k*3;”，則此語句中肯定屬於過載操作符的是（  ）。
        A. ( )     B. =      C. ++      D. *
    190. 假定K是一個類名，並有定義“K k; int j;”，已知K中過載了操作符 ( )，且語句“j=k(3);”和“k(5)=99;”都能順利執行，說明該操作符函式的原形只可能是（  ）。
        A. K operator ( ) (int);        B. int operator ( )(int&);
        C. int & operator ( )(int);     D. K &operator( )(int);
    191. 假定M是一個類名，且M中過載了操作符=，可以實現M物件間的連續賦值，如“m1=m2=m3;”。過載操作符=的函式原型最好是（  ）。
        A. int operaotor=(M);           B.  int operator=(M&);
        C. M operator=(M&);             D.  M& operator=(M);
    192. 下面是過載雙目運算子+的普通函式原形，其中最符合+原來含義的是（   ）。
        A. Value operator+(Value, Value);   B. Value operator+(Value,int);
        C. Value &operator+(Value, Value);  D. Value &operator+(Value&, Value&);
    193. 下面是過載雙目運算子-的成員函式原形，其中最符合-原來含義的是（   ）。
        A. Value Value::operator-(Value);
        B. Value Value::operator-(int);
        C. Value& Value::operator-(Value);
        D. Value& Value::operator-(Value&); 
    194. 在過載一運算子時，若運算子函式的形參表中沒有引數，則不可能的情況是（   ）。
        A. 該運算子是一個單目運算子。      
        B. 該運算子函式有一個隱含的引數this。
        C. 該運算子函式是類的成員函式。
        D. 該運算子函式是類的友元函式。
    195. 關於插入運算子<<的過載，下列說法不正確的是（   ）。
        A. 運算子函式的返回值型別是ostream & 。
        B. 過載的運算子必須定義為類的成員函式。
        C. 運算子函式的第一個引數的型別是ostream & 。
        D. 運算子函式有兩個引數。
    196. 從一個基類派生出的各個類的物件之間(    )。
       A. 共享所有資料成員，每個物件還包含基類的所有屬性
       B. 共享部分資料成員，每個物件還包含基類的所有屬性
       C. 不共享任何資料成員，但每個物件還包含基類的所有屬性
       D. 共享部分資料成員和函式成員
    197. 如果是類B在類A的基礎上構造，那麼，就稱（   ）。
       A. 類A為基類或父類，類B為超類或子類
       B. 類A為基類、父類或超類，類B為派生類或子類
       C. 類A為派生類，類B為基類
       D. 類A為派生類或子類，類B為基類、父類或超類
    198. C++的繼承性允許派生類繼承基類的（   ）。
       A. 部分特性，並允許增加新的特性或重定義基類的特性
       B. 部分特性，但不允許增加新的特性或重定義基類的特性
       C. 所有特性，並允許增加新的特性或重定義基類的特性
       D. 所有特性，但不允許增加新的特性或重定義基類的特性
    199. 派生類的成員函式可以直接訪問基類的（   ）成員。
       A. 所有         B. 公有和保護         C. 保護和私有         D. 私有
    200. 對於公有繼承，基類的公有和保護成員在派生類中將(   )成員。
       A. 全部變成公有                  B. 全部變成保護
       C. 全部變成私有                  D. 仍然相應保持為公有和保護
    201. 對於公有繼承，基類中的私有成員在派生類中將 (   )。
       A. 能夠直接使用成員名訪問        B. 能夠通過成員運算子訪問
       C. 仍然是基類的私有成員          D. 變為派生類的私有成員
    202. 當保護繼承時，基類的（    ）在派生類中成為保護成員，在類作用域外不能夠通過派生類的物件來直接訪問該成員。
       A. 任何成員                      B.公有成員和保護成員
       C. 保護成員和私有成員            D.私有成員
    203. 在定義一個派生類時，若不使用保留字顯式地規定採用何種繼承方式，則預設為（   ）方式。
       A. 私有繼承                      B. 非私有繼承
       C. 保護繼承                      D. 公有繼承
    204. 建立包含有類物件成員的派生類物件時，自動呼叫建構函式的執行順序依次為（    ）的建構函式。
       A. 自己所屬類、物件成員所屬類、基類
       B. 物件成員所屬類、基類、自己所屬類
       C. 基類、物件成員所屬類、自己所屬類
       D. 基類、自己所屬類、物件成員所屬類
    205. 當派生類中有和基類一樣名字的成員時，一般來說，（  ）。
       A. 將產生二義性              B. 派生類的同名成員將覆蓋基類的成員
       C. 是不能允許的              D. 基類的同名成員將覆蓋派生類的成員
    206. C++中的虛基類機制可以保證：（  ）。
       A. 限定基類只通過一條路徑派生出派生類
       B. 允許基類通過多條路徑派生出派生類，派生類也就能多次繼承該基類
       C. 當一個類多次間接從基類派生以後，派生類物件能保留多份間接基類的成員
       D. 當一個類多次間接從基類派生以後，其基類只被一次繼承
    207. 下列對派生類的描述中錯誤的說法是：（    ）。
       A. 派生類至少有一個基類
       B. 派生類可作為另一個派生類的基類
       C. 派生類除了包含它直接定義的成員外，還包含其基類的成員
       D. 派生類所繼承的基類成員的訪問許可權保持不變
    208. 派生類的物件對其基類中（    ）可直接訪問。
       A. 公有繼承的公有成員
       B. 公有繼承的私有成員
       C. 公有繼承的保護成員
       D. 私有繼承的公有成員

單選題參考答案:
1. A    2. C    3. B    4. B    5. B    6. C    7. A    8. D
9. B    10. D   11. D   12. C   13. D   14. D   15. C   16. A
17. B   18. A   19. C   20. B   21. B   22. C   23. C   24. B
25. D   26. C   27. A   28. A   29. C   30. B   31. D   32. C
33. D   34. C   35. C   36. A   37. B   38. B   39. C   40. A
41. C   42. C   43. A   44. B   45. B   46. A   47. B   48. B
49. C   50. B   51. D   52. B   53. A   54. D   55. C   56. D
57. C   58. B   59. C   60. D   61. D   62. B   63. A   64. C
65. A   66. C   67. C   68. B   69. B   70. C   71. A   72. D  
73. B   74. D   75. A   76. C   77. D   78. D   79. C   80. C
81. D   82. A   83. B   84. D   85. A   86. A   87. B   88. C
89. D   90. C   91. A   92. D   93. D   94. B   95. D   96. C
97. A   98. B.  99. C   100. D  101. A  102. B  103. B  104. C
105. D  106. B  107. A  108. D  109. B  110. C  111. D  112. A
113. A  114. B  115. D  116. B  117. A  118. C  119. A  120. B
121. D  122. C  123. A  124. C  125. B  126. A  127. C  128. C
129. D  130. B  131. D  132. C  133. A  134. B  135. A  136. C
137. C  138. B  139. A  140. C  141. B  142. A  143. D  144. D
145. B  146. A  147. C  148. D  149. B  150. C  151. D  152. C
153. D  154. B  155. A  156. C  157. D  158. C  159. D  160. A
161. A  162. B  163. D  164. B  165. C  166. B  167. C  168. C
169. D  170. A  171. C  172. D  173. B  174. A  175. D  176. D
177. C  178. A  179. D  180. B  181. B  182. C  183. A  184. C
185. C  186. D  187. C  188. B  189. A  190. C  191. D  192. A
193. A  194. D  195. B  196. C  197. B  198. C  199. B  200. D
201. C  202. B  203. A  204. C  205. B  206. D  207. D  208. A