练习题—方法和方法的重载

练习题—方法和方法的重载
练习题—方法和方法的重载

一.选择题

1.下列方法定义中,正确的是( )。

A)int x( int a,b ) { return (a-b); }

B)double x( int a,int b) { int w; w=a-b; }

C)double x( a,b ) { return b; }

D)nt x( int a,int b) { return a-b; }

2.下列方法定义中,正确的是( )。

A)void x( int a,int b ); { return (a-b); }

B)x( int a,int b) { return a-b; }

C)double x { return b; }

D)int x( int a,int b) { return a+b; }

3.下列方法定义中,不正确的是( )。

A)float x( int a,int b ) { return (a-b); }

B)int x( int a,int b) { return a-b; }

C)int x( int a,int b ) { return a*b; }

D)int x(int a,int b) { return 1.2*(a+b); }

4.下列方法定义中,正确的是( )。

A)int x( ){ char ch='a'; return (int)ch; }

B)void x( ){ ...return true; }

C)int x( ){ ...return true; }

D)nt x( int a, b){ return a+b; }

5.下列方法定义中,方法头不正确的是( )。

A)public int x( ){ ... }

B)public static int x( double y ){ ... }

C)void x( double d ) { ... }

D)public static x( double a ){ ... }

6.在某个类中存在一个方法:void getSort(int x),以下能作为这个方法的重载的声明的是( )。

A)public getSort(float x) B)int getSort(int y)

C)double getSort(int x,int y) D)void get(int x,int y)

7.在某个类中存在一个方法:void sort(int x),以下不能作为这个方法的重载的声明的是( )。

A)public float sort(float x) B)int sort(int y)

C)double sort(int x,int y) D)void sort(double y)

8.为了区分类中重载的同名的不同方法,要求( )。

A)采用不同的形式参数列表B)返回值类型不同

C)调用时用类名或对象名做前缀D)参数名不同

二.填空题

1.以下方法fun的功能是求两参数之积。

int fun ( int a, int b ) { __________________; }

2.以下方法fun的功能是求两参数之积。

float fun ( int a, double b ) { __________________; }

3.以下方法fun的功能是求两参数的最大值。

int fun ( int a, int b ) { __________________; }

4.以下方法m的功能是求两参数之积的整数部分。

int m ( float x, float y ) { __________________; }

5.下面方法的功能是判断一个整数是否为偶数,将程序补充完整。

public ________ isEven(int a)

{ if(a%2==0)

return _____;

else

return false;

}

6.同一个类中多个方法具有相同的方法名,不同的_____________称为方法的重载。

三编程题

1.编写一个方法将华氏温度转换成摄氏温度,同时在main方法中调用该方法将转换成的摄氏温度在屏幕上显示出来:

转换公式为:摄氏度=(5/9)*(华氏度-32)

2. 编写方法,判断一个数是否是水仙花数。水仙花数是指个位、十位和百位三个数的立方和等于这个三位数本身的数。使用如下方法说明:boolean isShuiXianHua(int n)。并在main 方法中调用该方法打印输出所有的水仙花数。

3. 利用方法重载的概念,写三个方法分别求int型数据的绝对值,float型数据的绝对值和

double型数据的绝对值。

四挑战题

1. 编写一个方法打印a行的三角形。例如当a=3时,打印出如下图形。然后在main方法中

调用方法,打印出a=8时的图形。

*

**

***

2.编写一个方法求a+aa+aaa+…+a..a(n个)的和,其中a为1~9之间的整数,例如,如当a=3、n=4时,求3+33+333+3333的和。然后在main方法中利用该方法求a=4,n=5时的和,并输出到显示器上。

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

运算符重载基础概念练习题 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、在重载一个运算符时,其参数表中没有任何参数,这表明该运算符是()。

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++期末复习--1.练习题_选择

