C++簡單測試題共享打賞

C++主要教學內容
章節????教學內容
1?????? 面向對象及C++語言概述
2?????? C++表達式
3?????? 程序結構
4?????? 數組
5?????? 指針
6?????? 函數
7?????? 類與對象
8?????? 基類與派生類
9?????? 多態性
10??????流與文件

考試題型及分值
1、選擇??????15 * 2??共 30 分
2、填空??????15 * 2??共 30 分
3、分析理解?? 4 * 4??共 16 分 4、問答?????? 2 * 5??共 10 分
5、程序設計?? 2 * 7??共 14 分
合計 100 分

格式說明:
題號、章 難度 【答案】題目
A、選項A
B、選項B
C、選項C
D、選項D
一、選擇題

1、1A【A】輸入數據時,各數據間的分隔符有多種,錯誤的是()。
A、逗號
B、空格
C、制表
D、回車

2、1A【A】下列()是C++語言的有效標識符?
A、_No1
B、No.1
C、12345
D、int

3、1A【A】下列標識符正確的是()。
A、e2
B、MyID.
C、a(3)
D、int

4、1A【C】下列標識符正確的是()。
A、My Age
B、2L
C、Int
D、bool

5、1A【C】關于C++語言程序結構,敘述錯誤的是()。
A、函數是C++的基本功能模塊
B、程序中必不可少的一個函數是main()函數
C、程序若包含有多個函數,其他的函數必須放在main()函數的前面
D、程序是從main()函數開始執行的

6、1A【C】關于標識符,錯誤的敘述是()。
A、標識符是區分大小寫的
B、標識符可有英文字母、數字、下劃線組成
C、漢字也可作為C++標識符
D、標識符不能以數字開頭

7、1A【C】下面敘述錯誤的是()。
A、要使用數學函數,應包含頭文件math.h
B、要使用字符串函數,應包含頭文件string.h
C、要使用C語言提供的字符輸入輸出函數,應包含頭文件ctype.h
D、要使用C++流對象進行輸入輸出,應包含頭文件iostream.h

8、1A【C】在語句cin>>data;中,cin是()。
A、C++的關鍵字
B、類名
C、對象名
D、函數名

9、1A【D】C++語言對C語言做了很多改進,C++語言相對于C語言的最根本的變化是()。
A、增加了一些新的運算符
B、允許函數重載,并允許設置缺省參數
C、規定使用函數時必須用原型
D、引進了類和對象的概念

10、1A【D】要使用數學函數時,應包含的頭文件是()。
A、stdio.h
B、iostream.h
C、stdlib.h
D、math.h

11、1B【B】關于注釋,敘述錯誤的是()。
A、注釋有行注釋及塊注釋,行注釋符是“//”,塊注釋符是“/* ... */”
B、塊注釋內可以包含其他塊注釋
C、塊注釋內可以包含行注釋
D、行注釋后不可再寫其他語句

12、2A【B】關于變量,敘述錯誤的是()。
A、變量不能與C++保留字相同
B、變量沒有聲明就使用,編譯時會出現警告,但程序仍可正常執行
C、變量都有自己的存儲空間
D、變量具有不同的類型

13、2A【B】下面的整型常量,錯誤的是()。
A、12345
B、0678
C、0xABC
D、-2L

14、2A【C】設有定義int x; float v;,則10+x+v值的數據類型是()。
A、int
B、double
C、float
D、不確定

15、2A【C】下面的語句錯誤的是()。
A、char i=55;
B、char c='\n';
C、char c="G";
D、char c1,c2;

16、2A【C】字面常量42、4.2、42L的數據類型分別是()。
A、long, double, int
B、long, float , int
C、 int, double, long
D、 int, float , long

17、2A【D】假設所有變量均為整型,則表達式(a=2,b=5,b++,a+b)的值為()。
A、2
B、5
C、6
D、8

18、2A【D】下面程序的輸出結果是()。
#include<iostream.h>
void main()
{
int i=7;
double d=3.4;
cout<<i/2+(int)d/2.;
}
A、5.2
B、5
C、4.7
D、4.5

19、2B【B】若相同的字符串內容在常量區僅存儲一份。則下面的語句在運行時會顯示()。
cout<<("Ok"=="Ok");
A、0
B、1
C、false
D、true

20、2B【B】下面的整型常量,錯誤的是()。
A、123456789
B、012345678
C、0x0Ac0
D、-65536

21、2B【B】字符串常量"1\n\A"在存儲時占()個字節。
A、3
B、4
C、5
D、6

22、2C【A】下面程序的輸出結果是()。
#include<stdio.h>
void main()
{
int i=50;
printf("{%4d|%-4o|%04X}",i,i,i);
}
A、{??50|62??|0032}
B、{50|62??|0032}
C、{??50|??62|0432}
D、{??50|??62|??32}

23、2C【B】下面程序的輸出結果是()。
#include<stdio.h>
void main()
{
char c[]="How are you?";
printf("{%3s|%.3s|%-5.3s}",c,c,c);
}
A、{How|ou?|How??}
B、{How are you?|How|How??}
C、{How|How|How??}
D、{How are you?|How|??How}

24、2C【C】下面程序的輸出結果是()。
#include<stdio.h>
void main()
{
double d=3.1415926;
printf("{%f|%.3f|%7.3f}",d,d,d);
}
A、{3.1415926|3.142|??3.142}
B、{3.141592|.142|??3.142}
C、{3.141593|3.142|??3.142}
D、{3.14159|3.142|3.142??}

25、2C【D】下面的語句在運行時會顯示()。
int a=3,b=8;
if(a++==3&&b++==8);
cout<<a<<' '<<b;
A、3 8
B、3 9
C、4 8
D、4 9

26、3A【D】下面關于break語句的描述中,不正確的是()。
A、break可以用于循環體內
B、break語句可以在for循環語句中出現多次
C、break語句可以在switch語句中出現多次
D、break語句可用于if條件判斷語句內

27、3B【B】下面的語句在運行時會顯示()。
int a=3,b=8;
if(a++==3||b++==8);
cout<<a<<' '<<b;
A、3 8
B、4 8
C、3 9
D、4 9

28、3B【C】下面的語句在運行時會顯示()。
int a=3,b=8;
if(++a==3&&b++==8);
cout<<a<<' '<<b;
A、3 8
B、3 9
C、4 8
D、4 9

29、4A【A】有以下定義,則此數組中不正確的一個賦值結果是()。
int a[10]={1,2,3,4,5};
A、a[10]=2
B、a[0]=1;
C、a[3]=4;
D、a[7]=0;

30、4A【B】要定義數組A,使得其中每個元素的值依次為:
3、9、4、8、0、0、0
錯誤的定義語句是()。
A、int A[]={3,9,4,8,0,0,0};
B、int A[]={3,9,4,8};
C、int A[7]={3,9,4,8};
D、int A[7]={3,9,4,8,0,0,0};

31、4A【C】下面的()選項不能作為函數的返回類型。
A、void
B、int
C、new
D、long

32、4A【C】下面是一個完整的程序,其輸出值是()。
#include<string.h>
#include<iostream.h>
void main()
{
char a[]={'H','i','\0','b','o','b','y','\0'};
int i,j;
i=sizeof(a);
j=strlen(a);
cout<<i<<j;
}
A、12
B、22
C、82
D、83

33、4A【D】下面關于數組的描述錯誤的是()。
A、在C++語言中數組的名字就是指向該數組第一個元素的指針
B、長度為n的數組,下標的范圍是0至n-1
C、數組的大小必須在編譯時確定
D、數組只能通過值參數和引用參數兩種方式傳遞給函數

34、4A【D】要定義一個具有10個元素的整型數組,應使用()。
A、int a(10);
B、int a[];
C、int *a[10];
D、int a[10];

35、4B【B】要定義數組A,使得其中每個元素(共7個)的值依次為:
3、9、4、8、0、0、0
錯誤的定義語句是()。
A、int A[]={3,9,4,8,0,0,0};
B、int A[]={3,9,4,8};
C、int A[7]={3,9,4,8};
D、int A[7]={3,9,4,8,0,0,0};

36、4B【B】有下面的語句:
int a[][3]={{9},{2,3},{4,5,6},{7}};
問:a[2][1]的值是()。
A、0
B、5
C、6
D、2

