继承、多态、运算符重载、文件单元测验

继承、多态、运算符重载、文件单元测验

(满分100)

班级学号姓名成绩

一、选择题（每小题1分，共30分）

1．下列表示引用的方法中， (1) 是正确的。已知：int m=10：

A．int &x=m；B．int &y=10；C．int &z；D．float &t=&m；2．一个类的友元函数能够访问该类的 (2) 。

A．私有成员 B．保护成员C．公有成员 D．所有成员

3．下面关于友元的描述中，错误的是 (3) 。

A．友元函数可以访问该类的私有数据成员

B．一个类的友元类中的成员函数都是这个类的友元函数

C．友元可以提高程序的运行效率

D．类与类之间的友元关系可以继承

4．关于虚函数的描述中， (4) 是正确的。

A．虚函数是一个static类型的成员函数

B．虚函数是一个非成员函数

C．基类中说明了虚函数后，派生类中其对应的函数可不必说明为虚函数

D．派生类的虚函数与基类的虚函数具有不同的参数个数和类型

5．实现运行时的多态性要使用 (5) 。

A．重载函数 B．构造函数 C．析构函数 D．虚函数

6．如果一个类至少有一个纯虚函数，那么就称该类为 (6) 。

A．抽象类B．虚基类C．派生类D．以上都不对

7．关于纯虚函数和抽象类的描述中， (7) 是错误的。

A．纯虚函数是一种特殊的虚函数，它没有具体的定义

B．抽象类是指具有纯虚函数的类

C．一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类

D．抽象类只能作为基类来使用，其纯虚函数的定义由派生类给出

8．下列描述中， (8) 是抽象类的特性。

A．可以说明虚函数B．可以进行构造函数重载

C．可以定义友元函数D．不能说明其对象

9． (9) 是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自已的版本。

A．虚析构函数B．虚构造函数C．纯虚函数D．静态成员函数10．在下面的程序中，A、B、C、D四句编译时出现错误的是 (10) 。

Class A // A

{

public： // B

A(){func()；} // C

virtual void func()=O； // D

}；

11．下列关于运行时的多态性的叙述不正确的是 (11) 。

A．运行时的多态性要通过虚函数来实现

B．运行时的多态性要通过指向基类的指针来实现

C．运行时的多态性是在编译时确定其要执行的函数

D．运行时的多态性是在执行过程中根据具体被操作的对象来确定要运行的函数

答案：C

12. 在以下类定义中， (12) 的虚基类

A)类B、类C是类A B)类A是类B、类C C)类B、类C是类D D)类A是类D

class A{

public:

int x;

A(int a=0){x=a;}

};

class B:public virtual A

{ ... };

class C:virtual public A

{ ... };

class D:public B,public C

{ A x;

public:

int m;

D(int a,int b,int c):B(a),C(b),x(c) //F

...

};

13．下列运算符中， (13) 运算符在C++中不能重载。

A．&& B．[] C．：：D．new

14．下列关于运算符重载的描述中， (14) 是正确的。

A．运算符重载可以改变操作数的个数

B．运算符重载可以改变优先级

C．运算符重载可以改变结合性

D．运算符重载不可以改变语法结构

15．友元运算符objl>obj2被C++编译器解释为 (15) 。

A．operator>(objl，obj2) B．>(obj1，obj2)

C．obj2．operator：>(obj1) D．objl．operator>(obj2)

16．现需要对list类对象使用的逻辑运算符“==”重载，以下函数声明 (16) 是正确的。

A、list & list：：operator==(const list &a)；

B、list list：：operator==(const list &a)；

C、bool & list：：operator==(const list &a)；

D、bool list：：operator==(const list &a)；

17. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。如果主函数中有定义：

fun m,c,d;，那么，执行语句c=m++; 时，编译器把m++解释为： (17)

A) c.operator++(m); B) m=operator++(m);

C) m.operator++(m); D) operator++(m);

class fun

{ public:

.. .. ..

fun operator +=(fun );

friend fun operator ++(fun &,int);

};

18．按文件的访问方式不同，C++文件可分为(18)

A、文本文件、二进制文件

B、顺序文件、随机文件

C、ASCII文件、顺序文件

D、数据文件、文本文件

19．操作磁盘文件时需要包含 (19) 文件

A) iostream.h B) fstream.h C) iomanip.h D) stdlib.h