面向对象程序设计综合练习(单选题) 单选题 1.C++源程序文件的缺省扩展名为( )。 A. cpp B. exe C. obj D. lik 2.程序运行中需要从键盘上输入多于一个数据时,各数据之间应使用( )符号作为分 隔符。 A. 空格或逗号 B. 逗号或回车 C. 逗号或分号 D. 空格或回车 3.关于封装,下列说法中不正确的是()。 A. 通过封装,对象的全部属性和操作结合在一起,形成一个整体 B. 通过封装,一个对象的实现细节被尽可能地隐藏起来(不可见) C. 通过封装,每个对象都成为相对独立的实体 D. 通过封装,对象的属性都是不可见的 4.面向对象软件开发中使用的OOA表示()。 A. 面向对象分析 B. 面向对象设计 C. 面向对象语言 D. 面向对象方法 5.面向对象软件开发中使用的OOD表示()。 A. 面向对象分析 B. 面向对象设计 C. 面向对象语言 D. 面向对象方法 6.在一个类的定义中,包含有()成员的定义。 A. 数据 B. 函数 C. 数据和函数 D. 数据或函数 7.在类作用域中能够通过直接使用该类的()成员名进行访问。 A. 私有 B. 公用 C. 保护 D. 任何 8.在关键字public后面定义的成员为类的()成员。 A. 私有 B. 公用 C. 保护 D. 任何 9.在关键字private后面定义的成员为类的()成员。 A. 私有 B. 公用 C. 保护 D. 任何 10.假定AA为一个类,a为该类公有的数据成员,x为该类的一个对象,则访问x对象 中数据成员a的格式为()。 A. x(a) B. x[a] C. x->a D. x.a 11.假定AA为一个类,a()为该类公有的成员函数,x为该类的一个对象,则访问x对象 中成员函数a()的格式为()。 A. x.a B. x.a() C. x->a D. x->a() 12.假定AA为一个类,a为该类公有的数据成员,px为指向该类对象的一个指针,则访 问px所指对象中数据成员a的格式为()。 A. px(a) B. px[a] C. px->a D. px.a 13.假定AA为一个类,a为该类私有的数据成员,GetValue()为该类公有成员函数,它 返回a的值,x为该类的一个对象,则访问x对象中数据成员a的格式为()。 A. x.a B. x.a() C. x->GetValue() D. x.GetValue() 14.假定AA为一个类,int a()为该类的一个成员函数,若该成员函数在类定义体外定 义,则函数头为()。 A. int AA::a() B. int AA:a() C. AA::a() D. AA::int a() 15.假定AA为一个类,a为该类公有的数据成员,若要在该类的一个成员函数中访问它,

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.下列运算符中,运算符在C++中不能重载。 A.?: B.+ C. D.<= 解:C++中不能被重载的运算符有:·,一,::,?:。本题答案为A。 2.下列运算符中,运算符在C++中不能重载。 A.&& B.[] C.:: D.new 解:c++中不能被重载的运算符有:·,·+,::,?:。本题答案为c。 3.下列关于运算符重载的描述中,是正确的。 A.运算符重载可以改变操作数的个数 B.运算符重载可以改变优先级 C.运算符重载可以改变结合性 D.运算符重载不可以改变语法结构 解:运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算程的语法结构。本题答案为D。 4.友元运算符objl>obj2被C++编译器解释为。 A.operator>(objl,obj2) B.>(obj1,obj2) C.obj2.operator:>(obj1) D.objl.operator>(obj2) 解:重载为友元函数的运算符的调用形式如下: operator<运算符>(<参数1>,<参数2>) 等价于:<参数1><运算符><参数2> 本题答案为A。 5.现需要对list类对象使用的逻辑运算符“==”重载,以下函数声明是正确的。 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); 6. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。如果主函数中有定义: fun m,c,d;,那么,执行语句c=m++; 时,编译器把m++解释为: (33) 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); }; 答案:D 7. 在第33题中,当执行语句d+=m; 时,C++编译器对语句作如下解释: (34) A. d=operator+=(m); B. m=operator+=(d); C. d.operator+=(m); D. m.operator+=(d); 答案:C 8. 设有以下类定义,其中说明了“+”运算符重载函数的原型。这是一个友元函数,当类