37、4B【D】字符串常量"A\0BC"在存儲時占()個字節。
A、2
B、3
C、4
D、5

38、5A【A】有如下定義:
int *p=new int(10);
釋放申請的空間的語句是()。
A、delete p;
B、delete *p;
C、delete [] p;
D、delete [] *p;

39、5A【B】下面程序的輸出結果是()。
#include<string.h>
#include<iostream.h>
void main()
{
char *p="101\0";
cout<<strlen(p);
}
A、4
B、3
C、2
D、1

40、5A【B】下面程序段的執行結果為()。
char *p="Good\0 luck!";
cout<<p<<endl;
A、G
B、Good
C、Good luck!
D、顯示變量p的地址

41、5A【B】下面的語句在運行時會顯示()。
char *s="12345";
s+=3;
cout<<*s;
A、3
B、4
C、5
D、45

42、5A【B】下面的語句在運行時會顯示()。
int a[]={48,49,50};
cout<<*a<<endl;
A、0
B、48
C、48 49 50
D、顯示數組首元素的地址

43、5A【B】字符串"Good"的類型是()。
A、char
B、char *
C、char **
D、char *[5]

44、5A【C】對于基類型相同的兩個指針變量之間,不能進行的運算是()。
A、<
B、=
C、+
D、-

45、5A【C】若要使語句 p=new int [10]; 能夠正常執行,p 應定義為()。
A、int (*p)[];
B、int (*p)[10];
C、int *p;
D、int *p[12];

46、5A【C】下列表達式中,與a[k]等效的是()。
A、a+k
B、*a+k
C、*(a+k)
D、a+*k

47、5A【D】下面的語句在運行時會顯示()。
int a[]={48,49,50};
cout<<a<<endl;
A、0
B、48
C、48 49 50
D、顯示數組首元素的地址

48、5B【B】下列表達式中,與a[i][j]不等效的是()。
A、*(a[i]+j)
B、*(a+i)[j]
C、(*(a+i))[j]
D、*(*(a+i)+j)

49、5B【C】若要使語句 p=new int [10]; 能夠正常執行,p 應定義為()。
A、int (*p)[];
B、int (*p)[10];
C、int *p;
D、int *p[12];

50、5B【C】下面的語句在運行時會顯示()。
char a[20];
a="Good\0 morning!";
cout<<a<<endl;
A、Good
B、Good morning!
C、出現編譯錯誤
D、顯示數組首元素的地址

51、5B【D】下面的語句在運行時會顯示()。
int a[4]={1,2,3},*p=a+2;
cout<<*++p;
cout<< ' ' <<p-a;
A、1 0
B、2 1
C、3 2
D、0 3

52、5B【D】下面指針用法中正確的是()。
A、int *p=&i,i=100;
B、int i=100; char *p=&i;
C、int i,*p=100;
D、int i=100,*p=&i

53、5C【A】下面的語句在運行時會顯示()。
int *p,x,y=0;
p=&x;
*p=10;
x=*p+y;
A、10
B、11
C、12
D、不確定

54、5C【A】下面的語句在運行時會顯示()。
int a[]={48,49,50};
cout<<(char *)a<<endl;
A、0
B、48
C、012
D、出現錯誤

55、5C【A】下面的語句在運行時會顯示()。
int a[10],*p1=a,*p2=&a[9];
cout<<p2-p1;
A、9
B、36
C、不確定的值
D、出現編譯錯誤

56、5C【A】有指針p指向一維數組 int a[5];,且通過(*p)[3]可獲得數組元素,p的定義應該是()。
A、int (*p)[5]=&a;
B、int *p=a;
C、int *p[5]={a};
D、int p[5]=a;

57、5C【B】下面的語句在運行時會顯示()。
int a[3][3]={1,2,3,4,5,6,7,8,9};
int m,*p=&a[0][0];
m=*p * *(p+1) * *(p+2);
cout<<m;
A、2
B、6
C、28
D、出現錯誤

58、5C【B】下面是一個完整的程序,其運行結果是()。
#include<stdio.h>
void main()
{
char *f1="%d",*f2="%X";
int i=033;
printf(f1,i);
printf(f2,i);
}
A、3321
B、271B
C、5133
D、出現錯誤信息

59、5C【B】有定義 int a[1][2][3]; 和數組名 a 等價的指針定義是()。
A、int *p[2][3]=a;
B、int (*p)[2][3]=a;
C、int *p[1][2][3]=&a;
D、int (*p)[1][2][3]=&a;

60、5C【B】有下面的定義:
int a[2][3]={1,2,3,4,5,6};
int (*p)[3]=a+1;
則 (*p)[1]的值是()。
A、6
B、5
C、2
D、1

61、5C【C】下面的申請空間的操作,正確的是()。
A、int *p=new int*(5);
B、int (*p)[5]=new int[5];
C、int (*p)[5]=new int[5][5];
D、int **p=new int [5][5];

62、5C【C】要申請一個有10個元素的指針數組,保存到p指針,正確的是()。
A、int *p=new int *[10];
B、int (*p)[10]=new int *[10];
C、int **p=new int *[10];
D、int **p=new int [10][1];

63、5C【C】要使語句 p=new int[10][5]; 能正常執行,p 應定義為()。
A、int p[10][5];
B、int (*p)[10][5];
C、int (*p)[5]
D、int *p[5]

64、5C【C】一運行正常的程序中有這樣兩個語句:
int *p1=a,*p2;
*p2=b;
由此可知,變量a和b的類型分別是()。
A、int 和 int
B、int 和 int *
C、int * 和 int
D、int * 和 int *

65、5C【C】已知執行語句 cout<<p[0]; 后屏幕顯示的是:
Good Luck!
則p的定義應該是()。
A、char p[]="Good Luck!";
B、char *p="Good Luck!";
C、char *p[2]={"Good Luck!"};
D、char (*p)[20]="Good Luck!";

66、5C【C】有下面的定義:
int a[10][1];
數組名a的類型是()。
A、int **
B、int *[1]
C、int (*)[1]
D、int (*)[10][1]

67、5C【C】有這樣的定義 int **p=new int *[10];
要刪除申請的空間,應使用()。
A、delete p;
B、delete *p;
C、delete []p;
D、delete [] *p;

68、5C【D】若有:
int a[]={2,4,6,8,10};
int *p=a;
則值為4的數組元素,表示錯誤的是()。
A、*(a+1)
B、p[1]
C、*(p+1)
D、*p++

69、5C【D】下面的語句在運行時會顯示()。
char *p=20;
cout<<*p;
A、20
B、變量p的地址
C、不確定的值
D、出現編譯錯誤

70、5C【D】下面的語句在運行時會顯示()。
int a[4]={1,2,3},*p=a+2;
++*p;
cout<<*p++;
A、1
B、2
C、3
D、4

71、5C【D】有下面的定義:
int a[2][3]={1,2,3,4,5,6};
int (*p)[3]=a+1;
則 **p 的值是()。
A、1
B、2
C、3
D、4

72、6A【A】當一個函數無返回值時,函數類型為()。
A、void
B、int
C、double
D、省略

73、6A【A】函數重載的條件錯誤的是()。
A、不同的函數返回值類型
B、不同的參數個數
C、不同的參數類型
D、不同的參數順序

74、6A【D】不能作為重載函數的調用的依據是()。
A、參數個數
B、參數類型
C、參數順序
D、參數返回值類型

75、6A【D】關于函數,下面敘述錯誤的是()。
A、函數通過return返回函數值,沒有返回值的函數不能使用return語句。
B、實參與形參通過值傳遞方式傳遞值時,對形參值的修改不會影響對應實參的值。
C、調用函數時,實參按從右到左的順序壓入棧區并傳遞給形參
D、數組元素是按地址傳遞的方式來傳遞參數的

76、6A【D】下面關于函數返回值的敘述,錯誤的是()。
A、函數通過return返回函數值
B、一個函數體中可含多個return語句
C、return兼有計算的功能
D、無返回值時不能使用return語句

77、6A【D】下面關于函數返回值的敘述,錯誤的是()。
A、函數通過return返回函數值
B、一個函數體中可含多個return語句
C、return兼有計算的功能
D、無返回值時不能使用return語句

78、6A【D】下面是函數原型的聲明,錯誤的是()。
A、int f1(int,int,int);
B、int *f2(int a,int b);
C、int f3(int a,int b=3);
D、int f4(int a,b,c);

