当前位置:文档之家› c++考试试题

c++考试试题

语法扩充
1.1选择题
在C++中用( D )能够实现将参数值带回。
a)数组 b)指针 c)引用 d)上述ABC都可
考虑函数原型void test(int a,int b=7,char *ch="*"),下面的函数调用中,属于不合法调用的是:( C )
A)test(5) B)test(5,8) C)test(6,"#") D)test(0,0,"*");
已知: int m=10;下列表示引用的方法中,正确的是:( C )
A)int &Z; B)int &t=10; C)int &X=m; D)float &f=&m;
下列不是函数重载所要求的条件是:( D )
A)函数名相同 B)参数个数不同
C)参数类型不同 D)函数返回值类型不同
在C++中执行以下4条语句后输出rad值为:( C )
static int hot=200;
int &rad=hot;
hot=hot+100;
cout<A) 0 B) 100 C) 300 D) 200
系统在调用重载函数时,不能作为确定哪个重载函数被调用的依据是:( D )
A)参数个数 B)参数类型 C)函数名称 D)函数的返回值类型
对C++语言和C语言的兼容性,描述正确的是:( A )
A)C++兼容C B)C++部分兼容C C)C++不兼容C D)C兼容C++
在C++中使用流进行输入输出,其中用于屏幕输出的对象是:( C )
A)cerr B)cin C)cout D)cfile
对使用关键字new所开辟的动态存储空间,释放时必须使用( C )
A)free B)create C)delete D)realse
在函数调用时,如某一默认参数要指明一个特定值,则有( A )
A)其之前所有参数都必须赋值 B)其之后所有参数都必须赋值
C)其前、后所有参数都必须赋值 D)其前、后所有参数都不必赋值
下列哪个类型函数不适合声明为内联函数( A )
A)函数体语句较多 B)函数体语句较少
C)函数执行时间较短 D)函数执行时间过长
int Func(int,int);不可与下列哪个函数构成重载( B )
A)int Func(int,int,int); B)double Func(int,int);
C)double Func(double,double); D)double Func(int,double);
下面的哪个保留字不能作为函数的返回类型( C )
A)void B)int C)new D)long
一个函数功能不太复杂,但要求被频繁调用,选用( A )。
A. 内联函数 B. 重载函数 C. 递归函数 D. 嵌套函数
已知函数f的原型为:void f (int&a,char*b);变量s,t的定义是:int s;char t[ ]="ABCD";
把s和t分别作为第一参数和第二参数来调用函数f,正确的调用语句是( C )
A f(&s,&t); B f(&s,t); C f(s,t); D f(s,&t);
若定义cin>>str;
当输入
Microsoft Visual Studio 6.0!
所得结果是str=(B)。
A、 Microsoft Visual Studio 6.0!
B、 Microsoft
C、 Microsoft Visual
D、 Microsoft Visual Studio 6.0
.函数模板(C)。
A、代表某一具体函数
B、与模板函数是同一个函数
C、与某一个具体的数据类型连用
D、是模板函数实例化的结果

C++中,关于下列设置参数默认值的描述中,正确的是(C)
A、不允许设置参数的默认值
B、设置参数默认值只能在定义函数时设置
C、设置参数默认值时,应该是先设置右边的再设置左边的
D、设置参数默认值时,应该全部参数都设置
下列表示引用的方法中,(A)是正确的。
已知: k=1000;
A、int &x=k; B、char &y;
C、int &z=1000; D、float &t=&k;
有如下模板定义:
template T fun(T x,T y){return x*x+y*y;}
在下列对fun的调用中,错误的是:( C )
A)fun(2,8) B)fun(2.0,8.2) C)fun(2.3,8) D)fun (‘2’,’8’)
通常情况下,函数模板中的类型参数个数不能是( A )
A)0个 B)1个 C)2个 D)3个
1.2填空题
1、 假定有如下定义:int x;,若要将整型变量y定义为变量x的引用,则应使用的定义语句是_int &y=x;________。
具有相同函数名但具有不同参数表的函数称为 重载函数。'
2、 在进行函数调用时,将把参数的值传递给值参数,把参数的_地址_传递给引用参数。
3、 执行完下列三条语句后,指针变量c指向__b___。
Int a,b,*c=&a;
int *&p=c;
p=&b;
4、 假设有如下函数定义:void Fun(int x,int y=100);则语旬Fun(5)语句__ Fun(5,100)_等价。
5、 在一个C++程序中,每个变量都必须遵循__先定义后使用__的原则。
6、 下面是一个求数组元素之和的程序。主程序中定义并初始化了一个数组,然后计算该数组各元素之和,并输出结果。
函数TotalSum 计算数组元素之和。请完成下列程序。
#include
__ int Totalsum(int array[],int len)__ ;
void main()
{
int a[5]={2,3,6,8,10};
__int Total ___;
Total =Totalsum(a,5);
cout<<"Sum of array:"<}
int Totalsum(int array[],int len)
{
____int sum =0____ ;
for(int I=0;____I____ sum += array[I]_____ ;
return sum;
}
7、 下面的函数Fun未使用中间变量实现了对两个数的交换,请完成下列函数的定义。
Void Fun (int &x,int &y)
{
x+ = y;
y =___x-y____ ;
__x = x - y_____ ;
}
8、 定义一个函数时,若只允许函数体访问形参的值而不允许修改它的值,则应把该形参声明为__常量__,即在该形参声明的前面加上__const__关键字进行修饰。
9、 在一个函数的定义或声明前加上关键字__inline__时,该函数就声明为内联函数。
1.3简答题
A、.内联函数的含义
在函数前加上关键字inline说明了一个内联函数,这使一个函数在程序行里进行代码扩展而不被调用。这样的好处是减少了函数调用的开销,产生较快的执行速度。但是由于重复编码会产生较长代码,所以内联函数通常都非常小。如果一个函数在类说明中定义,则将自动转换成内联函数而无需用inline说明。
B、.函数重载的含义
 

 在同一作用域范围内,相同的函数名通过不同的参数类型或参数个数可以定义几个函数,编译时编译器能够识别实参的个数和类型来决定该调用哪个具体函数。需要注意的是,如果两个函数仅仅返回类型不同,则编译时将会出错,因为返回类型不足以提供足够的信息以使编译程序判断该使用哪个函数。所以函数重载时必须是参数类型或者数量不同。
C、引用与指针的区别
D、内联函数使用上的限制
E、定义带默认参数值函数的规则
F、指针与常量的关系
1.4程序阅读题
1)写出下列程序的运行结果。
#include
void main()
{
int x;
int &p=x;
x=10;
p=x+10;
cout<}
结果:20,20
2)写出下列程序的运行结果。
#include
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="<cout<<"n="<}
结果:
m=3
n=2
3) 写出下列程序的运行结果。
#include
void Fun()
{
int num=20;
cout<<"The Fun's num is"<}
void main()
{
int num=10;
cout<<"The main's num is "<Fun();
{
int num=30;
cout<<"The Field's num is "<}
cout<<"The main's num is "<}
结果:
The main's num is 10
The Fun's num is20
The Field's num is 30
The main's num is 10