练习题—方法和方法的重载

一.选择题 1.下列方法定义中,正确的是( )。 A)int x( int a,b ) { return (a-b); } B)double x( int a,int b) { int w; w=a-b; } C)double x( a,b ) { return b; } D)nt x( int a,int b) { return a-b; } 2.下列方法定义中,正确的是( )。 A)void x( int a,int b ); { return (a-b); } B)x( int a,int b) { return a-b; } C)double x { return b; } D)int x( int a,int b) { return a+b; } 3.下列方法定义中,不正确的是( )。 A)float x( int a,int b ) { return (a-b); } B)int x( int a,int b) { return a-b; } C)int x( int a,int b ) { return a*b; } D)int x(int a,int b) { return 1.2*(a+b); } 4.下列方法定义中,正确的是( )。 A)int x( ){ char ch='a'; return (int)ch; } B)void x( ){ ...return true; } C)int x( ){ ...return true; } D)nt x( int a, b){ return a+b; } 5.下列方法定义中,方法头不正确的是( )。 A)public int x( ){ ... } B)public static int x( double y ){ ... } C)void x( double d ) { ... } D)public static x( double a ){ ... } 6.在某个类中存在一个方法:void getSort(int x),以下能作为这个方法的重载的声明的是( )。 A)public getSort(float x) B)int getSort(int y) C)double getSort(int x,int y) D)void get(int x,int y) 7.在某个类中存在一个方法:void sort(int x),以下不能作为这个方法的重载的声明的是( )。 A)public float sort(float x) B)int sort(int y) C)double sort(int x,int y) D)void sort(double y) 8.为了区分类中重载的同名的不同方法,要求( )。 A)采用不同的形式参数列表B)返回值类型不同 C)调用时用类名或对象名做前缀D)参数名不同

第十章 运算符重载 复习题

运算符重载复习题 1. 重载赋值操作符时,应声明为( ) A. 友元函数 B. 虚函数 C. 成员函数 D. 多态函数 2.关于重载的描述,正确的是( ) A.函数重载只能在成员函数之间进行 B.函数重载只能在全局函数之间进行 C.函数重载可以在基类和派生类之间进行 D.函数重载必须要求同名的函数的形参类型和个数都完全一致,返回值类型无所谓 3.下列运算符中不能重载的是( )。 A.∷(域运算符) B.+ (正) C.++ (自增) D.*(指针) 4. 派生类的对象对它的基类成员中() A. 公有继承的公有成员是可以访问的 B. 公有继承的私有成员是可以访问的 C. 公有继承的保护成员是可以访问的 D. 私有继承的公有成员是可以访问的 5 不能重载的运算符是() A. ?: B. [ ] C. new D. && 6. C++中不能重载的运算符是( ) A. new B. += C. sizeof D. && 7.重载函数是( ) A.以函数参数来区分,而不用函数的返回值来区分不同的函数 B.以函数的返回值来区分,而不用函数参数来区分不同的函数 C.参数表完全相同而返回值类型不同的两个或多个同名函数 D.参数表和返回值类型中至少有一个不同的两个或多个同名函数 8.对于运算符重载,说法正确的是( ) A.运算符如果被重载为非成员函数,那么对象就不能利用这个运算符重载函数进行操作 B.运算符重载函数可能既不是成员函数,也不是友元函数 C.用户每定义一个类,系统会自动提供一个赋值运算符重载函数,所以完全不 必考虑重载赋值运算符函数 D.一个类的虚函数不能调用运算符重载函数 9. C++中不能重载的运算符是( )

运算符重载题目

