##C++复习题（面向对象程序设计）
一、选择题
- C++语言属于( C )。
A） 自然语言 B） 机器语言 C）面向对象语言 D） 汇编语言 - 下面选项中不属于面向对象程序设计特征的是( C ) 。
A）继承性 B）多态性 C）相似性 D）封装性 - 可用作C++语言用户标识符的一组标识符是( B )。
A） void define +WORD B） a3_b3 _123 YN
C） for -abc Case D） 2a DO sizeof - 假定一个二维数组的定义语句为“int a[3][4]={ {3,4},{2,8,6}};”，则元素a[2][1]的值为（ A ）。
A） 0 B） 4 C） 8 D） 6 - 下列情况中，哪一种情况不会调用拷贝构造函数 （ B ）
A）用派生类的对象去初始化基类对象时
B）将类的一个对象赋值给该类的另一个对象时
C）函数的形参是类的对象，调用函数进行形参和实参结合时
D）函数的返回值是类的对象，函数执行返回调用者时 - 以下哪一关键字可用于重载函数的区分（ C ）
A）extern B）static C）const D）virtual - 下列有关数组的叙述中，正确的是（ B ）
A）C++中数组的存储方式为列优先存储
B）数组名可以作为实参赋值给指针类型的形参
C）数组下标索引从1开始，至数组长度n结束
D）数组指针的语法形式为：类型名 *数组名[下标表达式]; - 下列有关继承和派生的叙述中，正确的是( C )
A）派生类不能访问通过私有继承的基类的保护成员
B）多继承的虚基类不能够实例化
C）如果基类没有默认构造函数，派生类就应当声明带形参的构造函数
D）基类的析构函数和虚函数都不能够被继承，需要在派生类中重新实现 - 实现运行时多态的机制是（ A ）
A）虚函数 B）重载函数 C）静态函数 D）模版函数 - 若有下面的函数调用：
fun(a+b, 3, max(n-1, b));
其中实参的个数是（ A ）
A）3 B）4 C）5 D）6 - 下列关于this指针的说法正确的是（ B ）
A）this指针存在于每个函数之中
B）在类的非静态函数中this指针指向调用该函数的对象
C）this指针是指向虚函数表的指针
D）this指针是指向类的函数成员的指针 - 在下列关于C++函数的叙述中，正确的是（ C ）
A）每个函数至少要有一个参数 B）每个函数都必须返回一个值
C）函数在被调用之前必须先声明 D）函数不能自己调用自己 - 下列运算符中，不能重载的是 （ C ）
A）&& B）!= C）. D）-> - 下面程序的输出结果是（ B ）
#include
using namespace std;
int i = 0;
int fun(int n)
{
static int a = 2;
a++;
return a+n;
}
void main()
{
int k = 5;
{
int i = 2;
k += fun(i);
}
k += fun(i);
cout << k;
}
A）13 B）14 C）15 D）16 - 下面的程序段的运行结果为（ D ）
char s
tr[] = “job”, *p = str;
cout << *(p+2) << endl;
A）98 B）无输出结果 C）字符’b’的地址 D）字符’b’ - 下面程序的输出结果是（ C ）
#include
using namespace std;
class A
{
public:
A (int i) { x = i; }
void dispa () { cout << x << “,”; }
private :
int x ;
};
class B : public A
{
public:
B(int i) : A(i+10) { x = i; }
void dispb() { dispa(); cout << x << endl; }
private :
int x ;
};
void main()
{
B b(2);
b.dispb();
}
A）10,2 B）12,10 C）12,2 D）2,2 - 下面程序的输出结果是（ C ）
#include
using namespace std;
class Base
{
public:
Base(int i) { cout << i; }
~Base () { }
};
class Base1: virtual public Base
{
public:
Base1(int i, int j=0) : Base(j) { cout << i; }
~Base1() {}
};
class Base2: virtual public Base
{
public:
Base2(int i, int j=0) : Base(j) { cout << i; }
~Base2() {}
};
class Derived : public Base2, public Base1
{
public:
Derived(int a, int b, int c, int d) : mem1(a), mem2(b), Base1©,
Base2(d), Base(a)
{ cout << b; }
private:
Base2 mem2;
Base1 mem1;
};
void main() { Derived objD (1, 2, 3, 4); }
A）134122 B）123412 C）14302012 D）143212 - 下面程序的输出结果是（ C ）
#include
using namespace std;
class Base
{
public:
virtual void f() { cout << “f0+”; }
void g() { cout << “g0+”; }
};
class Derived : public Base
{
public:
void f() { cout << “f+”; }
void g() { cout << “g+”; }
};
void main() { Derived d; Base *p = &d; p->f(); p->g(); }
A）f+g+ B）f0+g+ C）f+g0+ D）f0+g0+ - 下面程序的输出结果是（ C ）
#include
using namespace std;
class Sample
{
friend long fun (Sample s)
{
if (s.x < 2) return 1;
return s.x * fun(Sample(s.x-1));
}
public:
Sample (long a) { x = a; }
private:
long x;
};
void main()
{
int sum = 0;
for (int i=0; i<4; i++)
{
sum += fun(Sample(i));
}
cout << sum;
}A）12 B）16 C）10 D）34 - 以下程序的输出结果是：（ D ）
#include
using namespace std;
int fun(char *s)
{ char *p=s;
while (*p!=’\0’) p++;
return (p-s);
}
void main(){
cout<<fun(“abc”)<<endl;
}
A．0 B. 1 C. 2 D. 3 - 有如下程序段：
int i=1;
while(1)
{
i++;
if (i10) break;
if(i%20) cout<<’’;
}
执行这个程序段输出字符的个数是( C )
A. 10 B. 3 C. 4 D.5 - 下列关于虚基类的描述中，错误的是( C )
A. 使用虚基类可以消除由多继承产生的二义性
B. 构造派生类对象时，虚基类的构造函数只被调用一次
C. 声明 class B:virtual public A 说明类B为虚基类
D. 建立派生类对象时，首先调用虚基类的构造函数 - 有下类定义
class A {
char *a;
public:
A():a(0){}
A(char *aa) {//把aa所指字符串拷贝到a所指向的存储空间
a=___________________;
strcpy(a,aa);
~A() {delete [] a;}
};
正确的选择是（ A ）
A. new char[strlen(aa)+1] B. char[strlen(aa)+1]
C. char[strlen(aa)] D. new char[sizeof(aa)-1] - 假定AA为一个类，a为该类私有的数据成员，GetValue( )为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（ D ）。
A） x.a B） x.a() C） x->GetValue() D） x.GetValue( ) - 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（ A ）。
A） int AA::a( ) B） int AA:a()
C） AA::a() D） AA::int a() - 有如下程序：
#include
using namespace std;
class Test{
public:
Test(){}
~Test(){cout<<’#’;}
};
int main(){
Test temp[2], *pTemp[2];
return 0;
}
执行这个程序输出星号（#）的个数为（ B ）。
A）1 B）2 C）3 D）4 - 有如下程序：
#include
using namespace std;
class MyClass{
public:
MyClass(int i=0){cout<<1;}
MyClass(const MyClass&x){cout<<2;}
MyClass& operator=(const MyClass&x){cout<<3; return *this;}
~MyClass(){cout<<4;}
};
int main(){
MyClass obj1(1),obj2(2),obj3(obj1);
obj1=obj2;
return 0;
}运行时的输出结果是（ A ）。
A）1123444 B）11114444 C）121444 D）11314444 - 有如下程序：
#include
using namespace std;
class point
{
public:
static int number;
public:
point() { number++;}
~point() {number–;}
};
int point::number=0;
void main()
{ point *ptr;
point A,B;
{
point *ptr_point=new point[3];
ptr=ptr_point;
}
point C;
delete[] ptr;
cout<<point::number;
}
程序结果为( A )
A）3 B）4 C）6 D）7 - 友元运算符obj++被C++编译器解释为（ B ）。
A. operator++(obj) B. operator++(obj,0)
C. obj.operator++( ) D. obj.operator++(0)
二、程序填空
1．用递归法求从1到n的立方和：
f(1)=1 (n=1)
f(n)=f(n-1)+n3 (n>1)
#include
using namespace std;
int f(int);
int main(){
int n,s;
cout<<“input the number n:”;
cin>>n;
s= f(n) ;
cout<<“The result is “<<s<<endl;
return 0;
}
int f(int n){ //递归法求立方和函数
if ( n==1 ) return 1;
else return ( f(n-1)+nnn );
}
- 请将下列程序补充完整，使得输出结果为“Destructor Derived Destructor Base”。
#include
using namespace std;
class Base
{
public:
virtual ~Base () { cout << “Destructor Base”<< endl; }
};
class Derived : public Base
{
public:
~Derived(){ cout << “Destructor Derived” << endl; }
}；
void main ()
{
Base *pBase = new Derived;
delete pBase ;
}
三、阅读程序，写出运行结果
#include
#include
using namespace std;
class CD
{
char name[20];
int number;
public:
void Init(char* aa, int bb)
{
strcpy(name,aa);
number=bb;
}
char* Getname () {return name;}
int Getnumber () {return number;}
void Output() {cout<< name <<’ ‘<< number <<endl;}
};
CD dx;
void main()
{
CD dy;
dx.Init(“歌唱祖国”,30);
dy.Init(“义勇军进行曲”,3*dx.Getnumber ()+5);
dx.Output();
dy.Output();
}
歌唱祖国 30
义勇军进行曲 95
2．#include
using namespace std;
int f(int a){
return ++a;
}
int g(int& a){
return ++a;
}
void main(){
int m=0,n=0;
m+=f(g(m));
n+=f(f(n));
cout<<“m=”<<m<<endl;
cout<<“n=”<<n<<endl;
} m=3
n=2
3. #include
using namespace std;
class Demo
{
public:
Demo(){cout<<“default constructor\n”;}
Demo(const Demo &x){cout<<“copy constructor\n”;}
};
Demo userCode(Demo b){Demo c(b);return c;}
void main()
{
Demo a,d;
cout<<“calling userCode()\n”;
d = userCode(a);
}
执行上面的程序的过程中，构造函数Demo()和Demo(const Demo &x)被调用的次数分别是多少次？ 2 3
五、编写程序
1、编写函数计算y=1!+2!+3!..n! ，n作为参数传递，在主函数调用该函数并输出结果。
2、编写函数找出二维数组（5*4）中元素的最大值与最小值，并返回其最大值与最小值。测试结果。
3、编写一个三角形类，有计算面积，显示面积的功能等，并测试。要求有参数的构造函数及复制构造函数
C++复习题
一、单选题
1．C++语言对c语言做了很多改进，c++语言相对于C语言的最根本的变化是（ D ）
A. 增加了一些新的运算符
B. 允许函数重载，并允许设置缺省参数
C. 规定函数说明符必须用原型
D. 引进了类和对象的概念
2．下列哪个是c++语言的有效标识符? （ A ）
A. -N01 B. No.1 C. 12345 D. int
3．下面程序的运行结果为（ C ）
#include<iostream.h>
void main()
{
for(int a=0,x=0;!x && a<=10;a++)
{ a++;
}
cout<<a<<endl;
}
A. 10 B. 11 C. 12 D. 0
4．下列选项，语法不正确的是（ B ）
A. for(int a=1;a<=10;a++)；
B. int a=1;do { a++； }while(a<=10)
C. int a=1;while(a<=10) { a++; }
D. for(int a=1；a<=10；a++)a++；
5．下列程序的输出结果为（ B ）
#include<iostream.h>
void main()
{
char *a[]={“hello”,“the”,“world”};
char **pa=a;
pa++;
cout << pa << endl;
}
A. hello B. the C. world D. hellotheworld
6．决定C++语言中函数的返回值类型的是（ D ）
A. return语句中的表达式类型
B. 调用该函数时系统随机产生的类型
C. 调用该函数时的主调用函数类型
D. 在定义该函数时所指定的数据类型
7．下列程序的输出结果是（ B ）
#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;
}
A. 0 B. 1 C. 2 D. 3
8．对类成员访问权限的控制，是通过设置成员的访问控制属性实现的，下列不是访问控制属性的是（ D ）
A. 公有类型 B. 私有类型 C. 保护类型 D. 友元类型
9．在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是（ C ）
A. 友元函数 B. 虚函数 C. 构造函数 D. 析构函数
10．类的析构函数的作用是（ D ）
A. 一般成员函数的初始化 B. 类的初始化
C. 对象的初始化 D.对象生存器结束时作些清理工作
11．下列说法正确的是（ B ）
A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方
B. 内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方
C. 类的内联函数必须在类体内定义
D. 类的内联函数必须在类体外通过加关键字inline定义
12．下面对静态数据成员的描述中，正确的是( D )
A. 静态数据成员可以在类体内进行初始化
B. 静态数据成员不可以被类的对象调用
C. 静态数据成员不能受private控制符的作用
D. 静态数据成员可以直接用类名调用
13．下面对于友元函数描述正确的是( C )
A. 友元函数的实现必须在类的内部定义
B. 友元函数是类的成员函数
C. 友元函数破坏了类的封装性和隐藏性
D. 友元函数不能访问类的私有成员
14．在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是( C )
A. 派生类的对象可以赋给基类的对象
B. 派生类的对象可以初始化基类的引用
C. 派生类的对象可以直接访问基类中的成员
D. 派生类的对象的地址可以赋给指向基类的指针
15．下列关于虚基类的描述，错误的是( B )
A. 设置虚基类的目的是为了消除二义性
B. 虚基类的构造函数在非虚基类之后调用
C. 若同一层中包含多个虚基类，这些虚基类的构造函数按它们说明的次序调用
D. 若虚基类由非虚基类派生而来，则仍然先调用基类构造函数，再调用派生类的构造函数
16．下列关于多态性的描述，错误的是( C )
A. C++语言的多态性分为编译时的多态性和运行时的多态性
B. 编译时的多态性可通过函数重载实现
C. 运行时的多态性可通过模板和虚函数实现
D. 实现运行时多态性的机制称为动态绑定
17．下列运算符中，在C++语言中不能重载的是( C )
A. ++ B. >= C. ：： D./
18．下面关于类和对象的描述中，错误的是( A )
A. 类就是c语言中的结构体类型，对象就是C语言中的结构体变量
B. 类和对象之间的关系是抽象和具体的关系
C. 对象是类的实例，一个对象必须属于一个已知的类
D. 类是具有共同行为的若干对象的统一描述体
19．下面关于break语句的描述中，不正确的是( D )
A. break可以用于循环体内
B. break语句可以在for循环语句中出现多次
C. break语句可以在switch语句中出现多次
D. break语句可用于if条件判断语句内
20．下面关于数组的描述错误的是( D )
A. 在c++语言中数组的名字就是指向该数组第一个元素的指针
B. 长度为n的数组，下标的范围是0—n-l
C. 数组的大小必须在编译时确定
D. 数组只能通过值参数和引用参数两种方式传递给函数
21．下面程序错误的语句是( B )
①#include<iostream.h>
②void main()
③{
④ int p=new int[1];
⑤ p=9;
⑥ cout << p <<endl;
⑦ delete[] p;
⑧}
A. ④ B. ⑤ c. ⑥ D. ⑦
22．下面的哪个选项不能作为函数的返回类型?( C )
A. void B. int C. new D. long
23．下列程序的输出结果为( D )
#include<iostream.h>
int func(int n)
{
if(n<1)return 1;else return n+func(n-1);
return 0;
}
void main()
{
cout<<func(5)<<endl;
}
A. 0 B. 10 C. 15 D. 16
24．在C++语言中，数据封装要解决的问题是( D )
A. 数据的规范化 B. 便于数据转换
C. 避免数据丢失 D. 防止不同模块之间数据的非法访问
25．对类的构造函数和析构函数描述正确的是( A )
A. 构造函数可以重载，析构函数不能重载
B. 构造函数不能重载，析构函数可以重载
c. 构造函数可以重载，析构函数也可以重载
D. 构造函数不能重载，析构函数也不能重载
26．下面对静态数据成员的描述中，正确的是( A )
A. 静态数据成员是类的所有对象共享的数据
B. 类的每个对象都有自己的静态数据成员
C. 类的不同对象有不同的静态数据成员值
D. 静态数据成员不能通过类的对象调用
27．如果类A被说明成类B的友元，则( D )
A. 类A的成员即类B的成员
B. 类B的成员即类A的成员
C. 类A的成员函数不得访问类B的成员
D. 类B不一定是类A的友元
28．下面关于虚函数的描述，错误的是( B )
A. 在成员函数声明的前面加上virtual修饰，就可把该函数声明为虚函数
B. 基类中说明了虚函数后，派生类中对应的函数也必须说明为虚函数
C. 虚函数可以是另一个类的友元函数，但不能是静态成员函数
D. 基类中说明的纯虚函数在其任何派生类中都必须实现
29．下面程序的运行结果是( C )
#include<iostream.h>
void main()
{
int num=1;
int &ref=num;
ref=ref+2;
cout<<num;
num=num+3;
cout<<ref<<endl;
}
A. 13 B. 16 C. 36 D. 33
30．下面关于c++语言的描述错误的是( B )
A） C++语言支持数据封装
B） C++语言中引入友元没有破坏封装性
C） C++语言允许函数名和运算符重载
D） C++语言支持动态联编
31．下列程序的运行结果为( B )
#include<iostream.h>
void main()
{
int a=2;
int b=a+1;
cout <<a/b<<endl;
}
A. 0.66667 B. 0 C. 0.7 D. 0.66666666…
32．设int a=1,b=2;，则(a++)+b和a+++b这两个表达式的值分别为( A )
A. 3,3 B. 3,4 C. 4,3 D. 4,4
33．下面程序的运行结果为( D )
#include<iostream.h>
void main()
{ char a=‘3’;
switch(a)
{
case’3’:cout<<“3”;
case’2’:cout<<“2”;break;
default:cout<<“1”;
}
}
A. 3 B. 321 C. 31 D. 32
34．存在定义int a[10]，x,pa；，若pa=&a[0]，下列的哪个选项和其他3个选项不是等价的?( A )
A. x=pa； B. x=(a+1)； C. x=(pa+1)； D. x=a[1]；
35．下面程序的运行结果为 ( D )
#include<iostream.h>
void swap(int &a,int b)
{ int temp;
temp=a++;
a=b;b=temp;
}
void main()
{ int a=2,b=3;swap(a,b);
cout << a << “，”<< b <<endl;
}
A. 2，3 B. 3，2 C. 2，2 D. 3，3
36．下面关于C++语言变量的叙述错误的是( B )
A. 在C++语言中变量分为auto，static，extern和register四种存储类型
B. 自动变量和外部变量的作用域为整个程序
C. 内部静态变量的作用域是定义它的函数
D. 外部静态变量的作用域是定义它的文件
37．为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为( A )
A. public B. protected C. private D. static
38．在C++语言程序中，对象之间的相互通信通过( B )
A. 继承实现 B. 调用成员函数实现
C. 封装实现 D. 函数重载实现
39．类的析构函数是在什么时候调用的?( C )
A. 类创建时 B. 创建对象时 C. 删除对象时 D. 不自动调用
40．通常拷贝构造函数的参数是( C )
A. 某个对象名 B. 某个对象的成员名
C. 某个对象的引用名 D. 某个对象的指针名
41．在C++语言类体系中，不能被派生类继承的有( B )
A. 转换函数 B. 构造函数 C. 虚函数 D. 静态成员函数
42．试题内容：对于类定义, 下面正确的叙述是( C )
class A{ public：
virtual void funcl(){}
void func2(){}
}；
class B：public A
{ public：
void funcl(){cout<<”class B func 1”<<endl；}
viauM void func2(){cout<<”class B func 2”<<endl；}
}；
A）A：：func2()和B：：funcl()都是虚函数
B）A：：func2()和B：：funcl()都不是虚函数
C）B：：funcl()是虚函数，而A：：func2()不是虚函数
D） B：：funcl()不是虚函数，而A：：fune2()是虚函数
43．与语句cout<<endl；不等价的是( D )
A. cout<<’\n’； B. cout<<’\012’； C. cout<<’\xA’； D. cout<<’\0’；
44．下面程序的运行结果是( C )
#include<iostream.h>
void main()
{
int i=1;
while(i<=8)
if(++i%3!=2) continue;
else cout << i;
}
A. 25 B. 36 C. 258 D. 369
45．已知有定义, 则下列选项错误的是( B )
const int D=5;
int i=1;
double f=0.32;
char c=15;
A. ++i； B. D–； C. c++； D. –f
46．下面程序的功能是把316表示为两个加数的和，使两个加数分别能被13和11整除，在划线处应填入的选项是( B )
#include<iostream.h>
void main()
{
int i=0,j,k;
do{i++;k=316-13i;}
while( );
j=k/11;
cout << “316=13“<< i << “+11“<< j;
}
A. k/11 B. k％11 C. k/110 D. k％110
47．设有数组定义：char array[]=”China”；，则数组array所占的空间为( C )
A. 4个字节 B. 5个字节 C. 6个字节 D. 7个字节
48．下列描述中哪个是正确的?( b )
A. 私有派生的子类无法访问父类的成员
B. 类A的私有派生子类的派生类C无法初始化其祖先类A对象的属性，因为类A的成员对类C是不可访问的
C. 私有派生类不能作为基类派生子类
D. 私有派生类的所有子孙类将无法继续继承该类的成员
49．下列关于构造函数说法不正确的是( C )
A. 构造函数必须与类同名
B. 构造函数可以省略不写
C. 构造函数必须有返回值
D. 在构造函数中可以对类中的成员进行初始化
50．如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是( D )
A. 一元运算符 B. 二元运算符
C. 选项A)和选项B)都可能 D. 重载错误
51．下面程序的输出结果是 ( C )
#include<iostream．h>
class example
{ int a;
public：example(int b){a=b++；}
void print(){a=a+1；cout<<a<<””；}
void print()const{cout<<a<<””；}
}；
void main()
{ example x(3)；const example y(2)；x.print()；y.print()；
}
A. 2 2 B. 4 3 C. 4 2 D. 3 2
二、填空题
1．在面向对象的程序设计中，类描述的是具有相似性质的一组 ________________。
正确答案：对象
2．继承的方式有公有继承、______________和______________3种。
正确答案：私有继承、保护继承
3．对于下面定义的类MyClass，请在函数f()中添加语句把n的值修改为50。
class MyClass
{ public：
MyClass(int x){n=x；}
void SetNum(int n1){n=nl；}
private：int n；
}；
void f()
{ MyClass *ptr=new MyClass(45)；
}
正确答案：ptr->SetNum(50)
4．在面向对象方法中，类之间共享属性和操作的机制称为______________。
正确答案：继承
5．假设int a=1，b=2；则表达式a++±-b的值为______________。
正确答案：2
6．通过使用new和delete两个运算符进行的分配为______________分配。
正确答案：动态存储
7．下面程序的运行结果为______________。
#include<iostream.h>
void fun(int x=0,int y=0)
{
cout<<x<<y;
}
void main()
{
fun(5);
}
正确答案：50
8．重载的运算符保持其原有的______________、优先级和结合性不变。
正确答案：操作数个数
9．cout.put(’A’)；，还可以表示为______________。
正确答案：cout<< ’A’
10．在C++中封装性、继承性和______________是面向对象思想的主要特征。
正确答案：多态性
11．下面程序的结果为______________。
#include<iostream.h>
void main()
{
int a=1,b=2;
bool c=1;
if((a>b)|| c) cout <<“true”<<endl;
else
cout << “false”<<endl;
}
正确答案：true
12．假定A为一个类，则语句A(A &p)；为该类______________函数的原型说明。
正确答案：拷贝构造
13．派生类构造函数的执行顺序是先执行______________的构造函数，再执行______________的构造函数。
正确答案：基类、派生类
14．派生类的成员一般分为两部分，一部分是______________，另一部分是自己定义的新成员。
正确答案：从基类继承的成员
15．如果要把返回值为void的函数A声明为类B的友元函数，则应在类B的定义中加入的语句是______________。
正确答案：friend void A();
三、程序阅读题
1．阅读下面的程序，试求：
（1）给出程序的运行结果。
（2）根据程序的运行结果，说明“++”运算符的结合原则。
#include<iostream.h>
class A
{
int a;
public:
A(){a=0; }
A(int aa){ a=aa; cout << a++; }
};
void main()
{
A x,y(2),z(3);
cout << endl;
}
正确答案：（1）给出程序的运行结果：23
（2） 因为“++”运算符是右结合的，所以先输出，后加1，结果为23。
2．阅读下面的程序，试求：（1）给出程序的运行结果。（2）分析变量i的作用。
#include<iostream.h>
int i=0;
class A
{
public:
A(){i++;}
};
void main()
{
A a,b[3],c;
c=b;
cout << i <<endl;
}
正确答案：（1）给出程序的运行结果：4
（2）外部变量i的作用是记录调用构造函数的次数。
3．阅读下面的程序，试求：（1）给出程序的运行结果。（2）分析for循环的运行机制。
#include<iostream.h>
int fun(int a[],int n)
{
int result=1;
for(int i=1;i<n;i++) result= result * a[i];
return result;
}
void main()
{
int a[3]={3,4,5};
cout << fun(a,3)<<endl;
}
正确答案：（1）给出程序的运行结果：20
（2）分析for循环的运行机制: for循环执行2次，第一次result= 1a[1]=4，第二次result= 4*a[2]=20
4．阅读下面的程序，试求：（1）在程序中画线处填入合适的语句。（2）分析程序的运行机制。
class Base
{ public:
void fun(){ cout << “Base of fun”<<endl;}
};
class Derived:public Base
{
void fun()
{
//显示基类的成员函数fun
cout << “Derived of fun”<<endl;
}
};
正确答案：（1）填入的语句：Base：：fun()；。
（2）分析程序的运行机制：子类访问父类。
5．阅读下面的程序，试求：（1）给出程序的运行结果。（2）指出程序的运行机制。
#include<iostream.h>
class A
{
static int n;
public:A(){n=1;}
A(int num){ n=num;}
void print(){ cout << n;}
};
int A::n=2;
void main()
{
A a,b(3);a.print();b.print();cout << endl;
}
正确答案：（1）给出程序的运行结果：33。
（2）指出程序的运行机制：静态数据成员的使用。
6．阅读下面的程序，（1）给出程序的运行结果。
（2）若输出a数组中的最后3个数据，如何改写cout语句。
#include<iostream.h>
void main()
{
int i;
int a[3][3]={1,2,3,4,5,6,7,8,9};
for(i=0;i<3;i++)
cout<<a[2-i][i]<<” “;
}
正确答案：（1）给出程序的运行结果: 7 5 3
（2）若输出a数组中的最后3个数据，改写cout语句: cout<<a[2][i]<<” “;。
7．阅读下面的程序，给出程序的运行结果是什么？
#include<iostream.h>
void main()
{
int t,a,b,c;
a=1;b=2;c=2;
while(a<b<c)
{
t=a;a=b;b=t;c–;
}
cout<<a<<”,” <<b<<“,” <<c;
}
正确答案：程序的运行结果是 1,2,0
注：此程序运行时有一个警告错误warning C4804: ‘<’ : unsafe use of type ‘bool’ in operation
8．阅读下面的程序，给出程序的运行结果是什么？
#include<iostream.h>
#include<string.h>
void main()
{
char pl[10],p2[10];
strcpy (pl,“abc”);
strcpy(p2,“ABC”);
char str[50]=“xyz”;
strcpy(str+2,strcat(pl,p2));
cout<<str;
}
正确答案： 程序的运行结果是 xyabcABC
9．阅读下面的程序，给出程序的运行结果是什么？
#include<iostream.h>
int c;
class A
{
private:
int a;
static int b;
public:
A(){a=0;c=0;}
void seta(){a++;}
void setb(){b++;}
void setc(){c++;}
void display(){ cout << a <<” ” << b <<” ” << c; }
};
int A::b=0;
void main()
{
A a1,a2;
a1.seta();a1.setb();a1.setc();
a2.seta();a2.setb();a2.setc();
a2.display();
}
正确答案：程序的运行结果是 1 2 2
10．阅读下面的程序，（1）给出程序的运行结果。（2）指出函数 reverse的功能。
#include<iostream.h>
void reverse(int a[],int n)
{
int i,t;
for(i=0;i<n/2;i++)
{
t=a[i];a[i]=a[n-1-i];a[n-1-i]=t;
}
}
void main()
{
int b[10]={1,2,3,4,5,6,7,8,9,10};int i,s=0;
reverse(b,8);
for(i=6;i<10;i++)s+=b[i];cout<<s;
}
正确答案：（1）程序的运行结果：22。
（2）函数 reverse的功能：将b数组中的前8个成员互置。
11．阅读下面的程序，试求：（1）分析程序运行机制。（2）给出程序的运行结果。 #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；}
正确答案：
（1）程序运行机制：继承中，调用构造函数，先调用基类的，再调用派生类的；调用析构函数，先调用派生类的，再调用基类的。
（2）程序的运行结果：1342
12．阅读下面的程序，试求：（1）在程序中指出错误的行数。（2）分析错误语句的原因。
① #include<iostream.h>
② class A
③ {
④ public：
⑤ int n=2；
⑥ A(int val){cout<<val<<endl；}
⑦ ～A(){}；
⑧ }；
⑨ void main()
⑩ { A a(0)；}
正确答案：（1）程序中指出错误的行数是⑤。
（2）错误语句的原因：在类体中，不允许对所定义的数据成员进行初始化。
四、设计题
1．编写一个CRect类，代表一个矩形，要求CRect类中有代表矩形的左上角坐标（x1,y1）和右下角坐标（x2,y2）的数据成员，并可以通过构造器为坐标赋初值，还要求CRect类中有两个成员函数RectHeight()和RectWidth()，通过这两个函数能得到矩形的高和宽。
正确答案：
class CRect
{
private:
int x1,y1,x2,y2;
public:
CRect(int a1,int b1,int a2,int b2)
{x1=a1;y1=b1;x2=a2;y2=b2;}
int RectHeight()
{return (y2-y1);}
int RectWidth()
{return (x2-x1);}
};
2．定义一个学生类student，它含有私有数据成员：学号、姓名、年龄、成绩及公有成员函数：构造函数、成员函数set()用于对私有数据成员赋值、成员函数show()用于显示学号、姓名、年龄、成绩等。在主函数中定义student类的对象，显示两个学生的有关信息。如有下述输出结果：
学生1有关信息:
学号：101
姓名：lijun
年龄：18
成绩：85
学生2有关信息:
学号：102
姓名：wangming
年龄：19
成绩：78
正确答案：
#include<iostream.h>
#include<string.h>
class student
{
private: int num; char name[10]; int age; int score;
public: student(int x,char y[],int z,int m );
void set(int x,char y[],int z,int m); void show();
};
inline student::student(int x,char y[],int z,int m)
{
num=x; strcpy(name,y); age=z; score=m;
}
inline void student::set (int x,char y[],int z,int m)
{
num=x; strcpy(name,y); age=z; score=m;
}
void student::show()
{
cout<<“学号：”<<num<<endl;
cout<<“姓名：”<<name<<endl;
cout<<“年龄：”<<age<<endl;
cout<<“成绩：”<<score<<endl;
}
void main()
{
student t(101,“lijun”,18,85);
cout<<“学生1有关信息:”<<endl;
t.show ();
t.set(102,“wangming”,19,78);
cout<<“学生2有关信息:”<<endl;
t.show();
}