类和对象?
2.1选择题
下列的各类函数中,不是类的成员函数。( C )
A)构造函数 B)析构函数 C)友元函数 D)拷贝初始化构造函数
作用域运算符“::”的功能是:( B )
A)标识作用域的级别的 B)指出作用域的范围的
C)给定作用域的大小的 D)标识成员是属于哪个类的
已知:print()函数是一个类的常成员函数,它无返回值,下列表示中,是正确的。( A )
A)void print()const; B)const void print();
C)void const print(): D)void print(const);
在类定义的外部,可以被访问的成员有( C )
A)所有类成员 B)private的类成员
C)public的类成员 D)public或private的类成员
关于类和对象不正确的说法是:( C )
A)类是一种类型,它封装了数据和操作 B)对象是类的实例
C)一个类的对象只有一个 D)一个对象必属于某个类
在C++中实现封装是借助于( B )
A)枚举 B) 类 C) 数组 D)函数
定义析构函数时,应该注意:( C )
A)其名与类名完全相同 B)返回类型是void类型
C)无形参,也不可重载 D)函数体中必须有delete语句
类clase CC1的说明如下,错误的语句是:( A )
clase CC1{
int a=2; //(A)
CC1(); //(B)
public:
CC1(int val); //(C)
~CC1(); //(D)
};
类的指针成员的初始化是通过函数完成的,这个函数

通常是:( B )
A)析构函数 B) 构造函数 C)其它成员函数 D)友元函数
关于构造函数的说法,不正确的是:( A )
A)没有定义构造函数时,系统将不会调用它 B)其名与类名完全相同
C)它在对象被创建时由系统自动调用 D)没有返回值
通常拷贝构造函数的参数是:( C )
A)对象名 B)对象的成员名 C)对象的引用名 D)对象的指针名
关于成员函数特征的描述中,错误的是:( A )
A)成员函数一定是内联函数 B)成员函数可以重载
C)成员函数可以设置参数的默认值 D)成员函数可以是静态的
下列关于构造函数的描述中,错误的是:( D )
A)构造函数可以设置默认参数; B)构造函数在定义类对象时自动执行
C)构造函数可以是内联函数; D)构造函数不可以重载
有如下类声明“class A{int x; ……};”,则A类的成员x是:( B )
A)公有数据成员 B)私有数据成员 C)公有成员函数 D)私有成员函数
类TM和类TN是两个独立的类,那么类TM中哪种形式的数据成员一定是不允许的:( C )
A)TM * a B)TN & a C)TM a D)TN a;
以下关于this指针的叙述中正确的是:( D )
A)任何与类相关的函数都有this指针; B)类的成员函数都有this指针;
C)类的友员函数都有this指针; D)类的非静态成员函数才有this指针;
.关于类模板的说法正确的是:( B )
A)类模板的主要作用是生成抽象类
B)类模板实例化时,编译器将根据给出的模板实参生成一个类
C)在类模板中的数据成员具有同样类型
D)类模板中的成员函数没有返回值
.以下关键字不能用来声明类的访问权限的是:( C )
A)public B)private C)static D)protected
.类的私有成员可在何处访问( D )
A)通过子类的对象访问 B)本类及子类的成员函数中
C)通过该类对象访问 D)本类的成员函数中
.如果没有为一个类定义任何构造函数的情况下,下列描述正确的是:( A )
A)编译器总是自动创建一个不带参数的构造函数 B)这个类没有构造函数
C)这个类不需要构造函数 D)该类不能通过编译
.一个类可包含析构函数的个数是:( B )
A)0个 B)1个 C)0个或1个 D)0个或多个
.一个类可包含构造函数的个数是:( D )
A)0个 B)0个或1个 C)0个或多个 D)1个或多个
.this指针存在的目的是:( B )
A)保证基类公有成员在子类中可以被访问
B)保证每个对象拥有自己的数据成员,但共享处理这些数据成员的代码
C)保证基类保护成员在子类中可以被访问
D)保证基类私有成员在子类中可以被访问
.下列关于类的权限的描述错误的是:( A )
A)类