二、运算符重载(运算符重载的基本概念、运算符重载方法、运算符重载规则、特殊运算符重载和类型转换) 单选题10道: 1、假定要对类AB定义加号操作符重载成员函数,实现两个AB类对象的加法,并返回相加结果,则该成员函数的声明语句为( B )。 A. AB operator+(AB& a,AB& b) B. AB operator+(AB& a) C. operator+(AB a) D. AB &operator+( ) 2、关于运算符重载,下面的叙述错误的是()。 A.运算符预定义的操作数个数不能改变 B.重载不能改变运算符的优先级顺序 C.参数的类型没有限制 D.尽量使其与原意保持一致 3、在一个类中可以对一个操作符进行(D )重载。 A. 1种 B. 2种以下 C. 3种以下 D. 多种 4、重载赋值操作符时,应声明为(C )函数。 A. 友元 B. 虚 C. 成员 D. 多态 5、要在类对象使用运算符,以下不必被重载的运算符是( A )。 A. [] B. = C. ++ D. -- 6、下列运算符中,不能重载的是(C ) A.new B.() C.::D.&& 7、在表达式x+y*z中,+ 是作为成员函数重载的运算符,*是作为非成员函数重载的运算符。下列叙述中正确的是( A )。 A)operator+有两个参数,operator*有两个参数 B)operator+有两个参数,operator*有一个参数 C)operator+有一个参数,operator*有两个参数 D)operator+有一个参数,operator*有一个参数 8、友元运算符obj1>obj2被C++编译器解释为()。 A) operator>(obj1,obj2) B) >(obj1,obj2) C) obj1.operator>(obj2) D) obj2.operator>(obj1) 9、已知某个类的友元函数重载了+=和-,a,b,c是该类的对象,则“a+=b-c”被C++编译器解释为()。 A) operator+=(a,operator-(b,c)) B) a.operator+=(b.operator-(c)) C) operator+=(a,b.operator-(c)) D) a.operator+=(operator-(b,c)) 10、下列运算符中,必须使用成员函数进行重载的是()。 A) == B) = C) >> D) ++ 填空题10道: 1、多数运算符既能作为类的成员函数重载,也能作为类的非成员函数重载,但运算符“[]”只能作为类的函数重载。 2、加法运算符“+”和赋值运算符“=”都重载之后,“+=”也被重载了。 3、单目运算符作为类的成员函数重载时形参。 4、利用成员函数对二元运算符重载时,其右操作数为。 5、重载运算符函数的函数名由关键字引出。 6、运算符的重载归根结底是的重载。 7、后缀自增自减运算符定义时带有一个。

第7章 运算符重载-习题

《面向对象程序设计》习题 班级:学号:姓名:名单序号:成绩: 第7章运算符重载和多态性 一、选择题(共30分,每题1分) 1.下列运算符中,()运算符在C++中不能重载。 A.?: B.[] C. new D.++ 2.友元重载运算符obj1>obj2被C++编译器解释为()。 A.operator >(obj1,obj2) B.>(obj1,obj2) C.obj2.operator >(obj1) D.obj1.operator >(obj2) 3.重载赋值操作符时,应声明为()函数。 A.友元B.虚C.成员D.多态 4.在重载一个运算符时,其参数表中没有任何参数,这表明该运算符是()。 A. 作为友元函数重载的1元运算符 B. 作为成员函数重载的1元运算符 C. 作为友元函数重载的2元运算符 D. 作为成员函数重载的2元运算符5.在重载一运算符时,若运算符函数的形参表中没有参数,则不可能的情况是()。 A. 该运算符是一个单目运算符。 B. 该运算符函数有一个隐含的参数this。 C. 该运算符函数是类的成员函数。 D. 该运算符函数是类的友元函数。 6. 关于运输符重载,下列表述中正确的是()。 A.C++已有的任何运算符都可以重载 B.运算符函数的返回类型不能声明为基本数据类型 C.在类型转换符函数的定义中不需要声明返回类型 D.可以通过运算符重载来创建C++中原来没有的运算符 7. C ++流中重载的运算符>>是一个()。 A. 用于输出操作的非成员函数 B. 用于输出操作的成员函数 C. 用于输入操作的非成员函数 D. 用于输入操作的成员函数 8. 若要对Data类中重载的加法运算符成员函数进行声明,下列选项中正确的是()。 A. Data +(Data); B. Data operator+(Data); C. Data +operator(Data); D. operator +(Data, Data); 9. 下列运算符中哪些是不能够被重载的()。 A. .,.*,sizeof,::,?: B. ++,--,new,= = C. new,delete,>=,[ ] D. +,-,=,delete 10. 在名为BigNumber类的类体中对运算符函数double进行如下声明: operator double(BigNumbe); 函数声明中有一个明显的错误,这个错误就是()。 A.参数表中不应该有任何参数 B.缺少对函数返回类型的说明 C.参数声明中缺少参数变量 D.函数声明中缺少函数体 11. 下列关于运算符重载的描述中,正确的是()。