79、6A【D】在C++中,函數原型不能標識()。
A、函數的返回類型
B、函數參數的個數
C、函數參數的類型
D、函數的功能

80、6B【A】有下面的函數調用。該函數有()個參數。
func(a,b+c,(d,e));
A、3
B、4
C、5
D、會出現錯誤

81、6B【D】函數調用中,關于形參和實參的敘述,錯誤的是()。
A、實參可以是常量、變量或表達式
B、在函數定義時,必須指定形參的類型
C、實參和形參的類型應相同或兼容
D、修改形參的值會改變對應的實參的值

82、6C【C】已知下面的語句可以正常執行。關于p的定義,正確的是()。
p(1,2);
A、int p(int x,y);
B、int *p(int x,int y);
C、void (*p)(int,int);
D、int p[1][2];

83、7A【A】下列關于類定義的說法中,正確的是(A)。
A、類定義中可包括數據成員和函數成員
B、類成員的缺省訪問權限是protected
C、數據成員必須被聲明為private
D、函數成員只能在類體外進行定義

84、7A【B】關于析構函數,錯誤的是()。
A、析構函數沒有返回值
B、析構函數可以重載
C、析構函數應定義為public
D、析構函數的名字對一個類來說是確定的

85、7A【B】下列關于構造函數的說法,不正確的是()。
A、構造函數必須與類同名
B、拷貝構造函數不是構造函數
C、創建類對象時一定會調用構造函數
D、構造函數可以進行重載

86、7A【C】類AAA的拷貝構造函數的原形為()。
A、AAA();
B、AAA(AAA a);
C、AAA(AAA& a);
D、~AAA();

87、7A【C】下面對于友元函數描述正確的是()。
A、友元函數的實現必須在類的內部定義
B、友元函數是類的成員函數
C、友元函數破壞了類的封裝性和隱藏性
D、友元函數不能訪問類的私有成員

88、7A【C】在類的定義中,用于為對象分配內存空間,對類的數據成員進行初始化并執行其他內部管理操作的函數是()。
A、友元函數
B、虛函數
C、構造函數
D、析構函數

89、7A【D】可以用p.a的形式訪問類的成員,下面錯誤的說法是()。
A、a應是類的公有成員
B、p不能是類名
C、p不能是指向類的指針
D、p.a也可寫成this->a

90、7A【D】類的析構函數的作用是()。
A、一般成員函數的初始化
B、類的初始化
C、對象的初始化
D、類對象銷毀時的一些善后處理

91、7A【D】下列關于派生類構造函數和析構函數的說法中,錯誤的是()。
A、派生類的構造函數會隱含調用基類的構造函數
B、如果基類中沒有缺省構造函數,那么派生類必須定義構造函數
C、在建立派生類對象時,先調用基類的構造函數,再調用派生類的構造函數
D、在銷毀派生類對象時,先調用基類的析構函數,再調用派生類的析構函數

92、7A【D】以下敘述中正確的是()。
A、構成C++語言程序的基本單位是類
B、可以在一個函數中定義另一個函數
C、main()函數必須放在其他函數之前
D、所有被調用的函數一定要在調用之前進行聲明

93、7B【A】下面對靜態數據成員的描述中,正確的是()。
A、靜態數據成員是類的所有對象共享的數據
B、類的每個對象都有自己的靜態數據成員
C、類的不同對象有不同的靜態數據成員值
D、靜態數據成員不能通過類的對象調用

94、7B【D】下面()不會調用拷貝構造函數。
A、用已知的類對象初始化新定義的對象時
B、函數的形參為類類型,調用該函數時
C、函數返回值為類的對象,調用該函數時
D、函數的形參為類對象的引用,調用該函數時

95、7C【B】下列說法正確的是()。
A、內聯函數在運行時是將該函數的目標代碼插入每個調用該函數的地方
B、內聯函數在編譯時是將該函數的目標代碼插入每個調用該函數的地方
C、類的內聯函數必須在類體內定義
D、類的內聯函數必須在類體外通過加關鍵字inline定義

96、7C【D】下面對靜態數據成員的描述中,正確的是()。
A、靜態數據成員可以在類體內進行初始化
B、靜態數據成員不可以被類的對象調用
C、靜態數據成員不受private控制符的影響
D、公有的靜態數據成員可以直接用類名調用

97、8B【C】在公有派生情況下,有關派生類對象和基類對象的關系,下列敘述不正確的是()。
A、派生類的對象可以賦給基類的對象
B、派生類的對象可以初始化基類的引用
C、派生類的對象可以直接訪問基類中的成員
D、派生類的對象的地址可以賦給指向基類的指針

98、9A【A】通過運算符重載,可以改變運算符原有的()。
A、操作數類型
B、操作數個數
C、優先級
D、結合性

99、10A【B】使用輸入輸出操作符setw,可以控制()。
A、輸出精度
B、輸出寬度
C、對齊方式
D、填充字符

100、10A【D】當使用fstream流類定義一個流對象并打開一個磁盤文件時,文件的隱含打開方式為()。
A、ios::in
B、ios::out
C、ios::in|ios::out
D、以上都不對

101、10B【A】語句ofstream f("SALARY.DAT", ios::app);的功能是建立流對象f,試圖打開文件SALARY.DAT并與之連接,并且()。
A、若文件存在,將文件寫指針定位于文件尾;若文件不存在,建立一個新文件
B、若文件存在,將其置為空文件;若文件不存在,打開失敗
C、若文件存在,將文件寫指針定位于文件首;若文件不存在,建立一個新文件
D、若文件存在,打開失敗;若文件不存在,建立一個新文件

------------------------------------
格式說明:

題號、章 難度 【答案】題目

有的題目要占多行,含多個空
------------------------------------

二、填空題

1、1A C++的語句以【分號或;】作為結束標記。

2、1A C程序可由多個函數組成,其中不可缺少的是【main】函數。

3、1A void表示函數【沒有返回值】。

4、1A 開發一個C++語言程序的步驟通常包括編輯、【編譯】 、鏈接、運行和調試。

5、1A 輸出數據,要使用輸出流對象【cout】。

6、1A 輸入數據,要使用輸入流對象【cin】。

7、1A 在輸入數據時,各數據間以【空格】、制表或回車作為結束標記。

8、1B C++和C語言的最大區別在于 【C是面向過程,C++是面向對象】 。

9、2A "1" 要占用【2】個字節,而 '2' 則占用【1】個字節的存儲空間。

10、2A 13/5的值是【2】, 13%5的值是【3】。

11、2A C++中只有兩個邏輯常量:true和【false】。

12、2A 表達式 2,3,4+5的值是【9】 。

13、2A 所有運算符中優先級最低的是【逗號】運算符。

14、2A 已知a的值是2,則表達式 a+=5的值是【7】。

15、2A 已知變量x的值是3,則表達式x++ + 2的值是【5】。

16、2A 已知變量x的值是3,則表達式x+=3,x++,x+2的值是 【9】 。

17、2A 有這樣的敘述“x的值不小于5 ”,它對應的C語言表達式是【x>=5】。

18、2A 語句printf("%04X",27);的顯示結果是 【001B】 。

19、2A 執行語句int i=3.6; 后i的值是【3】。

20、2A 轉義字符'\n'的意思是【換行】。

21、2B 表達式 (double)5/2的值是【2.5】。

22、2B 表達式120 / '0'+ 12.34的值類型是【double】。

23、2B 要獲知變量所占的內存空間大小,可用運算符【sizeof】。

24、3A 程序設計的基本結構有【順序結構】、選擇結構及循環結構。

25、3A 當循環體中要包含多條語句時,要將其放在 【一對打括號或復合語句】中。

26、3A 復合語句是指【放在一對大括號中的語句】。

27、3A 某函數有返回值,則函數體內不能缺少的關鍵字是【return】。

28、3A 雙分支if語句中,else和if之間只能有一條語句,也可是 【復合】語句。

29、3A 在循環結構中用【break】語句可跳出循環,用【continue】語句可直接進入下次循環。

30、3B for語句中若省略了循環條件(表達式2)的值,則該表達式默認取【true】值。

31、3B 要顯示字符數組c首元素的地址值可用語句【cout<<(void *)c;】。

32、4A 定義字符數組c,同時用字符串"Good bye"進行初始化并確定其大小,語句為【char c[]="Good bye";】。