本身的成员函数只能访问自身的私有成员
B)类的对象只能访问该类的公有成员
C)普通函数不能直接访问类的公有成员,必须通过对象访问
D)一个类可以将另一个类的对象作为成员
.设类A将其它类对象作为成员,则建立A类对象时,下列描述正确的是:( B )
A)A类构造函数先执行 B)成员构造函数先执行
C)两者并行执行 D)不能确定
.假定有类AB,有相应的构造函数定义,能正确执行“AB a(4),b(5), c[3] , *p[2]={&a,&b};”语句,请问执行完此语句后共调用该类构造函数的次数为( C )
A)3 B)4 C)5 D)6
拷贝构造函数的作用是( C )。
A. 进行数据类型的转换 B. 用对象调用成员函数
C. 用对象初始化对象 D. 用一般类型的数据初始化对象
下列静态数据成员的特性中,错误的是( D )。
A.静态数据成员的声明以关键字static开头
B. 静态数据成员必须在文件作用域内初始化
C. 引导数据成员时,要在静态数据成员前加(类名)和作用域运算符
D. 静态数据成员不是类所有对象共享的
通过指针访问类对象成员的方法是( D )。
A. :: B. ; C. . D. ->
静态成员函数没有( B )。
A.返回值 B. this指针 C. 指针参数 D. 返回类型
在下列关键字中,用于说明类中公有成员的是( A )。
A.public; B.private; C.protected; D.friend
不是构造函数的特征( D )。
A.构造函数的函数名与类名相同; B. 构造函数可以重载;
C. 构造函数可以设置缺省参数; D. 构造函数必须指定类型说明。
是析构函数的特征( A )。
A.一个类中只能定义一个析构函数; B. 析构函数名与类名不同;
C. 析构函数的定义只能在类体内; D. 析构函数可以有一个或多个参数。
关于成员函数特征的下述描述中,( A )是错误的。
A.成员函数一定是内联函数; B. 成员函数可以重载;
C. 成员函数可以设置参数的缺省值; D. 成员函数可以是静态的。
下述静态数据成员的特性中,( D )是错误的。
A. 说明静态数据成员时前边要加修饰符static;
B. 静态数据成员要在类体外进行初始化;
C.引用静态数据成员时,要在静态数据成员名前加<类名>和作用域运算符;
D.静态数据成员不是所有对象所共用的。
2.2填空题
1、 在撤销类的对象时,C++程序将自动调用该对象的__析构___函数。
2、 类中的构造函数是一个特殊的成员函数,它由类的对象__自动_调用,它的作用是___为对象分配内存,数据成员初始化___。
3、 对类中的成员函数和属性的访问是通过__public__、__protected__和___pr

ivate__这3个关键字来控制的。
4、 __delete__运算符删除new运算符所动态分配的内存空间。
5、 假定用户没有给一个名为MyClass的类定义析构函数,则系统为其定义的默认析构函数形式为__MyClass()__。
6、 类中构造函数有__一个或多__个,析构函数有___一___个。
7、 类是对具有共同属性和行为的一类事物的抽象描述,共同属性被描述为类中的___数据成员___ ,共同行为被描述为类中的__成员函数__。
8、 若要把类FriendClass定义为类MyClass的友元类,则应在类MyClass的定义中加入语句_friend class FriendClass;___。
9、 在结构定义中,数据和成员函数默认权限是__public__。在类定义中,数据和成员函数默认权限是__private___。
10、 在下面程序的横线处填上适当的语句,使类型该程序执行结果为10。
#include
class MyClass
{
pub1ic:
___ MyClass ( int a ) {_x = a; }____//为x置值
__int GetNum(){ return x; }______ //取x值
private:
int x;
};
void main()
{
Myclass my(10);
Cout<}
11、 完成下面的类定义。
Class MyClass
{
public:
MyClass(){x=0;}
____friend______int GetNum(___MyClass ______my);
private:
int x;
};
int GetNum(____MyClass ______my)
{
___return my.x;
}
12、 __new__运算符对指定类型对象动态分配内存并返回该类型的__指针__。
13、 若要把函数void FriendFunction()定义为类MyClass的友元函数,则应在类MyClass的定义中加入语句__friend void FriendFunction();_______。
14、 类的具体表现是通过定义_对象__来操作的。
15、 在定义类的对象时,C++程序将自动调用该对象的__构造___函数初始化对象自身。
16、 一般情况下,按照面向对象的要求,把类中的数据成员(属性)定义为__private__权限,而把成员函数(方法)定义为__public__权限。
17、 在类中定义和实现的函数称为_内联函数__。
18、 非成员函数应声明为类的__友元函数__才能访问这个类的private成员。
2.3简答题
A、类的含义
B、构造函数的特点
C、拷贝构造函数的调用
D、析构函数的定义及其特点
E、静态成员的分类及各自的特点
2.4程序阅读题
1) 写出下列程序的运行结果。
#include
class MyClass
{
char ch;
public:
MyClass();
MyClass(char character);
void Print();
~MyClass();
};
MyClass::MyClass()
{
cout<<"This is a constructor!"<ch='a';
}
MyClass::MyClass(char character)
{
cout<<"This is a constructor!"<ch=character;
}
void MyClass::Print()
{
cout<<"The value of ch is "<}
MyClass::~MyClass()
{
cout<<"This is a destructor!"<}
void main()
{
MyClass first,second('b');
first.Print();
second.Print();
}
运行结果:
This is a constructor!
This is a constructor!
The value of ch is a
The value of ch is b
This is a destru

ctor!
This is a destructor!



2)写出下列程序的运行结果
#include
class MyClass
{
public:
MyClass();
void Print();
~MyClass();
private:
int I;
static int j;
};
int MyClass::j=0;
MyClass::MyClass()
{
cout<<"This is constructor!"<j+=10;
}
void MyClass::Print()
{
cout<<"The value of j is" <}
MyClass::~MyClass()
{
cout<<"This is a destructor!"<}
void main()
{
MyClass first,second;
first.Print();
second.Print();
}

This is constructor!
This is constructor!
The value of j is20
The value of j is20
This is a destructor!
This is a destructor!