C++运算符重载

一、运算符重载的规则 运算符重载规则如下: ①、C++中的运算符除了少数几个之外,全部可以重载,而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要,对原有运算符进行适当的改造。一般来说,重载的功能应当与原有功能相类似,不能改变原运算符的操作对象个数,同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个,它们是:成员运算符“.”、指针运算符“*”、作用域运算符“::”、“sizeof”、条件运算符“?:”。 运算符重载形式有两种,重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为: 函数类型 operator 运算符(形参表) { 函数体; } 运算符重载为类的友元函数的一般语法形式为: friend 函数类型 operator 运算符(形参表) { 函数体; } 其中,函数类型就是运算结果类型;operator是定义运算符重载函数的关键字;运算符是重载的运算符名称。 当运算符重载为类的成员函数时,函数的参数个数比原来的操作个数要少一个;当重载为类的友元函数时,参数个数与原操作数个数相同。原因是重载为类的成员函数时,如果某个对象使用重载了的成员函数,自身的数据可以直接访问,就不需要再放在参数表中进行传递,少了的操作数就是该对象本身。而重载为友元函数时,友元函数对某个对象的数据进行操作,就必须通过该对象的名称来进行,因此使用到的参数都要进行传递,操作数的个数就不会有变化。 运算符重载的主要优点就是允许改变使用于系统内部的运算符的操作方式,以适应用户自定义类型的类似运算。 一般说来,单目运算符最好被重载为成员;对双目运算符最好被重载为友元函数,双目运算符重载为友元函数比重载为成员函数更方便此,但是,有的双目运算符还是重载为成员函数为好,例如,赋值运算符。 二、运算符重载为成员函数 对于双目运算符B,如果要重载B为类的成员函数,使之能够实现表达式oprd1 B oprd2,其中oprd1为类A的对象,则应当把B重载为A类的成员函数,该函数只有一个形参,形参的类型是oprd2所属的类型。经过重载后,表达式oprd1 B oprd2 就相当于函数调用 oprd1.operator B(oprd2).

运算符重载

第4章运算符重载 4.1 什么是运算符重载 所谓重载,就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义,使之实现新功能。 运算符也可以重载。实际上,我们已经在不知不觉之中使用了运算符重载。如:+可以对int、float、double的数据进行加法运算。 现在要讨论的问题是:用户能否根据自己的需要对C++已提供的运算符进行重载,赋予它们新的含义,使之一名多用。譬如,能否用“+”号进行两个复数、两个点的相加。在C++中不能在程序中直接用运算符“+”对复数进行相加运算。用户必须自己设法实现复数相加。 例如用户可以通过定义一个专门的函数来实现复数相加。见下例。 //例4.1 通过函数来实现复数相加。 #include using namespace std; class Complex { public: Complex(){real=0;imag=0;} //构造函数 Complex(double r,double i){real=r;imag=i;} //构造函数重载 Complex complex_add(Complex &c2); //声明复数相加的函数 void display(); //声明输出函数 private: double real, imag; }; Complex Complex::complex_add(Complex &c2) { Complex c; c.real=real+c2.real; c.imag=imag+c2.imag; return c; //以上可简写为:return Complex(real+c2.real,imag+c2.imag); } void Complex::display() { cout<<"("< 8. /// 说明:本实例用于讲述重载的关系 9. /// 作者:周公 10. /// 日期:2008-09-04 11. /// 首发地址:https://www.360docs.net/doc/646787470.html,/zhoufoxcn 12. ///