20. 打开一个磁盘文件可以使用如ofstream ofile("A:data.txt"); 的语句，

句中的ofile函数是文件流类的 (20)

A) 成员函数 B) 系统函数 C)构造函数 D)自定义函数

21．C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过 (21) ，派生出新的类。

A．复用B．继承

C．单继承D．多继承

22．继承具有 (22) ，即当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员。

A．规律性B．传递性C．重复性D．多样性

23．在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则

(23) 。

A．完全相同B．完全不同

C．部分相同，部分不同D．以上都不对

24．基类的 (24) 不能为派生类的成员访问，基类的 (25) 在派生类中的性质和继承的性质一样，而基类的 (26) 在私有继承时在派生类中成为私有成员，在公有和保护继承时在派生类中仍为保护成员。

A．公有成员B．私有成员

C．私有成员函数 D．保护成员

25．派生类的构造函数的成员初始化列表中，不能包含 (27) 。

A．基类的构造函数B．派生类中子对象的初始化

C．基类的子对象初始化D．派生类中一般数据成员的初始化26．对于派生类的构造函数，在定义对象时构造函数的执行顺序为：先执行 (28) ，再执行 (29) ，后执行 (30) 。

A．基类的构造函数B．成员对象的构造函数 C．派生类本身的构造函数

D．抽象类的构造函数

二．填空题（每空1分，共10分）

1．在c++中，将多态性分为静态多态性和动态多态性两种。函数重载属于 (1) 多态性，虚函数属于 (2) 多态性。

2．用一个类定义了一个指针变量，但这个指针变量只能指向它的派生类的对象。这个类必定是： (3)

3．利用成员函数对双目运算符重载，其左操作数为 (4) ，右操作数为 (5) 。

4．在c++中，运算符的重载有两种实现方法，一种是通过 (6) 来实现，另一种通过成员函数来实现。

5. 当用成员函数重载双目运算符时，运算符的左操作数必定是： (7)

6. C++允许用户利用fstream类来定义非标准的文件对象。当被定义的对象是调用重载

运算符”>>”或”<<”来读取或写入文件时，这个文件必定是__(8)__文件。

7．ifstream类的对象是用于文件（9）的，而ofstream类的对象则是用于文件（10）的。

三．程序分析题（每输出行2分，共46分）

1．以下程序的执行结果是。

#include