继承与派生
3.1选择题
.在C++中,类与类之间的继承关系具有( C )
A)自反性 B)对称性 C)传递性 D)反对称性
.在公有继承的情况下,基类的成员(私有的除外)在派生类中的访问权限( B )
A)受限制 B)保持不变 C)受保护 D)不受保护
.按解释中的要求在下列程序划线处填入的正确语句是:( C )
#include
class Base{
public:
void fun(){cout<<"Base::fun"<};
class Derived:public Base{
public:
void fun()
{ //在此空格处调用基类的函数fun()
cout<<"Derived::fun"<};
A)fun(); B)Base.fun(); C)Base::fun(); D)Base->fun();
.在保护继承的情况下,基类的成员(私有的除外)在派生类中的访问权限( C )
A)受限制 B)保持不变 C)受保护 D)不受保护
.下面描述中,表达错误的是:( B )
A)公有继承时,基类中的public成员在派生类中仍是public的
B)公有继承时,基类中的private成员在派生类中仍是private的
C)公有继承时,基类中的protected成员在派生类中仍是protected的
D)私有继承时,基类中的public成员在派生类中是private的
.下列虚基类的声明中,正确的是:( B )
A)class virtual B: public A B)class B: virtual public A
C)class B: public A virtual D)virtual class B: public A
.C++设置虚基类的目的是( A )?
A)消除二义性 B)简化程序 C)提高运行效率 D)减少目标代码
class X{
int a;
public:
X(int x=0){a=x;}
};
class Y:public X{
int b;
public :
Y(int x=0,int y=0):X(y)){ b=x;}
};
下列语句组中出现语法错误的是(D)
A. X *pa=new Y(1,2);
B.X a1=Y(1,3);
C.Y b1(2,3); X &a3=b1;
D.X a4(10);Y b2=a4;
class Base
{ public: int i;
Base(int t) : i ( t ) { }
};
class Derived: protected Base
{ Base b;
int j;
public:
Derived (int t);
};
在构造函数Derived的下列定义中,正确的是(B )
A. Derived : : Derived (int t) : b(t), j(t) { }
B. Derived : : Derived (int t) : b(t), Base(t), j(t) { }
C. Derived : : Derived (int t) : Base(t), j(t) { }
D. Derived : : Derived (int t) : i(t), b(t), j(t) { }
.在哪种派生方式中,派生类可以访问

基类中的protected成员(B )
A)public和private B)public、protected和private
C)protected和private D)仅protected
在C++中,类与类之间的继承关系具有(C )
A) 自反性 B) 对称性 C) 传递性 D) 反对称性
下列关于类的继承描述中,(A )是错误的
A) 派生类可以访问基类的所有数据成员,也能调用基类的所有成员函数
B) 派生类也是基类,但基类不一定具有派生类的全部属性和方法
C) 继承描述类的层次关系,派生类可以具有与基类相同的属性和方法
D) 一个基类可以有多个派生类,一个派生类可以有多个基类
.当一个派生类仅有protected继承一个基类时,基类中的所有公有成员成为派生类的(C)
A) public成员 B) private成员 C) protected成员 D) 友元
当一个派生类私有继承一个基类时,基类中的所有公有成员和保护成员成为派生类的( B )
A) public成员 B) private成员 C) protected成员 D) 友元
不论派生类以何种方法继承基类,都不能使用基类的(B )
A) public成员 B) private成员 C) protected成员 D) public成员和protected成员
在创建派生类对象时,构造函数的执行顺序是(D)
A) 对象成员构造函数、基类构造函数、派生类本身的构造函数
B) 派生类本身的构造函数、基类构造函数、对象成员构造函数
C) 基类构造函数、派生类本身的构造函数、对象成员构造函数
D) 基类构造函数、对象成员构造函数、派生类本身的构造函数
下列虚基类的声明中,正确的是( D )。
A)class virtual B:public A
B)virtual class B:public A
C)class B:public A virtual
D)class B:virtual public A
下面叙述错误的是(A )。
A)基类的protected成员在派生类中仍然是protected的
B)基类的protected成员在public派生类中仍然是protected的
C)基类的protected成员在private派生类中是private的
D)基类的protected成员不能被派生类的对象访问
下列说法中错误的是(A )。
A) 保护继承时基类中的public成员在派生类中仍是public的
B)公有继承时基类中的private成员在派生类中仍是private的
C)私有继承时基类中的public成员在派生类中是private的
D)保护继承时基类中的public成员在派生类中是protected的
关于多继承二义性的描述中,错误的是(B )。
A)一个派生类的两个基类中都有某个同名成员,在派生类中对这个成员的访问可能出现二义性
B)解决二义性的最常用的方法是对成员名的限定法
C)基类和派生类中同时出现的同名函数,也存在二义性问题
D)一个派生类是从两个基类派生出来的,而这两个基类又有一个共同的基类,对该基类成员进行访问时,可能