习题二C++练习(含有答案)

习题二 一、填空题 1. 对运算符进行重载时,不能改变结合性,不能改变操作数个数,不能改变优先级。 2. 当++被重载为后置成员函数时需要0 个参数。 3. 当++被重载为前置成员函数时需要 1 个参数。 4. 在C++中,运算符重载函数可以是成员函数,也可以是友元函数,还可以是普通函数。 5. 友元破坏了类的封装性特性。 6. 类的友元能够访问这个类的所有成员。 7. 类的静态数据成员的初始化是在类外进行的。 8. 类的静态成员函数没有this指针。 9. 类的静态成员函数访问该类的非静态成员可以通过参数传递对象来实现。 10. 不能被重载的类成员函数是构造和析构函数。 二、选择题 1. 已知类A有一个带double型参数的构造函数,且将运算符“+”重载为该类友元函数,若如下语句:A x( 2.5),y( 3.6),z(0); z=x+y; 能够正常运行,运算符重载函数operator+ 应在类中声明为( D )。 A. friend A operator+ (double , double) ; B. friend A operator+ ( double , A &); C. friend A operator+ ( A &, double); D. friend A operator+ ( A & , A &); 2. 下列关于运算符重载的描述中,正确的是(D )。 A. 运算符重载可以改变操作数的个数 B. 运算符重载可以改变优先级 C. 运算符重载可以改变结合性 D. 运算符重载不可以改变语法结构 3. 友元运算符表达式obj1>obj2被C++编译器解释为(A )。 A. operator>(obj1,obj2) B. >(obj1,obj2) C. obj2.operator>(obj1) D. obj1.operator>(obj2) 4. 下列关于C++运算符函数的返回类型的描述中,错误的是(C )。 A. 可以是类类型 B. 可以是int类型

C++程序设计练习题与答案(1)

C++程序设计练习题 一、填空题 1.对象的三大基本特性分别为多态性、( )、封装性。 2.赋值运算符应重载为( )函数。 3.用( )声明的基类称为虚基类。 4.用( )声明的函数称为虚函数。 5.派生类对基类继承控制访问有三种。派生类可以定义其基类中不具备的( )。 6.静态成员是对象的成员,( )函数不是类的成员。 7.在函数体之前加( )关键字可以防止覆盖函数改变数据成员的值。 8.一个const对象只能访问( )成员函数。 9.使用友元函数是为了提高程序效率,且节约了( )开销。 10.类名为“ClassName”的类,其拷贝构造函数的原型说明是( )。 11.由关键字private、public和protected限定成员的访问权限分别是( )、( )和( )。缺省关键字时成员的访问权限为( )。 12.如果想要公共基类在派生类中只有一个拷贝,就要将公共的基类说明为( );如果虚基类没有默认构造函数,就必须在每一个派生类的构造函数中都要调用虚基类的( )函数。 13.静态成员函数是使用关键字( )说明的成员函数。 14.一个函数的原型声明为“void FunName(int=0, double=0, char='x');”,则调用FunName函数的方法共有( )种。 15.编译时多态性是通过( )实现的;运行时多态性是通过( )实现的。 16.C++通过( )实现编译时多态性,通过( )实现运行时多态性。 17.在C++中,声明类的关键字是( )。 18.声明C++模板的关键字是( )。 19.调用函数原型声明为“void FunName(short, int=0, float=1.0);”的方法有( )种。 20.处理C++异常的方法:采用( )结构。 21.用关键字( )、( )和( )限定的成员,其访问权限分别为:公有的、私有的和保护的。缺省关键字时,成员的访问权限为( )。 22.在C++中,处理( )的方法是采用try-catch结构。 23.在C++中,用关键字( )说明内置函数。 24.在C++中,声明友元函数的关键字是( )。 25.将公共基类说明为( )时,多重派生过程中公共基类在派生类中就只有一个拷贝了。 26.在C++中,如果函数调用在前、定义在后,就必须先对函数进行( )。 27.在成员函数头之后、函数体之前加( )修饰的成员函数称为类的常成员函数。 28.包含纯虚函数的类称为抽象类,这种类只能用作( )来派生新类。由于抽象类的特殊性,我们可以说明抽象类的( ),但不能说明抽象类的( )。 29.说明函数类型为“double”、函数名为“virfun”且无参数的纯虚函数的表达形式为( )。 30.说明静态成员要使用关键字( )。