class base{

public：

virtual void who(){cout<<”base class”<

}；

class derivel：public base{

public：

void who(){cout<<”derivel class”<

}；

class derive2：public base{

public：

void who(){cout<<”derive2 class”<

}；

void main(){

base objl，*p；

derivel obj2；

derive2 obj3；

p=&objl；

p->who()；

p=&obj2；

p->who()；

p=&obj3；

p->who()；

}

2．以下程序的执行结果是。

#include

class A{

public：

virtual void funl(){cout<< “ A funl”<

virtual void fun2(){cout<<”A fun2”<

void fun3(){ cout<<”A fun3”<

void fun4(){ cout<<”A fun4”<

}；

class B：public A{

public：

virtual void funl(){ cout<<”B funl”<

virtual void fun2(int x){cout<<”B fun2”<

virtual void fun3(){cout<<“ B fun3”<

void fun4(){cout<<”B fun4”<

}；

void main(){

A *p；

B b；

p=＆b；

p->funl()；

p->fun2()；

p->fun3()；

p->fun4()；

}

3．以下程序的执行结果是。

#include

class base{

public：

virtual void fl(){cout<<”fl function of base”<

}；

class derive：public base{

void fl(){cout<<”fl function of derive”<

}

void main(){

base obj1，*p；

derive obj2；

p=&objl；

p->fl()；

p->f2()；

p->f3()；

p=&obj2；

p->fl()；

p->f2()；

p->f4()；

}

3．以下程序的执行结果是。

#include

class Sample{

int n；

public：

Sample(){}

Sample(int m){n=m；}

int &operator--(int){

n--；

return n；

}

void disp(){ cout<<”rl=”<

void main(){

Sample s(10)；

(S--)++；

S．disp()；

}

5．以下程序的执行结果是。

#include

int f(int i){ return++i；}

int g(int &i){ return ++i；}

void main(){

int a，b；

a=b=0；

a+=f(g(a))；

b+=f(f(b))；

cout<<”a=”<

}

6．以下程序的执行结果是。

#include

class Sample{

int x；

public：

Sample(){}；

void setx(int i){ x=i；}

friend int fun(Sample B[]，int n){

int m=0；

for(int i=0； i

if(B[i]．x>m)m=B[i]．x；

return m;

}

}；

void main(){

Sample A[10]；

int Arr[]={90，87，42，78，97，84，60，55，78，65}；

for(int i=0；i<10； i++)

A[i]．setx(Arr[i])；

cout<

}

7．以下程序的执行结果是。

#include

class base{

public：

base(){

cout<<“构造base对象”<

f()； //调用base类的f()函数

}

virtual void f(){ cout<<”调用base：：f()”<

class derive：public base{

public：

derive(){

cout<<”构造derive对象”<

f()； //调用derive类的f()函数

}

void f(){ cout<<”调用derive：：f()”<

}；

void main(){

derive d；

}

8．以下程序的执行结果是。

#include

class Sample{

int n；

public：

Sample(){}

Sample(int i){n=i；}

void setn(int i){n=i；}

int getn(){return n；}

void disp(){ cout<<”n：”<

}；

Sample&add(Sample &s1，Sample s2){

s1．setn(s1．getn()+s2．getn()}；

return sl；

}

void main()

{

Sample s1(2)，s2(5)，s3；

S3=add(s1，s2)；

S1．disp()；

S2．disp()；

S3．disp()；

}

四．简答题（4分）

1．阅读下面类的定义，找出程序中的错误，并说明错误原因。

#include

class Sample{

char chl，ch2；

public：

friend void set(Sample&s，char)；

}；

void set(Sample &s，char c){

s．chl=c；

}

void set(Sample &s，char cl，char c2){

s．ch1=c1；

s．ch2=c2；

}

void main(){

Sample obj；

set(obj，5)；

}

五、完善程序题（每空2分，共10分）

1. 本程序调用构造函数实现字符串对象的初始化。调用重载运算符”+”把两个字符串拼接，

并通过重载运算符“>”来实现字符串的比较运算。

#include

#include

class string

{ char *str;

public:

string(char *s=0){

if(_(1)_){str=new char[strlen(s)+1]; strcpy(__(2)__);}

else str=0;

}

friend string operator+(string &,string &);

int operator>(string &);

void show(){ if(str)cout<

};

string operator+(string &s1,string &s2){

string t;

t.str=____(3)_____;

strcat(t.str,s2.str);

______(4)_______;

}

int string::operator>(string &s){

if(strcmp(____(5)_____)>0)return 1;

else return 0;

}

void main(void){

string s1("southeast university"),s2("mechanical department");

string s3; s3=s1+s2;

s1.show(); s2.show(); s3.show();

cout<<(s1>s2)<<'\n';

}

“继承、多态、运算符重载、文件”单元测验

参考答案

二、填空题（每空1分，共10分）

（1）静态（2）动态（3）抽象类（4）this指针（5）成员函数参数（6）友元（7)对象（8）文本（9）输入（10）输出

三、程序分析题（每输出行2分，共46分）

四．简答题（4分）

五、完善程序题（每空2分，共10分）

运算符重载基础概念练习题

运算符重载基础概念练习题 1、下列运算符中, （）运算符在C++中不能重载。 A = B () C :: D delete 2、下列运算符中, （）运算符在C++中不能重载。 A ?: B [] C new D && 3、下列关于C++运算符函数的返回类型的描述中,错误的是（）。 A 可以是类类型 B 可以是int类型 C 可以是void类型 D 可以是float类型 4、下列运算符不能用友元函数重载的是（）。 A + B = C * D << 5、在重载运算符函数时,下面（）运算符必须重载为类成员函数形式。 A + B - C ++ D -> 6、下列关于运算符重载的描述中,正确的是（）。 A 运算符重载可以改变运算符的操作数的个数 B 运算符重载可以改变优先级 C 运算符重载可以改变结合性 D 运算符重载不可以改变语法结构 7、友元运算符obj>obj2被C++编译器解释为（）。 A operator>(obj1,obj2) B >(obj1,obj2) C obj2.operator>(obj1) D obj1.oprator>(obj2) 8、在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（）。 A operator+有两个参数，operator*有两个参数 B operator+有两个参数，operator*有一个参数 C operator+有一个参数，operator*有两个参数 D operator+有一个参数，operator*有一个参数 9、重载赋值操作符时,应声明为（）函数。 A 友元 B 虚 C 成员 D 多态 10、在一个类中可以对一个操作符进行（）重载。 A 1种 B 2种以下 C 3种以下 D 多种 11、在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。

多态参考代码分析

1224: 多态-虚函数问题 Description 请以点类Point为基类派生出一个圆类Circle。Point类的数据成员为x、y（私有属性，存储点的横纵坐标），成员函数有构造函数Point（实现对数据成员x、y的初始化）、输出函数Display（输出点坐标）；圆类Circle的数据成员为r（私有属性，存储圆的半径，圆心的点坐标通过继承点类Point加以实现），成员函数有构造函数Circle、计算圆的面积函数Area、计算圆的周长函数Perimeter和输出函数Display，其中构造函数实现基类和圆类的数据成员的初始化，Display函数实现圆心坐标、圆的半径、圆的面积（利用Area函数实现）和圆的周长（利用Perimeter函数实现）的输出。实现Point类和Circle类的定义及成员函数。主函数的代码（不允许改动）如下： int main() { double x,y,r; cin>>x>>y>>r; //圆心的点坐标及圆的半径 Point *p; p=new Point(x,y); p->Display(); p=new Circle(x,y,r); p->Display(); return 0; } 说明：圆周率PI的取值为3.14 提示：Display应设计为虚函数 Input Output Sample Input 0 0 1 Sample Output Point(0,0) Circle's center:Point(0,0) Radius:1 Area:3.14 Perimeter:6.28 **************************************************************** #include using namespace std; const double PI=3.14; class Point { private: double x,y; public:

实验报告类的重载继承和多态

实验报告类的重载继承和多态 篇一：实验三_类的重载继承和多态_() 篇二：实验三_类的重载继承和多态 篇三：C++实验报告(类和对象重载与继承多态和模板异常和流) C++实验报告 目录 C++实验报告 ................................................ ................................................... (4) 实验一：类和对象 ................................................ ................................................... . (4) 1．................................................ ................................................... . (4) 代码 ................................................

................................................... .. (4) 运行结果 ................................................ ................................................... (5) 2.................................................. ................................................... (5) 思路： .............................................. ................................................... . (5) 代码 ................................................ ................................................... (5) 运行结果 ................................................ ...................................................

c 运算符的重载习题答案

1.概念填空题 1.1运算符重载是对已有的运算符赋予多重含义，使同一个运算符在作用于不同类型对象时导致不同的行为。运算符重载的实质是函数重载，是类的多态性特征。 1.2可以定义一种特殊的类型转换函数，将类的对象转换成基本数据类型的数据。但是这种类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。类类型转换函数既没有参数，也不显式给出返回类型。类类型函数中必须有return 表达式的语句返回函数值。一个类可以定义多个类类型转换函数。 1.3运算符重载时其函数名由operator运算符构成。成员函数重载双目运算符时,左操作数是对象,右操作数是函数参数。 2.简答题 2.2简述运算符重载的规则。 2.2简述重载单目运算符++、--，前置和后置时的差别。 2.3 C++中重运算符是否都可以重载?是否都可以重载成类的成员函数?是否都可以重载成类的友元函数? 2.4 构造函数作为类型转换函数的条件是什么。 3．选择题 3.1在下列运算符中,不能重载的是(B) A.！ B. sizeof C. new D. delete 3.2 不能用友员函数重载的是(A)。 A.= B.== C.<= D.++ 3.3下列函数中,不能重载运算符的函数是(B)。 A.成员函数 B.构造函数 C.普通函数 D.友员函数 3.4如果表达式++i*k时中的”++”和”*”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为（B）。 A．operator*(i.operator++(),k) B．operator*(operator++(i),k) C．i.operator++().operator*(k) D．k.operator*(operator++(i)) 3.5已知在一个类体中包含如下函数原型：VOLUME operator-(VOLUME)const；下列关于这个函数的叙述中，错误的是（B ）。 A．这是运算符-的重载运算符函数 B．这个函数所重载的运算符是一个一元运算符 C．这是一个成员函数 D．这个函数不改变数据成员的值 3.6在表达式x＋y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。下列叙述中正确的是（C ）。 A．operator+有两个参数，operator*有两个参数 B．operator+有两个参数，operator*有一个参数 C．operator+有一个参数，operator*有两个参数 D．operator+有一个参数，operator*有一个参数 4.写出下列程序运行结果 4.1#include #using namesoace std;

C#中区别多态、重载、重写的概念和语法结构

重写是指重写基类的方法，在基类中的方法必须有修饰符virtual，而在子类的方法中必须指明override。 格式： 基类中： public virtual void myMethod() { } 子类中： public override void myMethod() { } 重写以后，用基类对象和子类对象访问myMethod()方法，结果都是访问在子类中重新定义的方法，基类的方法相当于被覆盖掉了。 重载 用于在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。 public void test(int x,int y){} public void test(int x,ref int y){} public void test(int x,int y,string a){} 重载特征： I.方法名必须相同 II.参数列表必须不相同，与参数列表的顺序无关 III.返回值类型可以不相同 ========================= 但如果有泛型，就要注意了！ 多态 c#的多态性主要体现在类的继承上: 子类继承父类的时候,可能出现同名但方法定义不同的情况, 所以在子类中会将原方法覆盖,实现自身的要求. using System; class Employee { virtual public void CalculatePlay() { Console.WriteLine("Employee");

} }; class SalariedEmployee: Employee { override public void CalculatePlay() { Console.WriteLine("Salary"); } }; class PolyApp { public static void Main() { Employee baseE1 = new Employee(); baseE1.CalculatePlay(); Employee baseE2 = new SalariedEmployee(); baseE2.CalculatePlay(); SalariedEmployee s = new SalariedEmployee(); s.CalculatePlay();

习题10-运算符重载与多态性

C 、可以是void 类型 D 、可以是float 类型 A 、运算符重载可以改变运算符的操作数的个数 B 、运算符重载可以改变优先级 C 、运算符重载可以改变结合性 D 、运算符重载不可以改变语法结构 A 、动态联编是以虚函数为基础的 B 、动态联编是在运行时确定所调用的函数代码的 C 、动态联编调用函数操作是指向对象的指针或对象引用 D 、动态联编是在编译时确定操作函数的 A 、虚函数是一个静态成员函数 B 、虚函数是一个非成员函数 C 、虚函数既可以在函数说明时定义，也可以在函数实现时定义 D 、派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型 B 、重载函数和析构函数 C 、虚函数和对象 习题 10 运算符重载与多 态性 、单项选择题 A 、 ? : B 、 [ ] C 、 new D 、 && 2、 下列运算符不能用友元函数重载的是（ ）。 A 、 + B 、 = C 、 * D 、 << 3、 在一个类中可以对一个操作符进行（ ）重载。 A 、 1种 B 、 2 种以下 C 、 3 种以下 D 、 多种 4、友元运算符 obj1>obj2 被 C++ 编译器解释为（ ）。 1、下列运算符中，（ ）运算符在C++中不能重载。 A 、 operator > (obj1, obj2) B 、 > (obj1, obj2) C 、 obj2.operator > （obj1） D 、 obj1.operator > （obj2） 5、下列关于C++运算符函数的返回类型的描述中，错误的是（ ） 。 A 、可以是类类型 B 、可以是int 类型 6、下列关于运算符重载的描述中，正确的是（ ）。 9、对虚函数的调用（ ） 。 A 、 定使用动态联编 B 、必须使用动态联编 C 、 定使用静态联编 D 、不一定使用动态联编 10、编译时的多态性可以通过使用（ ）获 得。 7、下列关于动态联编的描述中，错误的是（ ）。 8、关于虚函数的描述中，正确的是（ ）。 A 、虚函数和指针 D 、虚函数和引用

C中用运算符重载实现矩阵运算

走进3D的世界 -- C++中用运算符重载实现矩阵运算 作者：周军 矩阵(Matrix)无处不在，我们的生活中到处都能找到矩阵的身影，然而此处我不想把这个定义放大，我们只讨论线性代数中的矩阵，我们要用它们来完成我们的3D变换。为什么矩阵可以完成3D变换呢？下面，我们就来介绍矩阵是如何变换坐标的： 设空间中有一坐标(x,y,z)，如果我们想把它变换成另一坐标(x,’y’,z’)，我们可以进行如下操作： = (x’,y’,z’,1) 这就是矩阵的妙用了。它在复杂处理变换的时候表现得尤为突出。假设我们想要把一个物体先沿z轴旋转角thetaZ，再沿x轴旋转角thetaX，我们可以进行如下操作(pseudo-code): obj*=rotX(thetaX)*rotZ(thetaZ); 注意：矩阵的乘法是不可逆的，而且我们要按变化顺序的逆序进行乘法，具体推导见计算几何相关书籍。 下面，我们进入正题：如何再C++中用重载运算符的方法来进行矩阵运算以完成线性变换呢？我们需要变换坐标，所以很自然地，我们需要一个向量(Vector)类；同时我们要进行

为直观、人性化，我选用了运算符重载这以技巧而不是简单地调用函数，下面请看我的具体实现：

以上便是CVector类的具体实现，我想对C++和线性代数有所了解的读者都能很清楚地理解这段代码，在次不累述。 上述代码的成员函数实在类外定义的，如果读者在实践中为了提高速度可以把这些成员函数定义在类内以起到内联函数的作用，可以省去参数压栈、出栈时的时间。 下面是CMatrix类的具体实现：

是不是也很好理解呢？哈哈，这就是用运算符重载的好处。不过这种方法也确实有它的不足，而且这个不足在游戏编程中是致命的，那就是效率不高，这也正是为什么Microsoft 在DirectX中也使用难看的一般函数调用来完成矩阵运算的原因。影响速度的主要原因是在使用运算符+、-、*、/等时，程序会在每次运算时创建临时对象再将临时对象返回，对于重复多次的矩阵运算来说，这无疑成为了一笔庞大的额外开销（好在现在的计算机的处理速度还算快）。但注意：在使用+=、-=、*=、/=时不会有上述问题，因为在使用这些运算符时程序只需要修改第一个对象不需要创建并返回临时对象。所以在能使用+=、-=、*=、/=时尽量不要使用单一的=、-、*、/运算符。 好了，这两个类我们已经封装好了，下面还有什么呢？是的，忘了向大家交代旋转矩阵了：

继承与多态的习题

一：选择题 1. 下面有关析构函数的说法中，不正确的是( ) A．析构函数中不可包含Return语句 B．一个类中只能有一个析构函数 C．用户可定义有参析构函数 D．析构函数在对象被撤销时，被自动调用 2．派生类不可以访问基类的( ) A．Public成员B．Private成员 C．Protected成员D．Protected internel成员 3．有关sealed修饰符，描述正确的是( ) A．密封类可以被继承 B．abstract修饰符可以和sealed修饰符一起使用 C．密封类不能实例化 D．使用sealed修饰符可保证此类不能被派生 4．若想从派生类中访问基类的成员，可以使用( ) A．this关键字B．me关键字 C．base关键字D．override关键字 5．下面有关派生类的描述中，不正确的是( ) A．派生类可以继承基类的构造函数 B．派生类可以隐藏和重载基类的成员 C．派生类不能访问基类的私有成员 D．派生类只能有一个直接基类 6．C#中，继承具有( )，即A类派生B类，B类又派生C类，则C类会继承B类中的成员和A类中的成员。 A．传递性B．多态性C．单继承D．多继承 7．下面有关静态方法的描述中，错误的是( ) A．静态方法属于类，不属于实例 B．静态方法可以直接用类名调用 C．静态方法中，可以定义非静态的局部变量 D．静态方法中，可以访问实例方法 8．下面关于运算符重载的描述中，错误的是( ) A．重载的运算符仍然保持其原来的操作数个数、优先级和结合性不变 B．可以重载双目运算符，不可以重载单目运算符 C．运算符重载函数必须是public的 D．运算符重载函数必须是static的 9．下面对派生类和基类的关系的描述中，不正确的是( ) A．派生类的方法可以和基类的方法同名 B．派生类是对基类的进一步扩充 C．派生类也可作另一个派生类的基类 D．派生类继承基类的公有、保护和私有成员 10.下面关于虚方法的描述中，正确的是（） A．虚方法可以实现静态联编 B．在一个程序中，不能有同名的虚方法 C．虚方法必须是类的静态成员

c++运算符重载习题

Task8-1 /* 1. 定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。将运算符函数重载为非成员、非友元的普通函数。编写程序，求两个复数之和*/ #include using namespace std; class Complex { public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} void display(); double real; double imag; }; void Complex::display() { cout<<"("<