出现二义性
下面叙述错误的是(C )。
A)派生类可以使用private派生
B)对基类成员的访问必须是无二义性的
C)基类成员的访问能力在派生类中维持不变
D)赋值兼容规则也适用于多继承的组合
派生类的构造函数的成员初始化列表中,不能包含(C )。
A)基类的构造函数
B)派生类中子对象的初始化
C)基类中子对象的初始化
D)派生类中一般数据成员的初始化
下面(B )的叙述不符合赋值兼容规则。
A)派生类的对象可以赋值给基类的对象
B)基类的对象可以赋值给派生类的对象
C)派生类的对象可以初始化基类的引用
D)派生类的对象的地址可以赋值给指向基类的指针
.下列虚基类的声明中,正确的是:( B )
A)class virtual B: public A B)class B: virtual public A
C)class B: public A virtual D)virtual class B: public A
.C++设置虚基类的目的是( A )
A)消除二义性 B)简化程序 C)提高运行效率 D)减少目标代码
3.2填空题
1、 垂直访问时,保护成员的访问控制权限与_公有__成员相同。
2、 利用继承能够实现_代码复用__。这种实现缩短了程序的开发时间,促使开发人员复用已经测试和调试好的高质量软件。
3、 派生类对基类的继承有三种方式:__public__、___protected__ 和___private__。
4、 多继承情况下,派生类的构造函数的执行顺序取决于__定义__派生类时所指定的各基类的顺序。
5、 C++提供的_多继承__机制允许一个派生类继承多个基类,即使这些基类是相互无关的。
6、 派生类可以调用其_定义___中不具备的数据和操作。
7、 对基类数据成员的初始化必须在派生类构造函数中的__初始化列表___处执行。
8、 如果类Alpha继承了类Beta,则类Alpha称为__派生__类,类Beta称为__基__类。
9、 己知下面的程序框架,按注释中的提示补充细节。
#include
class planet
{
protected:
double distance;___//行星距太阳的距离
int revolve;___//行星的公转周期
public:
planet(double d,int r)
{
distance=d;
revolve=r;
}
};
class earth:public planet
{
double circumference; //地球绕太阳公转的轨道周长
public:
//定义构造函数earth(double d,int r),并计算地球绕太阳公转的轨道周长。
//假定:circumnference=2*d*3.1416
___ earth(double d,int r): planet (d, r){__ circumnference=2*d*3.1416;}___
//定义show()函数显示所有信息
___void show() { cout<<”distance is ”<< distance<<”miles, revolve is”<< revolve<<”days”<};
void main()
{
earth ob(9300000,365);
ob.show();
}
10、 设置虚基类的目的是__为了消除二义性__,可通过____virtual_____标识虚基类。
11、 若多继承时,多个基类中拥有一个同名的

成员,则__不能__用调整访问权限确定对该成员的访问。
12、 根据基类的定义和测试程序,完成下面派生类的定义。
Class Point
{
public:
Point(int I=0,int j=0){X=I;Y=j;}
void Move(int xOff,int yOff){X+=xOff;Y+=yOff;}
int GetX(){return X;}
int GetY(){return Y;}
private:
int X,Y;
};
class Rectangle :private Point
{
public:
Rectangle(int x,int y,int w,int h)__:Point(x,y)___{_W = w ; H = h ;_ }
void Move(int xOff,int yOff){_ Point:Move(xOff, yOff);__ }
int GetX(){__return Point:GetX();__ }
int GetY(){___return Point:GetY();__ }
int GetW(){__return W;__ }
int GetH(){__return H;__ }
private:
int W,H;
}
#include
#include
void main()
{
Rectangle rect(1,2,3,4);
rect.Move(5,6);
cout<<“The data of rect(X,Y,W,H):(“
<<13、 多继承可以视为是__单继承__的扩展。
14、 在划线处填上适当的语句,完成下列程序。
#include
class Point
{
public:
point(double a,double b,double c){_X =a; Y=b; Z =c;__}
double Getx(){return X;}
double Gety(){return Y;}
double Getz(){return Z;}
private:
__double X, Y;_____
protected:
__double Z;_____
};
class Line :_____public____Point
{
public:
Line(double a ,double b,double c,double d)_:Point(a,b,c)_____{____K = d;___ }
void show()
{
cout<cout<cout<cout<}
private:
double k;
};
void main()
{
Line obj(1.2,3.4,5.6,7.8);
obj.show();
}
15、 类继承中,缺省的继承方式是__private___。
16、 当用protected继承从基类派生→个类时,基类的public成员成为派生类的__protected__成员,protected成员成为派生类的_____protected____成员。
18、 __公有派生__类的对象可作为____基___类的对象处理。
19、 指向基类的对象的指针变量也可以指向__公有派生类_的对象。
20、 类之间的”有”关系代表__组合___,”是”关系代表__继承__。
3.3简答题
A、派生类的定义及其特点
B、单继承和多继承的概念及其关系
C、继承方式的种类及其各自的特点
D、在继承中构造函数和析构函数的调用规则
F、赋值兼容原则
G、类模板和模板类的含义及其关系
3.4读程序题
1、 写出下列程序的运行结果。
#include
class Base
{
public:
void Who(){cout<<"class Base"<};
class Derived1:public Base
{
public:
void Who(){cout<<"class Derived1"<};
class Derived2:public Base
{
public:
void Who(){cout<<"class Derived2"<};
void main()
{
Base obj1,*p;
Derived1 obj2;
Derived2 obj3;
p=&obj1;
p->Who();
p=&obj2;
p->Who();
p=&obj3;
p->Who();
obj2.Who();
obj3.Who();
}
答案:
class Base
class Base
class Base
class Derived1
class Derived2


2、 写出下列程序的运行结

果。
#include
class instrument
{
public:
void display() const{cout<<"instument::display."<};
class piano:public instrument
{
public:
void display() const{cout<<"piano::display."<};
class guitar:public instrument
{
public:
void display() const{cout<<"guitar::display."<};
void tone(instrument & I)
{
I.display();
};
void main()
{
guitar guitar1;
tone(guitar1);
piano piano1;
tone(piano1);
}
答案
instument::display.
instument::display.

3、 写出下列程序的运行结果。
#include
class A
{
public:
A(char i){cout<<"A's cons."<~A(){cout<<"A's des."<};
class B:virtual public A
{
public:
B(char i,char j):A(i){b = j; cout<<"B's cons."<~B(){cout<<"B's des."<private:
char b;
};
class C:virtual public A
{
public:
C(char i,char j):A(i)
{
cout<<"C's cons."<}
~C(){cout<<"C's des."<};
class D:public B,public C
{
public:
D(char i,char j,char k,char s,char m,char n)
:C(k,s),B(i,j),A(i),aa(m){cout<<"D's cons."<~D(){cout<<"D's des."<private:
A aa;
};
void main()
{
D obj('a','b','c','d','e','f');
}
答案 :
A's cons.a
B's cons.b
C's cons.d
A's cons.e
D's cons.
D's des.
A's des.
C's des.
B's des.
A's des.

类的多态性
4.1选择题
.实现运行时的多态性采用( D )
A)重载函数 B)构造函数 C)析构函数 D)虚函数
.在派生类中重新定义虚函数时,必须在下列哪方面与基类保持一致。(A )
A)参数类型 B)参数名字 C)操作内容 D)赋值
.当一个类的某个函数被说明为virtual时,在该类的所有派生类中的同原型函数(A )
A)都是虚函数 B)只有被重新说明时才是虚函数
C)都不是虚函数 D)只有被重新说明为virtual时才是虚函数
.通过下述哪一项调用虚函数时,采用动态联编。(A )
A)对象指针 B)对象名 C)成员名限定 D)派生类名
下面描述中,正确的是(B D )(两个答案)
A) 虚函数是没有实现的函数 B) 纯虚函数的实现在派生类中
C) 抽象类是没有纯虚函数的类 D) 抽象类指针可以指向不同的派生类对象
若一个类中含有纯虚函数,则该类称为(D )
A) 基类 B) 纯基类 C) 派生类 D) 抽象类
假设A为抽象类,下列声明(B )是正确的
A) A fun(int); B) A *p; C) int fun(A); D) A Obj;
在C++中,要实现动态联编,必须使用(D )调用虚函数
A) 类名 B) 派生类指针 C) 对象名 D) 基类指针
下列函数中,可以作为虚函数的是(C D)(两个答案)
A) 普通函数 B) 构造函数 C)成员函数 D) 析构函数
在派生类中,重载一个虚函数时,要求函数名、参数的个数、参