33、4A 數組的下標是從【0】開始的。

34、4A 數組各元素在內存中是【連續】存放的。

35、4A 數組名代表【數組首元素的地址】。

36、4A 要定義有5個元素的整型數組a,語句為【int a[5];】。

37、4A 有這樣的語句:char c[]= "Welcome"; 系統將初始化數組c的大小為【8】。

38、4A 語句char c[20]="Good morning"; c[4]=0; cout<<c;的執行結果是 【Good】 。

39、4A 在定義數組時,各維的大小必須是【整型常量】表達式。

40、4A 在引用數組元素時,對【下標】是否越界不做檢查。

41、4A 在引用數組元素時,下標可是【整型】表達式。

42、4A 在語句 int a[10]; 中,10的含義是 【整型數組a中元素的個數為10】 。

43、4B 已知a和b都是有5個元素的整型數組,則語句b=a;是【不能】正確執行的。

44、4B 語句for(int i=0;i=10;++i);將執行循環體【無限】次。

45、5A 存儲在常量區的字符串返回的是【字符串首元素的地址】。

46、5A 定義一整型指針p并用整型變量i的地址進行初始化,該語句為【int *p=&i;】。

47、5A 兩指針可進行大小的比較,但它們的【基類型】必須是相同的。

48、5A 若要訪問指針變量p所指向的數據,應使用表達式【*p】。

49、5A 要訪問某內存單元,可用該單元的名字直接訪問,也可用【指向該單元的指針】間接訪問。

50、5A 有語句int*p=new int; ,現要將該單元的值改為123,可使用語句 【*p=123;】。

51、5A 有指針變量p,則p+2的含義是【將指針往后移動兩個元素】。

52、5A 在函數中有這樣的語句來申請空間:int *p=new int[10];要釋放該空間應使用語句: 【delete [] p;】 。

53、5C 要使語句p=new double[12][5];能夠正常執行,變量p的定義應為??【double (*p)[5];】 。

54、5C 有語句char*A[1]; ,則A[0]元素中可存放【字符指針】類型的數據。

55、6A 函數A調用函數B,可將函數B的定義放在函數A的前面,也可在函數A的前面放置【函數B的函數原形】。

56、6A 函數可以作為語句單獨調用,也可【作為表達式的一部分】。

57、6A 函數有函數頭和【函數體】兩部分組成。

58、6A 函數重載的條件是 【參數個數不同、參數類型不同、參數順序不同】 。

59、6A 某函數ABC有一字符型參數,返回值是整數,該函數的原形為 【int ABC(double);】。

60、6A 某函數max返回兩個整數的較大值,其原形應為【int max(int,int);】。

61、6A 數組名作為函數的參數傳遞的是【數組首元素的地址】。

62、6A 一函數原形是void f(); ,要調用該函數,可用語句【f();】。

63、6A 已知一個函數的原型是 int fn(double a);若要以5.27為實參調用該函數,應使用表達式【fn(5.27)】。

64、6A 直接或間接調用自己的函數叫【遞歸】函數。

65、7A 定義結構類型,要使用關鍵字【struct】。

66、7A 定義一個類,要用的一個關鍵字是【class】。

67、7A 對于類中的非靜態函數成員,都包含一個默認的指針this,它代表 【調用該函數的類對象】 。

68、7A 結構數據成員的默認訪問權限是 【public】 。

69、7A 結構體的成員默認的訪問權限是【public】。

70、7A 類AAA的拷貝構造函數的原形為【AAA(AAA&);】。

71、7A 類AAA的無參構造函數的原形為【AAA();】。

72、7A 類AAA的析構構造函數的原形為【~AAA();】。

73、7A 類有數據成員,還有【函數】成員。

74、7A 要創建類AAA的對象a,應使用語句【AAA a;】。

75、7A 要聲明友元函數,須用到的關鍵字是【friend】。

76、7A 已知類AAA,則執行語句AAA a;時會調用類的【無參構造】函數。

77、7A 友元函數雖可訪問類的【私有或private】成員,但卻不是類的成員。

78、7B 要重載為類的成員,要滿足兩個條件,一是單目運算符重載,二是雙目運算符左側的操作數必須是【類對象】。

79、7C 類X的靜態整型數據成員i的初值是10,定義的方法是 【int X::i=10;】 。

80、8A 用來派生新類的類稱為【基類】,而派生出的新類稱為它的子類或派生類。

81、9A 若將一個二元運算符重載為類的成員函數,其形參個數應該是【1】個。

82、9A 要進行運算符重載,參與運算的操作數至少有一個必須是【自定義】類型。

83、9A 要重載運算符+,函數名應該是【operator+】。

84、9A 重載++運算符時,為區分前++及后++,【后++】要帶一個int類型的參數。

85、9B C++語言中的多態性分為編譯時的多態性和【運行】時的多態性。

86、9B 要重載輸出運算符<<,函數返回值類型應該是【ostream&】。

87、9B 要重載輸出運算符>>,函數返回值類型應該是【istream&】。

------------------------------------
格式說明:

題號、章 難度 題目【答案】
------------------------------------

三、理解題

1、6B 本函數的功能是【按8進制輸出一個整數】。
void display(int num)
{
if (num>=8)
display(num/8);
cout<<(num%8);
}

2、3A 本函數的功能是【計算 1+2+3+...+n的值】。
int f(int n)
{
int i,sum=0;
for(i=1;i<=n;i++)
sum+=i;
return sum;
}

3、6A 本函數的功能是【計算整型數組前n個元素的最大值】。
int Max(int p[],int n)
{
int m=p[0];
for(int i=1; i<n; i++)
if(m<p[i])
m=p[i];
return m;
}

4、3B 本程序的輸出結果是【3,8,11 7,10,6 14,9,】。
#include <iostream.h>
void main()
{
int a[8]={3,7,9,4,6,1,8,2};
for(int i=0;i<8;i++)
{
cout<<a[i]+i;
if((i+1)%3==0)
cout<<' ';
else
cout<<',';
}
}

5、3B 本程序的輸出結果是【Good morning,Xiao Wang】。
#include<iostream.h>
void main()
{
char c1[100]="Good morning,";
char c2[]="Xiao Wang";
int i=0,j=0;
while(c1[i])i++;
while(c1[i++]=c2[j++]);
cout<<c1<<endl;
}

6、3C 本程序的輸出結果是【1\11\121\1331\14641\】。
#include<stdio.h>
void main()
{
int i,j,a[5];
for(i=0;i<5;i++)
{
a[i]=1;
for(j=i-1;j>0;j--)
a[j]+=a[j-1];
for(j=0;j<=i;j++)
printf("%d",a[j]);
printf("\\");
}
}

7、4A 本程序的輸出結果是【BC++】。
#include<iostream.h>
void main()
{
char c[][10]={"Basic","Foxpro","C++"};
cout<<c[0][0]<<c[2];
}

8、4A 本程序的輸出結果是【See y】。
#include<iostream.h>
void main()
{
char s[]="See you.";
s[5]=0;
cout<<s<<endl;
}

9、5A 本程序的輸出結果是【0】。
#include<iostream.h>
void main()
{
char s[]="Fine",t[]="Fine";
cout<<(s==t);
}

10、7A 本程序的輸出結果是【03628】。
#include<iostream.h>
class rectangle
{
int w,h;
public:
rectangle(int width,int height)
{
w=width,h=height;
}
rectangle(int value)
{
w=h=value;
}
rectangle()
{
w=h=0;
}
int area()
{
return w*h;
}
};
void main()
{
rectangle r1,r2(6),r3(4,7);
cout<<r1.area()<<r2.area()<<r3.area();
}

11、7A 本程序的輸出結果是【構造20/拷貝構造40/析構30/析構20/】。

#include<iostream.h>
class A
{
int val;
public:
A(int v=0)
{
val=v;
cout<<"構造"<<val<<"/";
}
A(A &a)
{
val=a.val*2;
cout<<"拷貝構造"<<val<<"/";
}
~A()
{
cout<<"析構"<<val<<"/";
}
void set(int v)
{
val=v;
}
};
void f(A aa)
{
aa.set(30);
}
void main()
{
A a(20);
f(a);
}

12、9A 本程序的輸出結果是【4/13】。