C++运算符重载讲解与经典实例 (2)

C++中预定义的运算符的操作对象只能是基本数据类型,实际上,对于很多用户自定义类型,也需要有类似的运算操作。例如: class complex { public: complex(double r=0.0,double I=0.0){real=r;imag=I;} void display(); private: double real; double imag; }; complex a(10,20),b(5,8); “a+b”运算如何实现?这时候我们需要自己编写程序来说明“+”在作用于complex类对象时,该实现什么样的功能,这就是运算符重载。运算符重载是对已有的运算符赋予多重含义,使同一个运算符作用于不同类型的数据导致不同类型的行为。 运算符重载的实质是函数重载。在实现过程中,首先把指定的运算表达式转化为对运算符函数的调用,运算对象转化为运算符函数的实参,然后根据实参的类型来确定需要调用达标函数,这个过程爱编译过程中完成。 一、运算符重载的规则 运算符重载规则如下: ①、C++中的运算符除了少数几个之外,全部可以重载,而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要,对原有运算符进行适当的改造。一般来说,重载的功能应当与原有功能相类似,不能改变原运算符的操作对象个数,同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个,它们是:成员运算符“.”、指针运算符“*”、作用域运算符“::”、“sizeof”、条件运算符“?:”。 运算符重载形式有两种,重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为: 函数类型 operator 运算符(形参表) { 函数体; } 运算符重载为类的友元函数的一般语法形式为: friend 函数类型 operator 运算符(形参表) { 函数体; } 其中,函数类型就是运算结果类型;operator是定义运算符重载函数的关键字;运算符是重载的运算符名称。 当运算符重载为类的成员函数时,函数的参数个数比原来的操作个数要少一个;当重载为类

C++重载运算符的几类使用方法

1.非运算符重载实现复数的加法运算//非运算符重载实现复数的加法运算 //complex.h #include #ifndef COMPLEX_H #define COMPLEX_H class complex { public: complex(); doublegetreal(); doublegetimag(); voidsetreal(double); voidsetimag(double); void display(); private: double real; double image; }; #endif //complex.cpp #include #include"complex.h" complex::complex() { real = 0; image = 0; } void complex::setreal(double r) { real = r; } void complex::setimag(double i) { image = i; } double complex::getreal() { return real; }