数的类型、参数的顺序和函数的返回值(B )
A) 不同 B) 相同 C) 相容 D) 部分相同
下面函数原型声明中,(C )声明了fun为普通虚函数
A) void fun()=0; B) virtual void fun()=0;
C) virtual void fun(); D) virtual void fun(){};
在下面四个选项中, (A)是用来声明虚函数的。
A)virtual
B)public
C)using
D)false
在下面程序中,A、B、C、D四句编译时出现错误的是(C)。
Class A______ //A
{
public:______ //B
A(){func();}___ //C
virtual void func()=0;___//D
};
实现运行时的多态性要使用(D)。
A)重载函数
B)构造函数
C)析构函数
D)虚函数
对虚函数的调用(D )。
A)一定使用动态联编
B)必须使用动态联编
C)一定使用静态联编
D)不一定使用动态联编
在派生类中重新定义虚函数时,除了(D )方面,其他方面都必须与基类中相应的虚函数保持一致。
A)参数个数
B)参数类型
C)函数名称
D)函数体
关于虚函数的描述中,正确的是(D)。
A)虚函数是一个静态成员函数
B)虚函数是一个非成员函数
C)虚函数既可以在函数说明时定义,也可以在函数实现时定义
D)派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型
下列描述中, (D)是抽象类的特性。
A)可以说明虚函数
B)可以进行构造函数重载
C)可以定义友元函数
D)不能说明其对象
关于纯虚函数和抽象类的描述中,错误的是(C )。
A) 纯虚函数是一种特殊的虚函数,它没有具体的实现
B) 抽象类是指具有纯虚函数的类
C) 一个基类中说明有纯虚函数,该基类的派生类一定不再是抽象类
D) 抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出
以下(C )成员函数表示纯虚函数。
A)virtual int vf(int);
B)void vf(int)=0;
C)virtual void vf()=0;
D)virtual void vf(int){}
下列关于动态联编的描述中,错误的是(D)。
A)动态联编是以虚函数为基础的
B)动态联编是在运行时确定所调用的函数代码的
C)动态联编调用函数操作是指向对象的指针或对象引用
D)动态联编是在编译时确定操作函数的
如果一个类至少有一个纯虚函数,那么就称该类为(A)。
A)抽象类
B)虚基类
C)派生类
D)以上都不对
下面的描述中,正确的是(A)。
A)virtual可以用来声明虚函数
B)含有纯虚函数的类是不可以用来创建对象的,因为它是虚基类
C)即使基类的构造函数没有参数,派生类也必须显示调用其构造函数
D)静态数据成员可以通过成员初始化列表来初始化
4.2填空题
1、 在析构函数中调用虚函数时,采用__静态__联编。
2、 动态联编是在__虚函数___的支持下实现的,它通