#include<iostream.h>
class fraction??????//分數類
{
int n;??????????//分子
int d;??????????//分母
public:
fraction(int numerator=0,int denominator=1)
{
n=numerator;
d=denominator;
}
friend ostream &operator<<(ostream &out,fraction &f)
{
out<<f.n;
if(f.d!=1)out<<"/"<<f.d;
return out;
}
fraction &operator*=(fraction f2)
{
n*=f2.n;
d*=f2.d;
return *this;
}
};
void main()
{
fraction a(2,13),b(2);
cout<<(b*=a)<<endl;
}

13、3C 下面是一個完整的程序,其輸出值是【答案在本題下面】。
#include<iostream.h>
void main()
{
int i,j,k;
for(i=1,j=1,k=0;i<11;i++)
{
cout<<i;
if(++k%j==0)
cout<<endl,k=0,j++;
else
cout<<',';
}

}

【答案】
1
2,3
4,5,6
7,8,9,10

14、3B 下面程序的輸出結果是【001012】。
#include<iostream.h>
void main()
{
int i=0,j;
while(i++<4)
for(j=0;j<i;j++)
if(i<4)
cout<<j;
}

15、6C 下面程序的運行結果是【321】。
#include<iostream.h>
void s(char *p,int n)
{
if(n)
{
cout<<*(p+n-1);
s(p,n-1);
}
}
void main()
{
s("123456",3);
}

16、3A 下列程序的輸出結果是【1】。
#include<iostream.h>
int min(int a, int B)
{
if(a<B)return a;
else return B;
return 0;
}
void main()
{
cout<<min(1, min(2,3))<<endl;
}

17、8A 下面程序的運行結果為【1342】。
#include<iostream.h>
class A
{
public:
A(){ cout<<"1"; }
~A(){ cout<<"2"; }
};
class B:public A
{
public:
B(){ cout<<"3"; }
~B(){ cout<<"4"; }
};
void main()
{
B b;
}

18、5A 下列程序的輸出結果為【e】。
#include<iostream. h>
void main()
{
char a[]={"hello the word"};
char *pa=a;
pa++;
cout<<*pa<<endl;
}

19、6C 下面的函數執行后的顯示結果是【123】。
#include<iostream.h>
void display(int num)
{
if (num>=10)
display(num/10);
cout<<(num%10);
}
void main()
{
display(123);
}

20、6B 下面的程序,輸出結果是【23343】。
#include<iostream.h>
int i=2;
void main()
{
cout<<i;
int i=3;
cout<<i;
{
cout<<i;
int i=4;
cout<<i;
}
cout<<i;
}

21、4C 下面程序的輸出結果是【123ABC】。
#include<string.h>
#include<iostream.h>
void main()
{
char c[10]="123456789";
char *p="ABC";
c[3]=0;
strcat(c,p);
strcmp(c," X");
cout<<c;
}

22、3B 下面是一個完整的程序,其輸出值是【852】。
#include<iostream.h>
void main()
{
int i=10;
for(;i>0;i--)
if(i%3==0)
cout<<--i;
}

23、3B 下面是一個完整的程序,其輸出值是【3】。
#include<iostream.h>
void main()
{
int i=3;
do
{
cout<<i--;
} while(!i);
}

24、3C 下面是一個完整的程序,其輸出值是【12】。
#include<iostream.h>
void main()
{
int i,j;
for(i=1,j=1;j<50;j++)
{
if(i>10)break;
if(i%2)
{
i+=7;
continue;
}
i-=3;
}
cout<<i;
}

25、3C 下面是一個完整的程序,其輸出值是【10】。
#include<iostream.h>
void main()
{
int a[3][3]={{2},{3,4},{5,6}};
int i,j,s=0;
for(i=1;i<3;i++)
for(j=1;j<=i;j++)
s+=a[i][j];
cout<<s;
}

26、3A 下面是一個完整的程序,其輸出值是【357】。
#include<iostream.h>
void main()
{
int a[3][3]={1,2,3,4,5,6,7,8,9};
for(int i=0;i<3;i++)
cout<<a[i][2-i];
}

27、3C 下面是一個完整的程序,當輸入的數據是-7時,屏幕顯示是【Bye bye】。
#include<iostream.h>
void main()
{
int n;
cout<<"請輸入一個作整數: ";
cin>>n;
if (n>0)
if (n%2)
cout<<"輸入的是奇數!";
else
cout<<"請輸入大于0的整數!";
cout<<"Bye bye";
}

28、7B 如下程序的輸出結果是【11333】。

#include<iostream.h>
class DA{
int k;
public:
DA(int x=1){ k=x; }
~DA( ){cout<<k;}
};
void main( ){
DA d[]={DA(3),DA(3),DA(3)};
DA *p=new DA[2];
delete []p;
}

29、8B 如下程序的輸出結果是【AAB】 。
#include<iostream.h>
class CA{
public:
CA( ){ cout<<'A'; }
};
class CB:private CA{
public:
CB( ){ cout<<'B'; }
};
void main(){
CA a;
CB b;
}

------------------------------------
格式說明:

題號、章 難度 題目【答案】
------------------------------------

四、程序設計(每題7分,共14分)

1、6B 編寫函數maxCommDiv ,用來計算兩個正整數(不等于零)的最大公約數。