double complex::getimag() { return image; } void complex::display() { cout<<"the result is\n"< #include"complex.h" complex add(complex comp1,complex comp2); complex sub(complex comp1,complex comp2); void main() { complex c1,c2,c3,c4; c1.setreal(2.0); c1.setimag(3.0); c2.setreal(1.0); c2.setimag(4.0); c3 = add(c1,c2); cout<<"c3 = c1 + c2 , "; c3.display(); c4 = sub(c1,c2); cout<<"c4 = c1 - c2 ,"; c4.display(); } complex add(complex comp1,complex comp2) { complex temp; temp.setreal(comp1.getreal() + comp2.getreal()); temp.setimag(comp1.getimag() + comp2.getimag()); return temp; } complex sub(complex comp1,complex comp2) { complex temp; temp.setreal(comp1.getreal() - comp2.getreal()); temp.setimag(comp1.getimag() - comp2.getimag()); return temp; } 2.运算符重载作为类的成员函数 //运算符重载作为类的成员函数

运算符重载练习1

第10章运算符重载 一、选择题 1.在下列运算符中,不能重载的是( )。 (a) ! (b) sizeof (c) new (d) delete 2. 在下列运算符中,不能重载的是( )。 (a) <= (b) >> (c) && (d) &= 3.下列关于运算符重载的描述中,( )是正确的。 (a) 可以改变参与运算的操作数个数 (b) 可以改变运算符原来的优先级 (c) 可以改变运算符原来的结合性(d) 不能改变原运算符的语义 4.下列函数中,能重载运算符的函数是( b,c )。 (a) 成员函数(b) 构造函数(c) 析构函数 (d) 友员函数 5.不能用友员函数重载的是( a )。 (a) = (b) == (c) += (d) != 6.下面描述中,错误的是( b )。 (a) 只有系统预先定义的运算符才可能被重载 (b) 使用类型转换函数不能把一个类转换为另一个类 (c) 使用类型转换函数可以把类转换为基本类型 (d) 类型转换函数只能定义为一个类的成员函数,不能定义为类的友员函数

二、阅读下列程序,写出执行结果 1.#include class T { public : T() { a = 0; b = 0; c = 0; } T( int i , int j , int k ) { a = i; b =j ; c = k; } void get( int &i , int &j , int &k ) { i = a; j = b; k = c; } T operator * ( T obj ); private: int a , b , c; }; T T::operator * ( T obj ) { T tempobj; tempobj.a = a * obj.a; tempobj.b = b * obj.b; tempobj.c = c * obj.c; return tempobj;

实验五 方法的重载和静态成员

实验五方法的重载和静态成员 【实验目的】 1.巩固掌握构造方法的作用和定义; 2.掌握方法重载的意义和实现方式; 3.掌握静态成员的使用方法。 【实验准备】 复习配套教材相关章节的内容; 【实验内容】 项目一: 1.定义一个游戏中Hero 英雄的类,在该类中定义英雄的名字,生命值和等级 3 个属性,定义一个无参构造方法完成对名字、生命值和等级的初始化,分 别赋初值为“无名英雄”、100和1。同时实现名字和英雄信息的输出。 public class Hero { String name; int healthPower = 100; int grade; public Hero() { https://www.360docs.net/doc/646787470.html, ="无名英雄"; this.healthPower = 100; this.grade=1; } void showInfo() { System.out.println("——英雄信息——"); System.out.println("名字:" + https://www.360docs.net/doc/646787470.html,); System.out.println("生命值:" + this.healthPower); System.out.println("类型:" + this.grade); } }

2.在上一步的基础上,为英雄再定义拥有一个参数的构造方法,第一个参数传 入英雄的名字,第二个参数传入一个英雄类型的值,如果为1,则为普通英雄,生命值为100;如果该值为2,则为高级英雄,生命值初始化为200;如果该值为3,则为超级英雄,生命值初始化为300。 Public Hero(String name, int grade) { https://www.360docs.net/doc/646787470.html, = name; if (grade == 3) { this.healthPower = 300; this.grade = 3; } else if (grade == 2) { this.healthPower = 200; this.grade = 2; } else { this.healthPower = 100; this.grade = 1; } } 3.为英雄添加一个基本战斗的方法,该方法拥有一个英雄类型的参数,当传入 另一个英雄时,能降低对方10点血。再增加一个绝招战斗的重载方法,加入一个绝招类型参数,通过输入不同绝招参数,降低对方不同的血量(这里简化为:1,多杀伤3点血,2,多杀伤6点血,3,多杀伤10点血)。 void fight(Hero opponent) { opponent.healthPower -= 10; } void fight(Hero opponent, int skill) { opponent.healthPower -= 10; if (skill == 3) { opponent.healthPower -= 10; } else if (skill == 2) { opponent.healthPower -= 6; } else if (skill == 1) { opponent.healthPower -= 3; } } 4.在主类的主方法中编写代码,测试。 public static void main(String[] args) { // TODO code application logic here

相关文档
最新文档