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等