int GCD(int m,int n)
{
int p;
while((p=m%n)!=0)
m=n,n=p;
return n;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
2分 → 函數頭正確
3分 → 函數體正確
2分 → 正確返回值

2、3A 從鍵盤輸入一個正整數,求出它的所有因子并顯示出來,比如12的因子有1 2 3 4 6 12。


#include<iostream.h>
void main()
{
int i,n;
cout<<"請輸入一個正整數:\n";
cin>>n;
for(i=1;i<=n;i++)
if(n%i==0)cout<<i<<' ';
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

3、1A 計算鍵盤輸入的兩個整數的和、差、積,格式如下:
請輸入兩個整數:
123 456
-------------------------
123 + 456 = 579
123 - 456 = -333
123 * 456 = 56088
Press any key to continue


#include<iostream.h>
void main()
{
int a,b;
cout<<"請輸入兩個整數:\n";
cin>>a>>b;
cout<<"-------------------------\n";
cout<<a<<" + "<<b<<" = "<<a+b<<endl;
cout<<a<<" - "<<b<<" = "<<a-b<<endl;
cout<<a<<" * "<<b<<" = "<<a*b<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

4、2A 已知直角三角形的兩個直角邊,求斜邊。

#include<iostream.h>
#include<math.h>
void main()
{
double a,b;
cout<<"請輸入直角三角形的兩個直角邊:\n";
cin>>a>>b;
cout<<"\n三角形的斜邊="<<sqrt(a*a+b*b)<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
2分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
2分 → 運算及輸出

5、2A 已知“邊角邊”,計算三角形的面積。


#include<iostream.h>
#include<math.h>
void main()
{
double a,b,c,pi=3.1415926;
cout<<"請輸入三角形的兩個邊及其夾角:\n";
cin>>a>>b>>c;
cout<<"\n三角形的面積="<<a*b*sin(c*pi/180)/2<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
2分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
2分 → 運算及輸出

6、2A 分別顯示雙精度數據的整數和小數部分。


#include<iostream.h>
void main()
{
double d;
cout<<"請輸入一浮點數:";
cin>>d;
cout<<"\n整數部分="<<int(d)<<endl;
cout<<"小數部分="<<d-int(d)<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

7、2A 計算任意一個三位整數的各位數字的和。


#include<iostream.h>
void main()
{
int a,b,c,d;
cout<<"請輸入一個三位的整數:";
cin>>d;
a=d/100;????// 百位
b=d/10%10;??// 十位
c=d%10;???? // 各位
cout<<"\n各位數字的和="<<a+b+c<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

8、2B 將實數變量d 的值保留到小數點后n位。


#include<iostream.h>
#include<math.h>
void main()
{
double c,d;
int n;
cout<<"請輸入一個浮點數:";
cin>>c;
cout<<"請輸入要保留的小數位數: ";
cin>>n;
d=pow(10,n);
cout<<"\n結果="<<int(c*d+0.5)/d<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
2分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
2分 → 運算及輸出

9、2A 下面是把華氏溫度轉換為攝氏溫度的計算公式:
C=(F-32)*5/9
試根據用戶輸入的華氏溫度,計算相應的攝氏溫度。


#include<iostream.h>
void main()
{
double f,c;
cout<<"請輸入華氏溫度:\n";
cin>>f;
c=(f-32)*5/9;
cout<<"\n對應的攝氏溫度 = "<<c<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

10、2B 計算用戶輸入的兩個整數相除的結果,假設除數不為0.
請按下面顯示的樣子(括號內為商和余數)來顯示結果:
263/8=32.875 (32...7)


#include<iostream.h>
void main()
{
int i,j;
cout<<"請輸入兩個整數:\n";
cin>>i>>j;
cout<<"\n"<<i<<"/"<<j<<"="
<<double(i)/j
<<" ("
<<i/j<<"..."<<i%j<<")"<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

11、2C 將整數的 位n(0≤n≤31) 清0


#include<iostream.h>
void main()
{
int a,n;
cout<<"請輸入一個整數:??";
cin>>a;
cout<<"你想將哪一位清零: ";
cin>>n;
cout<<"\n清零后的結果="<<(a&(~(1<<n)))<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

12、2B 將用戶輸入的整數以10進制、8進制、16進制進行顯示


#include<iostream.h>
#include<stdio.h>
void main()
{
int n;
cout<<"請輸入一個整數:";
cin>>n;
printf("\n不同進制間的轉換結果為:\n");
printf("%d(10)<->0%o(8)<->0x%X(16)\n",n,n,n);
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

13、2B 由鍵盤輸入一個字符,顯示該字符及其后一個字符的ASCII碼
運行示例:
請輸入一個字符:c
------------------
字符 10進制 16進制
c???? 99???? 63
d????100???? 64


#include<iostream.h>
#include<stdio.h>
void main()
{
char c;
cout<<"請輸入一個字符:";
cin>>c;
printf("------------------\n");
printf("字符 10進制 16進制\n");
printf("%2c%8d%7X\n",c,c,c);
++c;
printf("%2c%8d%7X\n",c,c,c);
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

14、3A 計算整數n的階乘,n由鍵盤輸入(n≤10)。


#include<iostream.h>
void main()
{
int n, jc=1;
cout<<"請輸入一個正整數:\n";
cin>>n;
while(n>1) jc*=n--;
cout<<"\n它的階乘 = "<<jc<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

15、3A 計算輸入的10個整數中正數的和。


#include<iostream.h>
void main()
{
int i, c=0, cj;
cout<<"請輸入十個整數:\n";
for(i=0; i<10; ++i)
{
cin>>cj;
if(cj>0) c+=cj;
}
cout<<"其中正整數的和 = "<<c<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 運算及輸出

16、3A 將一無限大的紙對折幾次后,其高度超過喜馬拉雅山(8848米)?假設紙的厚度為0.00004米


#include<iostream.h>
void main()
{
const double mountainHeight=8848;
double paperHeight=0.00004;
int count=0;
do
{
paperHeight*=2;
count++;
} while (paperHeight<mountainHeight);
cout<<"折疊"<<count<<"次后的高度為:"<<paperHeight<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及初始化
1分 → 相應的提示信息
3分 → 運算及輸出

15、3C 顯示數據81到120,每行顯示5個,每3行間 空一行。如下所示:
0081 0082 0083 0084 0085
0086 0087 0088 0089 0090
0091 0092 0093 0094 0095

0096 0097 0098 0099 0100
0101 0102 0103 0104 0105
0106 0107 0108 0109 0110

0111 0112 0113 0114 0115
0116 0117 0118 0119 0120
Press any key to continue


#include<iostream.h>
#include<iomanip.h>
void main()
{
int i;
for(i=81; i<=120; ++i)
{
cout<<setfill('0')<<setw(4)<<i<<" ";????//顯示數據
if((i-80)%5==0)??cout<<endl;????????????//夠一行(5個數),顯示換行
if((i-80)%15==0)??cout<<endl;?????? //夠三行(15個數)再換行
}
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
2分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義
1分 → 使用setw
2分 → 運算及輸出

17、4B 輸入若干個成績,統計位于0~59、60~69、70~79、80~89、90~100各區間的個數。若成績小于0表示成績輸入結束。


#include<iostream.h>
#include<iomanip.h>
void main()
{
int i,j,cj,c[5]={0};
cout<<"請輸入成績,-1表示結束:\n";
while(true) {
cin>>cj;
if(cj<0) break;???? //退出循環
j=cj/10-5;??????????//計算索引值
if(j<0) j=0;????????//0-49分,調整索引
if(j>=5)j=4;????????//100分
++c[j];???????????? //計數增1
}
cout<<"\n\n成績分布情況如下:\n";
cout<<"??0~59,60~69,70~79,80~89,90~100\n";
for(i=0;i<5;++i)
cout<<setw(7)<<c[i];
cout<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
1分 → 數組下標的計算
2分 → 計數及輸出

18、4C 按下面的格式顯示m行*n列的二維表。


請輸入矩陣的行數及列數[3-9]:5 6

1???2???3???4???5???6
12 ?11 ?10 ? 9???8???7
13 ?14 ?15? 16 ?17 ?18
24 ?23 ?23 ?21 ?20 ?19
25 ?26 ?27 ?28 ?29 ?30
Press any key to continue

#include<iostream.h>
#include<iomanip.h>
void main()
{
int m,n,i,j,a[9][9],num=0;
cout<<"請輸入矩陣的行數及列數[3-9]:";
cin>>m>>n;
m=m<3?m=3:m>9?9:m;
n=n<3?n=3:n>9?9:n;
while(num<m*n)
{
i=num/n;
j=num%n;
if(i%2)j=n-1-j;
a[i][j]=++num;
}
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
cout<<setw(4)<<a[i][j];
cout<<endl;
}
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
1分 → 數組下標的計算
2分 → 計算及輸出

19、4B 有一排100只的鎖,編號為(1~100),100只鎖全鎖著,第1次把編號是1的倍數的鎖的狀態取反(全變為打開),第2次把編號為2的倍數的鎖狀態取反(打開的鎖上,鎖上的打開),第3次把編號為3的倍數的鎖的狀態取反,等等,把這種動作進行100次(包括第1次),請問進行100次以后有哪些編號的鎖是打開的?


#include<iostream.h>
void main()
{
int i,j,c=0,a[101]={0};
for(i=1; i<=100; ++i)?????????????? //做 100 次
for(j=i;j<=100;j+=i) ++a[j];????//改變編號是i的鎖的狀態
cout<<"開著的鎖有個:\n\t";
for(i=1; i<=100; ++i)
if(a[i]%2==1)cout<<i<<"??";???? //把開著的鎖的編號顯示出來
cout<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
3分 → 計算及輸出

20、4A 由學生對班長的工作投票評議,等次為ABCD,試統計ABCD各等次及無效的票數。
投票情況可由鍵盤直接連續輸入。比如:AAABABBCAAAADAABBBAAAACCCBBDAAACA


#include<iostream.h>
#include<string.h>
void main()
{
char pd[200];?????????????? //可調整大小以保證更多的投票人數
int i, j, l, c[5]={0};
cout<<"請輸入評定信息:\n";
cin>>pd;????????????????????//輸入字符串,各字符要連續輸入,不能用空格分隔
strupr(pd);???????????????? //將串中字符都改為大寫
l=strlen(pd);?????????????? //總票數
for(i=0; i<l; ++i)
{
j=pd[i]-'A';
if(j<0 || j>3) j=4;???? //處理無效票
++c[j];???????????????? //票數增1
}
cout<<"\n\n各等級的個數為:\n";
for(i=0; i<4; ++i)
cout<<"??"<<char('A'+i)<<": "<<c[i]<<endl;
cout<<"無效票數: "<<c[4]<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
1分 → 數組下標的計算
1分 → strlen strupu函數的使用
1分 → 計算及輸出

21、4A 由用戶輸入血型,系統顯示相應的信息。示例如下:

請輸入你的血型:AB

AB型:較討人喜歡、聰明、漂亮。
Press any key to continue

血型與性格信息
O型:為人忠誠、熱情、自信。
A型:敏感、耐心、具有親和力。
B型:你具有創造性和靈活性。
AB型:較討人喜歡、聰明、漂亮。


#include<iostream.h>
#include<string.h>
void main()
{
char *s[]={"A","B","O","AB"};?????? //已知的血型
char *m[]={???????????????????????? //各種血型的性格信息
"A型:敏感、耐心、具有親和力。\n",
"B型:你具有創造性和靈活性。\n",
"O型:為人忠誠、熱情、自信。\n",
"AB型:較討人喜歡、聰明、漂亮。\n",
"你輸入的可能是外星人的血型。\n"
};
cout<<"請輸入你的血型:";
char xx[4];
cin.getline(xx,4);??????????????????//輸入的血型
strupr(xx);???????????????????????? //轉換成大寫
int i;
for(i=0;i<4;i++)
if(stricmp(s[i],xx)==0) break;??//和已知的血型字符串比較
cout<<"\n??"<<m[i];???????????????? //顯示相應的信息
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
1分 → 數組下標的計算
1分 → strcmp cin.getline的使用
1分 → 計算及輸出

22、5A 用戶從鍵盤輸入一double類型的數據,程序按其在內存中從低到高的字節順序顯示出來


#include<iostream.h>
#include<iomanip.h>
void main()
{
int i;
double d;
cout<<"請輸入一小數:";
cin>>d;
unsigned char *p=(unsigned char *)&d;?? //強制類型轉換
cout.fill('0');???????????????????????? //設置填充字符
cout.setf(ios::uppercase|ios::hex);???? //大寫16進制輸出
for(i=0;i<sizeof(double);i++)
cout<<setw(2)<<int(*(p+i))<<" ";????//一個字節占2個16進制位
cout<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及輸入
1分 → 相應的提示信息
1分 → 強制類型轉換
2分 → 計算及輸出

23、5A 請寫一個程序,判斷處理器是Big_endian模式還是Little_endian模式的。
常見的CPU是Little Endian模式的,而某些CPU則是Big Endian模式的。
little endian和big endian是表示計算機字節順序的兩種格式。
little endian:低字節存放在低地址,高字節存放在高地址
big endian:低字節存放在高地址,高字節存放在低地址
比如:一個整數(int)0x123456在計算機內存的存放順序是不一樣的。
little endian:從低到高的順序是:56 34 12 00
big endian:從低到高的順序是:00 12 34 56


#include<iostream.h>
void main()
{
int i=1;
char *p=(char *)&i;
if(*p==1)cout<<"Little Endian\n";
else cout<<"Big Endian\n";
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出main函數
1分 → 變量定義及初始化
1分 → 強制類型轉換
3分 → 判斷及輸出

24、6B 求兩個正整數的最大公約數及最小公倍數
函數原形如下:
int GCD(int m, int n); //求m及n的最大公約數
int LCM(int m, int n); //求m及n的最小公倍數


int GCD(int m,int n)????//求m及n的最大公約數
{
int p;
while((p=m%n)!=0)
m=n,n=p;
return n;
}
int LCM(int m,int n)????//求m及n的最小公倍數
{
return m*n/GCD(m,n);
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件
1分 → 寫出函數頭
3分 → 正確寫出最大公約數的計算過程
2分 → 正確寫出最小公倍數

25、6A 利用函數重載計算面積:
已知正方形的邊長,求面積
已知矩形的兩個邊長,求矩形面積
已知長方體的三個邊長,求長方體的表面積
函數原形如下:
double area(double); ?????????????????? //正方形面積
double area(double,double); ????????????//矩形面積
double area(double,double,double);??????//長方體表面積


//函數重載的方案
#include<iostream.h>
double area(double a)?????????????????? //正方形面積
{
return a*a;
}
double area(double a,double b)??????????//矩形面積
{
return a*b;
}
double area(double a,double b,double c) //長方體表面積
{
return (a*b+b*c+c*a)*2;
}
void main()
{
cout<<area(2)<<endl;
cout<<area(2,3)<<endl;
cout<<area(2,3,4)<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 寫出main函數并驗證
6分 → 3個面積計算函數

26、7C 下面是“人”類的聲明,試給出函數的具體定義,并在程序中進行測試。
class person????????????????????//人類
{
private:
char name[20];??????????????//姓名
int age;????????????????????//年齡
public:
person(char *n="",int a=-1);//構造函數
char* GetName();????????????//獲取姓名
int??GetAge();??????????????//獲取年齡
void??Set(char*,int);?????? //設置信息
void??input();??????????????//鍵盤輸入信息
void??display();????????????//顯示信息
};


#include<iostream.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
class person????????????????????//人類
{
private:
char name[20];??????????????//姓名
int age;????????????????????//年齡
public:
person(char *n="",int a=-1);//構造函數
char* GetName();????????????//獲取姓名
int??GetAge();??????????????//獲取年齡
void??Set(char*,int);?????? //設置信息
void??input();??????????????//鍵盤輸入信息
void??display();????????????//顯示信息
};
person::person(char *n,int a)
{
Set(n,a);
}
void person::Set(char *n,int a)
{
strcpy(name,n);
age=a;
}
char* person::GetName()
{
return name;
}
int person::GetAge()
{
return age;
}
void person::input()
{
cout<<"請輸入姓名及年齡:";
cin>>name>>age;
}
void person::display()
{
printf("%-12s %3d\n",name,age);
}
void main()
{
person x1,x2("張三"),x3("李斯",18); //創建對象
x1.display();?????????????????????? //x1是無參構造函數初始化的
x2.display();?????????????????????? //x2是一個參數的構造函數初始化的
x3.display();?????????????????????? //x3是兩個參數的構造函數初始化的
x1.input();???????????????????????? //通過鍵盤輸入x1的值
x1.display();
x1.Set("楊柳依依",20);??????????????//設置x1的屬性值
cout<<"姓名:"<<x1.GetName()<<",年齡:"<<x1.GetAge()<<endl;
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
6分 → 6個成員函數
1分 → 寫出main函數并驗證

27、7B 下面的程序并不完整,試添加構造、拷貝構造、析構函數,將程序補充完整,排除錯誤。

#include<iostream.h>
#include<string.h>
class person               //人類
{
void Set(char *name,int age);    //類內調用的函數,設置人的信息
char *name;             //姓名,注意是字符指針
int age;              //年齡
};

void person::Set(char *name,int age)   //該函數已經寫好了,怎么調用它?
{
this->name=new char[strlen(name)+1];//動態分配內存
strcpy(this->name,name);      //存儲姓名
this->age=age;           //存儲年齡
}

void main()
{
person p1("那一劍的風情", 18);
person p2(p1);
}


//在類內添加下面的內容
public:
person(char *name,int age)     //構造函數
{
Set(name,age);
cout<<"構造:"<<name<<age<<endl;
}
person(person &p)          //拷貝構造函數
{
Set(p.name,p.age);
cout<<"拷貝構造:"<<name<<age<<endl;
}
~person()              //析構函數
{
cout<<"析構:"<<name<<age<<endl;
delete[]name;
}

】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → public:
2分 → 構造函數
2分 → 拷貝構造函數
2分 → 析構函數

28、10A 有一文本文件blog.txt,其中有100行sohu博客地址,如下:
1 waicpp 我愛C++
2 admin 博客管理員
3 pchxpchx 維也納春天
4 greenjiao 快樂的女兵
......

根據此生成一個文件blog.htm,文件內容如下:
1、<a href=http://waicpp.blog.sohu.com>我愛C++</a><br>
2、<a href=http://admin.blog.sohu.com>博客管理員</a><br>
3、<a href=http://pchxpchx.blog.sohu.com>維也納春天</a><br>
4、<a href=http://greenjiao.blog.sohu.com>快樂的女兵</a><br>


#include<fstream.h>
void main()
{
ifstream fin("d:\\blog.txt",ios::nocreate);
if(!fin){
cout<<"打開文件錯!\n";
return;
}
ofstream fout("d:\\blog.htm");
if(!fout){
cout<<"創建文件錯!\n";
return;
}
int i;
char blog[20];
char text[40];
while(!fin.eof())
{
fin>>i>>blog>>text;
fout<<i<<"、<a href=http://"<<blog<<".blog.sohu.com>"<<text<<"</a><br>"<<endl;
}
fin.close();
fout.close();
}
】】】】】】】】】】】】】】】】】】】】】】】】

評分標準:
1分 → 正確包含頭文件及main函數
1分 → 創建文件對象用于讀取
1分 → 創建文件對象用于寫入
1分 → 變量定義
1分 → 從文件讀取數據
1分 → 將信息寫入文件
1分 → 文件關閉

五、簡答題(每題5分,共10分)

1、2A 談談你對0、0.0、'0'、"0" 的認識

1分 → 它們都是常量
2分 → 類型不同:int、double、char、char *
2分 → 占用內存空間不同:4、8、1、2

2、6A 試述函數參數傳遞各方式的特點

2分 → 函數參數傳遞方式有:傳值、傳址、傳引用
1分 → 傳值:形參是實參的副本,修改形參對實參沒有影響
1分 → 傳址:傳遞的是實參的地址,可通過形參修改實參所指內存單元的內容
1分 → 引用:形參和實參代表相同的存儲單元,修改形參也就修改了實參

3、8A 簡述派生類對象構造與析構的過程

3分 → 構造時,現構造從基類繼承的成員,再構造派生類新增的成員
2分 → 析構時和構造的順序相反

4、2A 試舉下面每種類型的常量一個例子
bool、char、int、float、double

每個1分 → true、'c'、123、4.5f、6.78

5、7A 在哪些情況下會執行拷貝構造函數?

3分 → 用已知對象初始化新創建的對象時;
1分 → 類對象作為函數參數進行值傳遞時;
1分 → 函數返回類對象時

6、7A 友元函數有何特點?

1分 → 友元函數可訪問類的私有成員
1分 → 它不是類的成員
1分 → 它破壞了類的封裝性
1分 → 它的參數至少有一個是該類的對象或引用
1分 → 在類內聲明的位置可是任意的

7、7A 談談你對this的認識

1分 → 類的函數成員具有的默認參數
1分 → 它是一個指針
1分 → 它指向調用該成員的對象
1分 → 可用this->來訪問成員
1分 → 返回引用時用return *this;

8、3A 程序結構有哪些?

1分 → 順序結構:按語句出現的先后順序執行
2分 → 選擇結構:根據條件執行相應的分支
2分 → 循環結構:根據條件循環執行一些語句

9、1A 談談你對cin及cout的認識

1分 → cin及cout都是系統定義好的對象
2分 → cin是輸入流對象,用來輸入數據
2分 → cout是輸出流對象,用來輸出數據

10、2A C++的表達式都有哪些,各舉一個例子。

2分 → C++的表達式有算數、關系、邏輯、賦值,逗號等表達式
1分 → 算數:3+4
關系:x>3
1分 → 邏輯:x>3 && x<9
賦值:x=4
1分 → 逗號:3,4,5

11、6A 常用的字符串處理函數都有哪些?各有什么功能?

1分 → strlen:計算字符串的長度
1分 → strcpy:字符串拷貝
1分 → strcmp:字符串比較
1分 → strcat:字符串連接
1分 → strupr:將字符串轉換成大寫

12、7A 類和對象有何異同點?

2分 → 類是根據一個個具體對象的特點抽象出來的概念
2分 → 對象是類的一個實例
1分 → 每個對象都有自己的屬性值

13、6A 函數重載有哪些條件,試舉一個重載的例子。

3分 → 函數重載是依據函數的參數來進行的,要重載,必須滿足:
(1) 參數個數不同
(2) 參數類型不同
2分 → 比如:
void f(int a);
void f(int a,int b);
void f(char *p);

14、5A 下面語句中*及&分別是什么含意?
int i,*p;
p=&i;
i=3*j;
cout<<*p;
void f(int& a);

1分 → int i,*p;??????????// *表示p是指向整型數據的指針
1分 → p=&i;??????????????// &表示取其后變量i的地址
1分 → i=3*j;???????? // 這里是乘法運算符
1分 → cout<<*p;??????????// *表示取其后變量p所指單元的值
1分 → void f(int& a);????// &表示該參數的傳遞方式是傳引用

15、6A 談談你對函數局部變量的理解。

1分 → 當執行函數時,為局部變量分配存儲空間;
1分 → 函數結束時,局部變量所占的空間會被自動釋放
1分 → 不同的函數體內,同名的局部變量互不影響
1分 → 有包含關系的塊中的同名變量,外層變量在內層將不可見
1分 → 形參也屬于局部變量

16、6B 談談你對C++動態內存管理的認識。

3分 → 在很多情況下,事先并不知道要分配多少存儲空間;
分配多了,可能造成浪費,少了可能不夠用;
而動態分配則可根據需要進行內存的分配,不會造成浪費
1分 → 分配內存用new
1分 → 釋放內存用delete

17、6A 談談你對函數原形的理解。

3分 → C++程序是由函數組成的,函數間常要進行信息交流;
當函數A調用函數B時,函數B必須在函數A的前面定義;
當函數比較多,很難處理函數間的相對位置關系;
利用函數原形,你不用考慮函數間的位置關系;
1分 → 一般將函數原形放在頭文件中;
1分 → 需要調用函數時僅包含該頭文件即可,方便。

18、7A 談談你對類的構造函數、拷貝構造函數、析構函數的理解

1分 → 創建類對象時一定會調用構造函數對新對象進行初始化
1分 → 若用一個已知的對象來初始化新創建的對象,則會調用拷貝構造函數
1分 → 當對象銷毀時,需要調用析構函數進行善后處理工作
1分 → 若不提供這些函數,系統會提供默認的
1分 → 系統默認的構造及析構函數體是空的、拷貝構造完成按位復制操作

19、2A 在進行表達式計算時要注意哪些問題?

1分 → 運算符的優先級
1分 → 運算符的結合型
1分 → 運算符本身的功能
1分 → 數據類型的轉換
1分 → 表達式的值及其類型

20、4A 談談你對數組的認識。

1分 → 數組可用來存儲類型相同的數據;
1分 → 數組在計算機內是連續存放的
1分 → 定義數組時,大小必須是整型常量表達式,引用時是整型表達式
1分 → 數組一般和循環一起使用
1分 → 系統對下標是否越界不做檢查,要注意

21、7B 談談你對類的靜態成員的理解。

2分 → 靜態成員屬于類,不用創建對象即可用類名直接訪問。當然,也可通過對象調用
2分 → 靜態函數成員不能直接使用非靜態成員,只能通過對象進行操作
1分 → 靜態數據成員必須在類外定義以分配存儲空間

22、7A 已知類名是ABC,試寫出該類的無參構造函數、拷貝構造函數、析構函數的原形。

1分 → 無參構造函數??ABC();
2分 → 拷貝構造函數??ABC(ABC&);
2分 → 析構函數??????~ABC();

23、4A 談談在定義一維數組時,確定其大小與初始化的方法。

1分 → int a[10];??????????????//直接給出大小,沒有進行初始化,值不確定
2分 → int a[10]={1,2,3};??????//給出大小并進行初始化,但初始化數據個數較少,未給出值的默認為0
2分 → int a[]={1,2,3,4,5};????//未給出大小,其大小以初始化數據的個數來確定

24、1A 談談你對程序設計的認識。

根據情況給分

程序設計可是你發揮自己的想象力和創造力
對其他課程的學習都有很大的幫助
在日常工作中可提高工作效率
社會需要大量這方面的人才

25、2B 談談你對數據類型轉換的認識。

2分 → 類型轉換有兩種:自動轉換及強制類型轉換
1分 → 自動轉換完成由低類型向高精度類型的自動轉換
2分 → 強制類型轉換用于不能自動轉換的情況,其格式:
(類型)表達式
類型(表達式)
(類型)(表達式)

26、3A 談談你在編程時排錯的經驗

1分 → 程序出錯很正常,有語法錯誤及運行時錯誤兩種
2分 → 語法錯誤:有時一個地方出現錯誤,可能出現一系列相關的錯誤
查閱錯誤信息,改正查到的錯誤,再次進行編譯,可能已經沒有錯誤了
2分 → 運行時錯誤:可運用異常進行處理

27、3A 談談你對printf函數的認識

1分 → 它是C語言的輸出函數,在C++中用cout流對象進行輸出
2分 → 利用printf函數進行輸出格式控制是很方便的
2分 → 比如控制按不同的進制、指定的寬度、左右對齊、前是否補0等

C++簡單測試題共享
文章《C++簡單測試題共享》二維碼
  • 微信打賞
  • 支付寶打賞

已有2條評論

  1. Jeanne

    Uneblieavble how well-written and informative this was.

    2011-06-29 21:57 回復
  2. poorren

    改了頭像,試試效果

    2010-12-23 19:09 回復

(必填)

(必填)

(可選)

黑龙江22选5开奖