过__指针或引用__来调用该函数操作。
3、 动态联编中直到__程序运行__时才能确定调用哪个函数:而静态联编则是在__程序编译__时进行的。
4、 C++中__不支持__虚构造函数,但___支持___虚析构函数。
5、 静态联编所支持的多态性称为__编译时__多态性,动态联编所支持的多态性则称为___运行时___多态性,动态多态性由___虚函数___来支持。
6、 在类定义中,将___=0__置于虚函数的函数原型的末尾可以将该函数声明为纯虚函数。
7、 下列程序的运行结果如下:
Base's cons.
Derived's cons.
Derived's des.
Base's des.
根据结果将程序补充完整。
#incude
class Base
{
public:
Base(){cout<<"Base's cons."<__virtual ~Base()__{cout<<"Base's des."};
class Derived:public Base
{
public:
Derived(){cout<<"Derived's cons."<~Derived(){cout<<"Derived's des."<};
void main()
{
Base *Ptr=__new _ Derived()_
delete ptr;
}
8、 抽象类不能__定义对象,但可以_声明指针或引用__作为参数类型,函数返回类型或显式转换类型。
9、 根据不同的输出结果,在函数Tone中填入正确的语句。
#include
class Instrument
{
public:
virtual void Print() const{cout<<"Instrument:Print"<};
class Piano:public Instument
{
public:
void Print() const{cout<<"Piano::Print<};
class Guitar :public InstruIment
{
pub1ic:
void Print() const{cout<<"Guiur::Print"<};
void Tone(__Instrument obj__)//第二个要求改成Instrument &obj
{
__obj.print();__
}
void main()
{
Guitar g;
Tone(g);
Piano p;
Tone(p);
}
(1)输出结果为:
Instrument::Print
Instrument::Print
(2)输出结果为:
Guitar::Print
Piano::Print

10、 对虚函数使用对象指针或引用调用,系统使用__动态__联编:使用对象调用时,系统使用__静态__联编。

11、 将下列程序补充完整。
#include
class convert
{
public:
convert(double I){va11=I;}
____ virtual void compute()=0; ____
protected:
double val1;
double va12:
};
//liters to gallons
class l_to_g:public convert
{
public:
__ l_to_g(double I):convert(I){} ____
void compute()
{
va12=va11/3.7854;
cout<}
};
//Fahrenheit to Celsius
class f_to_c:public convert
{
public:
f_to_c(double I):convert(I){}
void& compute()
{
va12=(va11-32)*5/9;
cout<}
};
void fun(__convert& f____)
{
https://www.doczj.com/doc/f015352917.html,pute();
}
void main()
{
l_to_g lgobj(4);
f_to_c fcobj(70);
fun(lgobj);
fun(fcobj);
}
12、 下列程序的运行结果如下:
Derive1's Print() called.
Derive2's Print() caIIed.
根据结果将程序补充完整。
#include
class Base
{
public:
Base(int I){b=I;}
__ virtual Print()=0; ____
protected:
int b;
}
class Derive1:public Base
{
public:
__ Derive1(int& I):Base

(I){} ___
void Print()
{
cout<<"Derive1's Print() called."<}
};
class Derive2:public Base
{
public:
Derive2(int I):Base(I){}
void Print(){cout<<“Derive2’s Print() called.”<
};
void fun(__Base *obj ____)
{
obj->Print();
};
void main()
{
Derive1 *d1=new Derive1(1);
Derive2 *d2=new Derive2(2);
fun(d1);
fun(d2);
}
13、 在一个成员函数内调用一个虚函数时,对该虚函数的调用进行_动态__联编。
14、 带有__纯虚函数__的类称为抽象类,它只能作为__基类__来使用。
4.3简答题
A、成员函数重载与虚函数的区别
B、静态联编和动态联编的含义
C、纯虚函数和抽象类的定义及其关系
D、抽象类的特点
4.4读程序题
1、写出下列程序的运行结果。
#include
class Base
{
public:
Base(int i){x=i;cout<<"Base:"<virtual ~Base(){cout<<"~Base:"<private:
int x;
};
class Derived :public Base
{
public:
Derived(int i,int j):Base(i){y=j;cout<<"Derived:"<~Derived(){cout<<"~Derived:"<private:
int y;
};
void main()
{
Base *b1=new Base(15);
delete b1;
Base *b2=new Derived(20,25);
delete b2;
}
答案
Base:15
~Base:15
Base:20
Derived:25
~Derived:25
~Base:20


2、 阅读下列程序,回答后面提出的问题。
#include
class Base
{
public:
Base():x(0),y(0){}
Base(int I,int j):x(I),y(j){}
int GetX() const{return x;}
int GetY() const{return y;}
virtual void Print() const{cout<<"x="<private:
int color;
};
class Car :public Vehicle
{
public:
void Move(){cout<<"Carmoving."<};
class Bus :public Vehicle
{
public:
void Move(){cout<<"Bus moving."<};
class SportsCar:public Car
{
};
class Coupe :public Car
{
public:
void Move(){cout<<"Coupe moving."<};
void main()
{
Vehicle *vec;
vec=new Car;
vec->Move();
delete vec;
vec=new Bus;
vec->Move();
delete vec;
vec=new SportsCar;
vec->Move();
delete vec;
vec=new Coupe;
vec->Move();
delete vec;
}
答案:
Carmoving.
Bus moving.
Carmoving.
Coupe moving.


运算符重载
5.1选择题
友元运算符obj>obj2被C++编译器解释为(A )。

A)operator>(obj1,obj2)
B)>(obj1,obj2)
C)obj2.operator>(obj1)
D)obj1.oprator>(obj2)
下面对C++运算符的正确的描述是(D )。
A)只有类成员运算符
B)只有友元运算符
C)只有非成员和非友元运算符
D)上述三者都有
下列关于C++运算符函数的返回类型的描述中,错误的是(C)。
A)可以是类类型
B)可以是int类型
C)可以是void类型
D)可以是float类型
重载赋值操作符时,应声明为(C)函数。
A)友元
B)虚
C)成员
D)多态
在一个类中可以对一个操作符进行(D)重载。
A)1种
B)2种以下
C)3种以下
D)多种
下列关于运算符重载的描述中,正确的是(D)。
A)运算符重载可以改变运算符的操作数的个数
B)运算符重载可以改变优先级
C)运算符重载可以改变结合性
D)运算符重载不可以改变语法结构
下列运算符中, (C)运算符在C++中不能重载。
A)=
B)()
C)::
D)delete
下列运算符中, (A)运算符在C++中不能重载。
A〕?:
B)[]
C)new
D)&&
在重载运算符函数时,下面(D)运算符必须重载为类成员函数形式。
A)+
B)-
C)++
D)->
下列运算符不能用友元函数重载的是(B )。
A)+
B)=
C)*
D)<<
下面对友元的错误描述是(D )
A) 关键字friend用于声明友元
B) 一个类的成员函数可以是另一个类的友元
C) 友元函数访问对象的成员不受访问特性影响
D) 友元函数通过this指针访问对象成员
.如果类A被说明成类B的友元,则(C )
A)类A的成员即是类B的成员
B)类B的成员即是类A的成员
C)类A的成员函数可以访问类B的所有成员
D)类B的成员函数可以访问类A的所有成员
.在C++中不能被重载的一组运算符是:(A)
A):: ?: . sizeof B)?: . sizeof ++ ->
C):: ?: new delete D)++ -- ?: sizeof
5.2填空题
1、要在类的对象上使用运算符,除了运算符__=__和__&__以外,其他的运算符都必须被重载。
2、 在C++中,只能重载为类的成员函数的运算符是___=__、__()__、__[ ]__、_->__。
3、 运算符()与运算符[]必须重载为__类的成员函数___。
4、 利用成员函数对二元运算符重载,其左操作数为__this指针指向的当前对象__,右操作数为__成员函数参数__。
5、 下列程序定义了一实部为mal,虚部为imag的复数类complex,并在类中重载了复数的+、-操作。请将下列程序补充完整。
Class Complex
{
public:
Complex(double r=0.0,double I=0.O){__ real=r;imag=I;___}
__Complex__operator +(Complex);
__friend Complex____operator -(Complex,Complex);
private:
double real,imag;
};
___Complex Complex::operator +(Complex c)
{
return Complex(__real+c.real,imag+c.imag___);
};
___Complex___operator -(Complex c1,Complex c2)
{

return Complex(___c1.real-c2.real,c1.imag-c2.imag ____);
}
6、 单目运算符作为类成员函数重载时__没有__的参数;双目运算符作为__类成员函数__重载时需声明其右操作数,作为_友元函数__重载时需声明全部操作数。
7、 重载运算符函数的函数名时使用关键字_ operator ___。
8、 重载的运算符仍然保持其原来的优先级、__结合性__和__语法结构__。
9、 为满足运算符+的可交换性,必须将其重载为_友元函数___。
10、 C++中不能重载的运算符有__.__、__* (取内容) __、__::__、__?:__和__size of__。
11、 设a和b是两个整型变量,a+b表示这两个变量的和:设c和d为浮点型变量,c+d也表示这两个变量的和。这里的运算符+具有不同的用途,这是__运算符重载___的例子。
5.3简答题
A、友元的特点
B、运算符重载的含义
C、运算符重载的限制
5.4读程序题
1、 写出下列程序的运行结果。
#include
class Rect
{
public:
Rect(int l,int w){length=l;width=w;}
void Print(){cout<<"Area:"<Rect operator *(int d){return Rect(length*d, width * d);}
private:
int length,width;
};
void main()
{
Rect p(5,4), m(0,0);
m = p * 4;
m.Print();
}
答案:
Area:320



2、 写出下列程序的运行结果。
#include
class Vector
{
public:
Vector(){}
Vector(int i,int j){x=i;y=j;}
friend Vector operator +=(Vector v1,Vector v2)
{
v1.x+=v2.x;
v1.y+=v2.y;
return v1;
}
Vector operator -=(Vector v)
{
Vector temp;
temp.x=x-v.x;
temp.y=y-v.y;
return temp;
}
void display(){cout<<"("<private:
int x,y;
};
void main()
{
Vector v1(1,2),v2(3,4),v3,v4;
v3=v1+=v2;
v4=v1-=v2;
cout<<"v1=";
v1.display();
cout<<"v2=";
v2.display();
cout<<"v3=";
v3.display();
cout<<"v4=";
v4.display();
}
答案:
v1=(1,2)
v2=(3,4)
v3=(4,6)
v4=(-2,-2)


3、 写出下列程序的运行结果。
#include
class Coord
{
public:
Coord(int I=0,int j=0){x=I;y=j;}
void Print(){cout<<"x="<friend Coord operator++(Coord op);
friend Coord operator++(Coord &op, int );
private:
int x, y;
};
Coord operator++(Coord op)
{
++op.x;
++op.y;
return op;
}
Coord operator++(Coord &op, int)
{
++op.x;
++op.y;
return op;
}
void main()
{
Coord obj(1,2), obj2(5,8);
obj.Print();
++obj;
obj2++;
obj.Print();
obj2.Print();
}
答案:
x=1,y=2
x=1,y=2
x=6,y=9


异常处理
6.1选择题
下列关于异常的叙述错误的是(A)。
A.编译错属于异常,可以抛出
B.运行错属于异常
C.硬件故障也可当异常抛出
D.只要是编程者认为是异常的都可当异常抛出
下列叙述错误的是( A )。
A.throw语句须书写在try语句块中
B.throw可以产生任何类型的异常
C.一个程序中可以有try

语句而没有throw语句
D.throw语句抛出的异常可以不被捕获
下列叙述错误的是(A)。
A.catch(int )语句可捕获所有类型的异常
B.一个try语句可以有多个catch语句
C. catch语句组的顺序可以随意
D.程序中try语句与catch语句是一个整体,缺一不可
下列程序运行结果为(A)。
#include
using namespace std;
class S{
public:
~S( ){cout<<”S”<<”\t”; }
};
char fun0() {
S s1;
throw(‘T’);
return ‘0’;
}
void main(){
try{
cout<catch(char c) {
cout<}
A.S T B.O S T C.O T D.T
6.2填空题
1)C++程序将可能发生异常的程序块放在 try 中,紧跟其后可放置若干个对应的 catch ,在前面所说的块中或块所调用的函数中应该有对应的 throw ,由它在不正常时抛出 异常 ,如与某一条 catch 类型相匹配,则执行该语句。该语句执行完之后,如未退出程序,则执行 catch后续语句 。如没有匹配的语句,则交给C++标准库中的 termanite 处理。
2)throw表达式的行为有些像函数的 函数调用 ,而catch子句则有些像函数的 函数定义 。函数的调用和异常处理的主要区别在于:建立函数调用所需的信息在 编译 时已经获得,而异常处理机制要求 运行 时的支撑。对于函数,编译器知道在哪个调用点上函数被真正调用;而对于异常处理,异常是 随机 发生的,并沿调用链逆向 查找异常处理子句,这与 运行时的 多态是 不一样的 。
6.3简答题
A、异常处理语法格式
B、异常处理机制
C、常成员函数的语法定义及其特点
C#语法
7.1选择题
1 C#中程序的入口方法名是(A)
A Main B main C Begin D using
2 C#导入某一命名空间的关键字是(A)
A using B use C import D include
3 下面是几条动态初始化一维数组的语句,指出其中正确的(D)
A int[] arr=new int[]; B int[] arr=new int[5];
c.int[] arr=new int{6,5,1,2,3}; D.int[] arr=new int[5]{6,5,1,2,3};
4.C#中MyClass 为一自定义类,其中有以下方法定义public void Hello(){..}使用以下语句创建了该类的对象,并使变量obj 引用该对象:MyClass obj = new MyClass();那么,可如何访问类MyClass 的Hello 方法(A)
A. obj.Hello();
B. obj::Hello();
C. MyClass.Hello();
D. MyClass::Hello();
5. 在定义类时,如果希望类的某个方法能够在派生类中进一步进行改进,以处理不同的派生类的需要,则应将该方法声明成(C)。
A. sealed 方法 B. public 方法 C. visual 方法 D. override 方法
6、在C#中有几种运算符重载的方法( A )。
A. 一种 B. 三种 C. 二种 D. 多种
7、在C#中所有异常的基类是( B )。
A. CException B. Exception C. Error D. CError

7.2填空题
1.C#中采用命名空间

来管理语法元素
2.C#中的Main方法是入口函数,其必须申明为static方法
3.C#中创建对象使用new关键字,给已经定义好的MyClass类创建一个名为obj的对象,实现语句是MyClass obj = new MyClass()。
4.创建一个包含8个整型元素的一维数组ary的实现语句是int ary[] = new int[8];。
5.C#中只存在 单 继承。
6.C#中多态性的实现方法是 在基类中用virtual声明,在派生类中用override 重新定义
7. C#中运算符重载都声明为public和static


课程名称 考试时间 任课教师 监考教室 监考教师1 乘车地点1 监考教师2 乘车地点2 监考教师3 乘车地点3 监考教师4 乘车地点4
面向对象程序设计 第18周周2(2011-01-04) 13:30-15:00 李晓勇 *c1-206 李晓勇 卢小林
座位号 学号 姓名 专业名称 考试时间 考试地点 课程名称
显示学生记录数为:0!









https://www.doczj.com/doc/f015352917.html,/p-401118495.html
https://www.doczj.com/doc/f015352917.html,/p-224491629.html

相关主题
相关文档 最新文档