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

合集下载

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

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

运算符重载基础概念练习题1、下列运算符中,()运算符在C++中不能重载。

A=B()C::Ddelete2、下列运算符中,()运算符在C++中不能重载。

A:B[]CnewD&&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++编译器解释为()。

Aoperator>(obj1,obj2)B>(obj1,obj2)Cobj2.operator>(obj1)Dobj1.oprator>(obj2)8、在表达式某+y某z中,+是作为成员函数重载的运算符,某是作为非成员函数重载的运算符。

下列叙述中正确的是()。

Aoperator+有两个参数,operator某有两个参数Boperator+有两个参数,operator某有一个参数Coperator+有一个参数,operator某有两个参数Doperator+有一个参数,operator某有一个参数9、重载赋值操作符时,应声明为()函数。

A友元B虚C成员D多态10、在一个类中可以对一个操作符进行()重载。

A1种B2种以下C3种以下D多种11、在重载一个运算符时,其参数表中没有任何参数,这表明该运算符是()。

A.作为友元函数重载的1元运算符B.作为成员函数重载的1元运算符C.作为友元函数重载的2元运算符D.作为成员函数重载的2元运算符12、在成员函数中进行双目运算符重载时,其参数表中应带有()个参数。

c 运算符的重载习题答案

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. sizeofC. newD. delete3.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++课后习题及其答案

C++课后习题及其答案

练习题11.1 判断题×1.C++语言和C语言都是面向对象的程序设计语言。

√2.面向对象方法具有封装性、继承性和多态性。

√3.C语言是C++语言的一个子集。

C++语言继承了C语言。

×4.C++语言程序与C语言程序一样都是函数串。

×5.C++语言支持封装性和继承性,不支持多态性。

√6.C++语言比C语言对数据类型要求更加严格了。

√7.C++语言对C语言进行了一次改进,使得编程更加方便了。

×8.C++源程序在编译时可能出现错误信息,而在连接时不会出现错误信息。

√9.编译C++源程序时,出现了警告错(Warning)也可以生成可执行文件。

√10.C++语言程序的实现也要经过编辑、编译连接和运行3个步骤。

1.2 单选题1.下列关于面向对象概念的描述中,错误的是(C )。

A.面向对象方法比面向过程方法更加先进B.面向对象方法中使用了一些面向过程方法中没有的概念C.面向对象方法替代了结构化程序设计方法D.面向对象程序设计方法要使用面向对象的程序设计语言2.下列各种高级语言中,不是面向对象的程序设计语言是(D )。

A.C++ B.JavaC.VB D.C3.下列关于类的描述中,错误的是( A )。

A.类就是C语言中的结构类型B.类是创建对象的模板C.类是抽象数据类型的实现D.类是具有共同行为的若干对象的统一描述体4.下列关于对象的描述中,错误的是(C )。

A.对象是类的一个实例B.对象是属性和行为的封装体C.对象就是C语言中的结构变量D.对象是现实世界中客观存在的某种实体5.下列关于C++程序中使用提取符和插入符的输入/输出语句的描述中,错误的是(C )。

A.提取符是对右移运算符(>>)重载得到的B.插入符是对左移运算符(<<)重载得到的C.提取符和插入符都是双目运算符,它们要求有两个操作数D.提取符和插入符在输入/输出语句中不可以连用1.3 填空题1.C++语言具有面向对象方法中要求的三大特性:封装性、继承性和多态性。

运算符重载知识题

运算符重载知识题

.《面向对象程序设计》习题班级:学号:姓名:名单序号:成绩:第7章运算符重载和多态性一、选择题(共30分,每题1分)1.下列运算符中,()运算符在C++中不能重载。

A.?:B.[]C. newD.++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. 下列运算符中哪些是不能够被重载的()。

何冰-面向对象程序设计-复习题(带部分复习资料)

何冰-面向对象程序设计-复习题(带部分复习资料)

、单项选择题1引入内联函数的主要目的是A)缩短程序代码,少占用内存空间B.既可以保证程序的可读性,又能提高程序的运行效率C)提高程序的执行速度D)使程序的结构比较清晰2重载函数是A)以函数参数来区分,而不用函数的返回值来区分不同的函数B.以函数的返回值来区分,而不用函数参数来区分不同的函数C)参数表完全相同而返回值类型不同的两个或多个同名函数D)参数表和返回值类型都必须是不同的两个或多个同名函数3有函数原型void fun2 (int *), 下面选项中,正确的调用是A)double x = 2.17; fun2 (&x); C) int a = 15; fun2 (a*3.14);B) int b = 100; fun2 (& b); D) fun2 (256);4在C++中,要实现动态联编,必须使用()调用虚函数。

A)类名B)派生类指针C)对象名D)基类指针5在公有派生情况下,有关派生类对象和基类对象的关系,下列叙述不正确的是A)派生类的对象可以直接访问基类中的所有成员B)派生类的对象可以初始化基类的引用C)派生类的对象可以赋给基类的对象D)派生类的对象的地址可以赋给指向基类的指针6设置虚基类的目的是A)消除两义性B)简化程序C)提高运行效率D)减少目标代码7关于构造函数,以下说法错误的是A)构造函数的作用是在对象被创建时使用特定的值构造对象,或者说将对象初始化为一个特定的状态。

在对象创建时由系统自动调用。

B)基类的构造函数可以被派生类所继承。

C)如果程序中未声明,则系统自动产生出一个缺省形式的构造函数。

D)允许为内联函数、重载函数、带缺省形参值的函数。

8下列关于C++函数的说明中,正确的是A)内联函数就是定义在另一个函数体内部的函数B)函数体的最后一条语句必须是return语句C)标准C++要求在调用一个函数之前,必须先声明其原型D)编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式9由于常对象不能被更新,因此A) 通过常对象只能调用它的常成员函数B) 通过常对象只能调用静态成员函数C) 常对象的成员都是常成员D) 通过常对象可以调用任何不改变对象值的成员函数10下列关于虚函数的说明中,正确的是A)从虚基类继承的函数都是虚函数B)虚函数不得是静态成员函数C)只能通过指针或引用调用虚函数D)抽象类中的成员函数都是虚函数11运算符重载是对已有的运算符赋予多重含义,因此A) 可以对基本类型(如int类型)的数据,重新定义“ + 运算符的含义B) 可以改变一个已有运算符的优先级和操作数个数C) 只能重载C++中已经有的运算符,不能定义新运算符D) C++中已经有的所有运算符都可以重载12模板对类型的参数化提供了很好的支持,因此A) 类模板的主要作用是生成抽象类B) 类模板实例化时,编译器将根据给出的模板实参生成一个类C) 在类模板中的数据成员都具有同样类型D) 类模板中的成员函数都没有返回值13下列符号中可以用作C++标识符的是A)_radius B)foo~bar C)else D)3room 14下列语句中,错误的是A)c onst int buffer=256; B)c onst int temp;C)const double *po int; D)const double *rt =new double(5.5);15有如下程序:int x=3;do{x -= 2;cout«x;}while(!(--x));执行这个程序的输出结果是A) 1 B) 3 0C) l-2 D)死循环16有如下程序:#in clude <iostream>using n amespace std;int mai n(){int *p;*p = 9;cout<<"The value at p:"«*p; return 0;}编译运行程序将出现的情况是A) 够编译时出现语法错误,不能生成可执行文件B) 运行时一定输出:The value at p: 9C) 运行时一定输出:The value at p: *9D) 运行时有可能出错17有如下程序:#i nclude <iostream>using n amespace std;int mai n(){void fun cti on( double val);double val;function( val);cout«val;return 0;}void fun cti on( double val){val = 3;}编译运行这个程序将出现的情况是A)编译出错,无法运行B)输出:3C)输出:3.0 D)输出一个不确定的数18有如下类定义:class AA{int a;public:int getRef() const{return &a;} // ①int getValue() con st{return a;} // ②void set(i nt n) con st{a=n;} // ③frie nd void show(AA aa) const {cout<<aa; } // ④ }; 其中的四个函数定义中正确的是A)①B)②C)③D)④19有如下程序:#in clude <iostream>using n amespace stdclass Base{public:void fun() {cout<v"Base::fu n"v<e ndl;};class Derived:public Base{public:void fun(){cout<<"Derived::f un"«en dl;}};int mai n(){Derived d;d.fu n();return 0;}已知其执行后的输出结果为:Base::fu nDerived::fu n则程序中下划线处应填入的语句是A) Base.fu n(); B)Base::fu n() C)Base->fu n() D)fu n(); 20下面是重载为非成员函数的运算符函数原型,其中错误的是A) Fracti on operator + (Fracti on, Fract ion);B) Fractio n operator - (Fracti on);C) Fract ion& operator = (Fracti on&, Fract ion);D) Fract ion& operator += (Fract ion&, Fract ion);21有如下类定义:class Foo{public:Foo(int v):value(v){} // ①~Foo(){} // ②private:Foo(){} // ③in t value = 0; 〃④};其中存在语法错误的行是A)①B)②C)③D)④22有如下类定义:class Point{int x_, y_;public:Poi nt():x_(0), y_(0){}Poi nt(i nt x, i nt y = 0):x_(x),y_(y){}};若执行语句Point a(2), b[3], *c[4];则Point类的构造函数被调用的次数是A)2次B)3次C)4次D)5次23有如下程序:#i nclude <iostream>using n amespace std;class A{public:A(){cout«"A";}~A(){cout«"~A";}};class B:public A{A* p;public:B(){cout<<"B"; p = new A();} ~B(){cout<<"~B"; delete p;} };int mai n(){B obj; return 0;}执行这个程序的输出结果是A)BAA~A~B~A B)ABA~B~A~AC)BAA~B~A~A D)ABA~A~B~A24有如下程序:#i nclude <iostream>using n amespace std;class Base{private:void fun 1() con st{cout«"fu nl";}protected:void fun 2() con st{cout<<"fu n2";} public:void fun 3() con st{cout<<"fu n3";}};class Derived:protected Base{public:void fun4() con st{cout<<"fu n4";}};int mai n(){Derived obj;obj.fu nl (); // ①obj.fu n2(); // ②obj.fu n3(); // ③obj.fu n4(); // ④return 0;}其中有语法错误的语句是A)①②③④B)①②③C)②③④D)①④ 25有如下程序:#i nclude <iostream>using n amespace std;class Base{public:void fun l(){cout«"Base "<<e ndl;}virtual void fun 2(){cout<<"Base"<<e ndl; } };class Derived:public Base{public:void fun l(){cout<v"Derived"v<e ndl;}void fun 2(){cout<<"Derived"<<e ndl;}};void f(Base & b){b.fu nl();b.fu n2();}int mai n(){Derived obj;f(obj);return 0;}执行这个程序的输出结果是A)Base B)BaseC)Derived D)DerivedBasQerived Base Derived26有如下类声明:class SAMPLE{int n;public:SAMPLE (int i = 0): n (i){}void setValue(i nt nO);};下列关于setValue成员函数的实现中,正确的是A) SAMPLE::setValue(i nt n 0){n = n0;}B) void SAMPLE::setValue(i nt n 0){n = n0;}C) void setValue(i nt n 0){n = n0;}D) setValue(i nt n 0){n = n0;}27 •下列函数模板的定义中,合法的是( )。

c++多态性复习要点

c++多态性复习要点

多态性和操作符重载知识要点1.多态性:多态是指同样的消息被不同类型的对象接收后导致完全不同的行为。

2.面向对象的多态性可以分为4类:重载多态、强制多态、包含多态和参数多态。

3.多态从实现的角度来讲可以划分为两类:编译时的多态和运行时的多态。

4.运算符重载是对已有的运算符赋予多重含义,使同一个运算符作用于不同类型的数据导致不同类型的行为。

5.运算符重载的规则如下:1)C++语言中的运算符除了少数几个之外,全部可以重载,而且只能重载C++语言中已有的运算符。

2)重载之后运算符的优先级和结合性都不会改变。

3)运算符重载是针对新类型数据的实际需要,对原有运算符进行适当的改造。

一般来讲,重载的功能应当与原有功能相类似,不能改变原运算符的操作对象个数,同时至少要有一个操作对象是自定义类型。

不能重载的运算符只有5个,它们是类属关系运算符“.”、成员指针运算符“*”、作用域分辨符“::”、sizeof运算符和三目运算符“?:”。

前面两个运算符保证了C++语言中访问成员功能的含义不被改变。

作用域分辨符和sizeof 运算符的操作数是类型,而不是普通的表达式,也不具备重载的特征。

6.运算符的重载形式有两种,重载为类的成员函数和重载为类的友元函数。

运算符重载为类的成员函数的一般语法形式为:函数类型operater 运算符(形参表){ 函数体;}运算符重载为类的友元函数的一般语法形式为:friend 函数类型operater 运算符(形参表){ 函数体;}7.虚函数说明虚函数的一般格式如下:virtual <函数返回类型说明符> <函数名>(<参数表>)在定义虚函数时要注意:(1) 虚函数是非静态的、非内联的成员函数,而不能是友元函数,但虚函数可以在另一个类中被声明为友元函数。

(2) 虚函数声明只能出现在类定义的函数原型声明中,而不能在成员函数的函数体实现的时候声明。

(3) 一个虚函数无论被公有继承多少次,它仍然保持其虚函数的特性。

C++ANDUML习题及答案(给学生)

C++ANDUML习题及答案(给学生)

C++ANDUML习题及答案(给学生)复习要求:1.C++语言概述(1)了解C++语言的基本符号。

(2)了解C++语言的词汇(保留字、标识符、常量、运算符、标点符号等)。

(3)掌握C++程序的基本框架(结构程序设计框架、面向对象程序设计框架等)。

(4)能够使用Visual C++ 6.0集成开发环境编辑、编译、运行与调试程序。

2.数据类型、表达式和基本运算(1)掌握C++数据类型(基本类型、指针类型)及其定义方法。

(2)了解C++的常量定义(整型常量、字符常量、逻辑常量、实型常量、地址常量、符号常量)。

(3)掌握变量的定义与使用方法(变量的定义及初始化、全局变量、局部变量)。

(4)掌握C++运算符的种类、运算优先级和结合性。

(5)熟练掌握C++表达式类型及求值规则(赋值运算、算术运算符和算术表达式、关系运算符和关系表达式、逻辑运算符和逻辑表达式、条件运算、指针运算、逗号表达式)。

3.C++的基本语句(1)掌握C++的基本语句,例如赋值语句、表达式语句、复合语句、输入、输出语句和空语句等。

(2)用if语句实现分支结构。

(3)用switch语句实现多分支选择结构。

(4)用for语句实现循环结构。

(5)用while语句实现循环结构。

(6)用do…while语句实现循环结构。

(7)转向语句(goto,continue,break和return)。

(8)掌握分支语句和循环语句的各种嵌套使用。

4.数组、指针与引用(1)掌握一维数组的定义、初始化和访问,了解多维数组的定义、初始化和访问。

(2)了解字符串与字符数组。

(3)熟练掌握常用字符串函数(strlen,strcpy,strcat,strcmp,strstr等)。

(4)掌握指针与指针变量的概念、指针与地址运算符、指针与数组。

(5)掌握引用的基本概念、引用的定义与使用。

5.掌握函数的有关使用(1)函数的定义方法和调用方法。

(2)函数的类型和返回值。

(3)形式参数与实在参数,参数值的传递。

C++陈维兴课后习题答案

C++陈维兴课后习题答案

的那些方面,以便更充分地注意与当前目标有关的方面。抽象是对复杂世界的简
单表示,抽象强调感兴趣的信息,忽略了不重要的信息。例如,设计一个学籍管
理程序的过程中,考察某个学生对象时,只关心他的姓名、学好、成绩等,而对
他的身高、体重等信息就可以忽略。以一般观点而言,抽象是通过特定的实例(对
[1_9]什么是单继承、多继承?请举例说明。
从继承源上分,继承分为单继承和多继承。单继承是指每个派生类只直接继
承了一个基类的特征。多继承是指多个基类派生出一个派生类的继承关系。多继
承的派生类直接继承了不止一个基类的特征。例如:小孩的玩具车继承了车的一
些特性,还继承了玩具的一些特征。
在面向对象程序设计中,要求某一对象作某一操作时,就向该对象发送一个响应
的消息,当对象接收到发向它的消息时,就调用有关的方法,执行响应的操作。
方法就是对象所能执行的操作。方法包括界面和方法体两部分。方法的界面也就
是消息的模式,它给出了方法的调用协议;方法体则是实现某种操作的一系列计
(3)类间具有层次结构
假设有两个类A 和B,若类B 继承类A,则类B 包含了类A 的特征(包括
数据和操作),同时也可以加入自己所特有的新特性。这时,我们称被继承类A
为基类或父类或超类;而称继承类B 为A 类的派生类或子类。同时,我们还可
以说,类B 是从类A 中派生出来的。
char *name; int number; float score;
----------------------- Page 4-----------------------
共同的行为:数据录入、数据修改和数据输出等,这构成了学生的行为抽象部分,

多态和虚函数、运算符重载

多态和虚函数、运算符重载

(3)单击标准工作栏的Save按钮,将文件保存到指定地点,并命名。

(4)编译运行。

3、输入并运行程序Ex_Complex的具体步骤如下。

(1) 选择“文件” “关闭工作区间”,关闭原来的项目。

(2) 单击标准工具栏上的“New Text File”按钮,在新打开的文档窗口中输入下列程序代码:#include<iostream.h>class CComplex{public:CComplex(double r=0,double i=0){realPart=r;imagePart=i;}void print(){cout<<"该复数实部="<<realPart<<",虚部="<<imagePart<<endl;}CComplex operator*(CComplex &b);//成员函数重载运算符*friend CComplex operator/(CComplex &a,CComplex &b);友元函数重载运算符private:五、分析与体会:1、象程序设计多态性是面向对象程序设计的重要特征之一,他与封装性和继承性构成了面向对的三大特征。

所谓多态性,是指不同类型的对象接受相同的消息是产生不同的行为。

这里的消息主要是指对类的成员函数的调用,而不同的行为是指成员函数的不同实现。

如:函数重载就是多态的典型例子。

2、此程序中定义了一个抽象类CShape,包含纯虚函数Area和SetData,Area用于计算各个形状的面积,SetData用于重设各个形状的大小。

程序代码中虚函数Area和SetData是通过在基类函数的前面加上virtual关键字来实现的。

程序中ppShape是定义的基类CShape的指针,通过语句ppShape[0]=newTriangle(triWidth,triHeight);ppShape[1]=new(rcWidth,rcHeight); ppShape[2]=new CCircle(r);是将ppShape[0]、ppShape[1]和ppShape[2]分别获得对派生类CTriangle、CRect和CCircle的成员函数的调用,因而语句ppShape[n]->SetData(f1,f2);根据n值的不同调用不同的形状类的area函数,例。

第十章运算符重载复习题

第十章运算符重载复习题

第十章运算符重载复习题运算符重载复习题1. 重载赋值操作符时,应声明为( )A. 友元函数B. 虚函数C. 成员函数D. 多态函数2.关于重载的描述,正确的是( )A.函数重载只能在成员函数之间进行B.函数重载只能在全局函数之间进行C.函数重载可以在基类和派生类之间进行D.函数重载必须要求同名的函数的形参类型和个数都完全一致,返回值类型无所谓3.下列运算符中不能重载的是( )。

A.∷(域运算符) B.+ (正) C.++ (自增) D.*(指针)4. 派生类的对象对它的基类成员中()A. 公有继承的公有成员是可以访问的B. 公有继承的私有成员是可以访问的C. 公有继承的保护成员是可以访问的D. 私有继承的公有成员是可以访问的5 不能重载的运算符是()A. ?:B. [ ]C. newD. &&6. C++中不能重载的运算符是( )A. newB. +=C. sizeofD. &&7.重载函数是( )A.以函数参数来区分,而不用函数的返回值来区分不同的函数B.以函数的返回值来区分,而不用函数参数来区分不同的函数C.参数表完全相同而返回值类型不同的两个或多个同名函数D.参数表和返回值类型中至少有一个不同的两个或多个同名函数8.对于运算符重载,说法正确的是( )A.运算符如果被重载为非成员函数,那么对象就不能利用这个运算符重载函数进行操作B.运算符重载函数可能既不是成员函数,也不是友元函数C.用户每定义一个类,系统会自动提供一个赋值运算符重载函数,所以完全不必考虑重载赋值运算符函数D.一个类的虚函数不能调用运算符重载函数9. C++中不能重载的运算符是( )A. =B. ()C. ::D. delete10. 不能作为函数重载判断依据的是( )A. constB. 返回类型C. 参数个数D. 参数类型11. 为满足运算符“+”的可交换性,必须将其重载为成员函数,重载的函数名是关键字加上运算符“+”。

多态性例题

多态性例题

多态性1 知识要点1.多态性:多态是指同样的消息被不同类型的对象接收后导致完全不同的行为。

2.面向对象的多态性可以分为4类:重载多态、强制多态、包含多态和参数多态。

3.多态从实现的角度来讲可以划分为两类:编译时的多态和运行时的多态。

4.运算符重载是对已有的运算符赋予多重含义,使同一个运算符作用于不同类型的数据导致不同类型的行为。

5.运算符重载的规则如下:1)C++语言中的运算符除了少数几个之外,全部可以重载,而且只能重载C++语言中已有的运算符。

2)重载之后运算符的优先级和结合性都不会改变。

3)运算符重载是针对新类型数据的实际需要,对原有运算符进行适当的改造。

一般来讲,重载的功能应当与原有功能相类似,不能改变原运算符的操作对象个数,同时至少要有一个操作对象是自定义类型。

不能重载的运算符只有5个,它们是类属关系运算符“.”、成员指针运算符“*”、作用域分辨符“::”、sizeof运算符和三目运算符“?:”。

前面两个运算符保证了C++语言中访问成员功能的含义不被改变。

作用域分辨符和sizeof运算符的操作数是类型,而不是普通的表达式,也不具备重载的特征。

6.运算符的重载形式有两种,重载为类的成员函数和重载为类的友元函数。

运算符重载为类的成员函数的一般语法形式为:函数类型 operater 运算符(形参表){ 函数体;}运算符重载为类的友元函数的一般语法形式为:friend 函数类型 operater 运算符(形参表){ 函数体;}7.虚函数说明虚函数的一般格式如下:virtual <函数返回类型说明符> <函数名>(<参数表>)在定义虚函数时要注意:(1) 虚函数是非静态的、非内联的成员函数,而不能是友元函数,但虚函数可以在另一个类中被声明为友元函数。

(2) 虚函数声明只能出现在类定义的函数原型声明中,而不能在成员函数的函数体实现的时候声明。

(3) 一个虚函数无论被公有继承多少次,它仍然保持其虚函数的特性。

实验07_多态性_函数与运算符重载

实验07_多态性_函数与运算符重载

实验07.多态性-函数与运算符重载7.1实验目的1、理解动态联编和动态联编的概念;2、理解掌握成员函数方式运算符重载;3、理解掌握友元函数方式运算符重载;4、理解掌握++、--、=运算符的重载;7.2实验内容7.2.1程序阅读与调试1.理解下面的程序,并在Code::Blocks下运行查看结果,回答程序后面的问题。

问题1:①处的运算符重载,为什么该函数的返回值要设计成CComplex类型问题2:②处的运算符重载函数调用就相当于“obj=operator+(obj1,obj2);”,但是为什么CComplex类中的运算符重载函数只设计了一个参数。

问题3:本程序的执行结果是什么。

——请将上述问题的解答填写在实验报告对应题号下面。

2.理解下面的程序,并在Code::Blocks下运行查看结果,回答程序后面的问题。

问题1:以上程序中的三个运算符重载都有错误,试改正过来,并分析该程序的输出结果?——请将上述问题的解答填写在实验报告对应题号下面7.2.2程序设计1.对7.2.1中的第2个程序,如果要实现后缀的--,即在主函数中添加以下语句:CComplex obj5 = obj3--;cout << "postfix after , obj5=obj3--; obj5 = "; obj5.print();cout << "postfix after , obj5=obj3--; obj3 = "; obj3.print();后输出:postfix after , obj5=obj3--; obj5 = 6.7 + 6.7ipostfix after , obj5=obj3--; obj3 = 5.7 + 5.7i应该如何扩展程序。

该程序命名为exp07_p1_1.cpp。

7.3思考题1、定义CPoint类,有两个成员变量:横坐标(x)和纵坐标(y),对CPoint 类重载“++”(自增运算符)、“--”(自减运算符),实现对坐标值的改变。

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

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

习题10 运算符重载与多态性一、单项选择题1、下列运算符中,()运算符在C++中不能重载。

A、? :B、[ ]C、newD、&&2、下列运算符不能用友元函数重载的是()。

A、+B、=C、*D、<<3、在一个类中可以对一个操作符进行()重载。

A、1种B、2种以下C、3种以下D、多种4、友元运算符obj1>obj2被C++编译器解释为()。

A、operator > (obj1, obj2)B、> (obj1, obj2)C、obj2.operator > (obj1)D、obj1.operator > (obj2)5、下列关于C++运算符函数的返回类型的描述中,错误的是()。

A、可以是类类型B、可以是int类型C、可以是void类型D、可以是float类型6、下列关于运算符重载的描述中,正确的是()。

A、运算符重载可以改变运算符的操作数的个数B、运算符重载可以改变优先级C、运算符重载可以改变结合性D、运算符重载不可以改变语法结构7、下列关于动态联编的描述中,错误的是()。

A、动态联编是以虚函数为基础的B、动态联编是在运行时确定所调用的函数代码的C、动态联编调用函数操作是指向对象的指针或对象引用D、动态联编是在编译时确定操作函数的8、关于虚函数的描述中,正确的是()。

A、虚函数是一个静态成员函数B、虚函数是一个非成员函数C、虚函数既可以在函数说明时定义,也可以在函数实现时定义D、派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型9、对虚函数的调用()。

A、一定使用动态联编B、必须使用动态联编C、一定使用静态联编D、不一定使用动态联编10、编译时的多态性可以通过使用()获得。

A、虚函数和指针B、重载函数和析构函数C、虚函数和对象D、虚函数和引用11、实现运行时的多态性要使用()。

A、重载函数B、构造函数C、析构函数D、虚函数12、要实现动态联编,必须通过()调用虚函数。

实验7多态性和运算符重载

实验7多态性和运算符重载

实验7多态性和运算符重载实验7 运算符重载一、实验目的1.了解多态性;2.掌握算术运算符和关系运算符的重载;3.掌握运算符重载的方法;4.掌握作为成员函数的运算符重载和作为友元函数的运算符重载的不同特点。

二、相关知识1.概念理解多态是指类族中具有相似功能的不同函数使用同一名称来实现,从而可以使用相同的调用方式来调用这些具有不同功能的同名函数。

C++中的多态的实现形式:函数重载、运算符重载、虚函数等。

函数重载是指同一个函数可以操作于不同类型的对象:运算符重载是对已有的运算符赋予多重含义,使用已有运算符对用户自定义类型(比如类)进行运算操作,运算符重载实际上是函数重载;虚函数是实现类族中定义于不同类中的同名成员函数的多态行为。

多态从实现的角度可以分为两类:编译时的多态和运行时的多态,前者是在编译过程中确定了同名操作的具体操作对象,而后者则是在程序运行过程中才动态地确定所针对的具体对象。

这种确定操作的具体对象的过程就是联编。

编译时的多态通过静态联编解决,如函数重载或运算符重载,它们在编译、链接过程中,系统就可以根据类型匹配等特征确定程序中操作调用与执行代码的关系,即确定了某一个同名标识到底要调用哪一段程序代码。

运行时的多态通过动态联编实现,虚函数是实现动态联编的基础,若定义了虚函数就可以通过基类指针或引用实现,执行时会根据指针指向的对象所属的类,决定调用哪个函数。

虚函数具有继承性,其本质不是重载声明而是覆盖。

纯虚函数是在基类中说明的虚函数,它在该基类中可以不给出函数体,要求各派生类根据实际需要编写自己的函数体。

带有纯虚函数的类是抽象类,抽象类的主要作用是通过它为一个类族建立一个公共的接口,使它们能够更有效地发挥多态特性。

2.运算符重载运算符重载是指同样的运算符可以施加于不同类型的操作数上面,使同样的运算符作用于不同类型的数据导致不同类型的行为。

运算符重载的实质就是函数重载。

在实现过程中,首先把指定的运算符表达式转化为对运算符函数的调用,运算对象转化为函数的形参,然后根据实参的类型来确定需要调用的函数,这个过程是在编译过程中完成的。

c运算符的重载习题答案

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. sizeofC. newD. delete3.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++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(⼆)运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式:(1)把运算符重载的函数作为类的成员函数;(2)运算符重载的函数不是类的成员函数,在类中把它声明为友元函数。

1 把运算符重载函数作为类的成员函数例1:为了便于说明问题,将重载函数的定义重写如下:1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问:“+”是双⽬运算符,为什么重载函数只有⼀个参数呢?实际上,运算符重载函数应当有两个参数,但是,由于重载函数是Complex类中的成员函数,因此有⼀个参数是隐含的,运算符函数是⽤this指针隐式的访问类对象的成员。

可以看到operator+访问了两个对象中的成员,⼀个是this指针指向的对象中的成员,⼀个是形参对象中的成员。

2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外,还可以是⾮成员函数。

在有关的类中把它声明为友元函数,即友元运算符重载函数。

例2:将运算符+重载为适⽤于复数加法,重载函数不作为成员函数,⽽放在类外,作为Complex类的友元函数。

1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐,只做了⼀处改动,就是将运算符重载函数作为类外的普通函数,并在Complex类中声明它为友元函数。

c++多态性相关习题

c++多态性相关习题

多态性10.2 典型例题分析与解答例题1:指出下列对定义重载函数的要求中,哪些是错误的提法。

A.要求参数的个数不同。

B.要求参数中至少有一个类型不同。

C.求函数的返回值不同。

D. 要求参数的个数相同时,参数类型不同。

答案:C例题3:下面关于友元的描述中,错误的是()。

A. 友元函数可以访问该类的私有数据成员B. 一个类的友元类中的成员函数都是这个类的友元函数C. 友元可以提高程序的运行效率D. 类与类之间的友元关系可以继承答案:D例题4:下述静态成员的特性中,()是错误的。

A. 静态成员函数不能利用this指针B. 静态数据成员要在类体外进行初始化C. 引用静态数据成员时,要在静态数据成员名前加<类名>和作用域运算符页脚内容1D. 静态数据成员不是所有对象所共有的答案:D例题5:关于虚函数的描述中,()是正确的。

A. 虚函数是一个静态成员函数B. 虚函数是一个非成员函数C. 虚函数既可以在函数说明时定义,也可以在函数实现时定义D. 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型参考答案:D例题11:分析下列程序的输出结果。

#include <iostream.h>class A{public:A() { cout<<"A's cons."<<endl; }virtual ~A() { cout<<"A's des."<<endl; }virtual void f() { cout<<"A's f()."<<endl; }页脚内容2void g() { f(); }};class B : public A{public:B() { f(); cout<<"B's cons."<<endl; }~B() { cout<<"B's des."<<endl; }};class C : public B{public:C() { cout<<"C's cons."<<endl; }~C() { cout<<"C's des."<<endl; }void f() { cout<<"C's f()."<<endl; }};void main(){ A *a=new C;a->g();delete a;页脚内容3}运行结果:A's cons.A's f().B's cons.C's cons.C's f().C's des.B's des.A's des.10.3 教材习题解答1.选择题(1)下列关于动态联编的描述中,错误的是()。

python中有关多态的试题

python中有关多态的试题

python中有关多态的试题含解答共20道1. 什么是多态性?-解答:多态性是指同一种操作作用于不同的对象上时,可以产生不同的行为。

2. Python中多态性的实现方式是什么?-解答:在Python中,多态性通过对象的特殊方法(例如`__len__`、`__add__`等)和动态类型特性实现。

3. 举例说明Python中的鸭子类型。

-解答:在Python中,不关心对象的具体类型,只关心对象是否具有特定的方法或属性。

例如,`len()`函数可以用于任何实现了`__len__`方法的对象。

4. 什么是函数的多态性?-解答:函数的多态性指同一函数名可以接受不同类型或数量的参数,并根据实际参数的类型或数量执行不同的操作。

5. 什么是运算符的多态性?-解答:运算符的多态性指同一运算符可以用于不同类型的操作数,并根据操作数的类型执行不同的操作。

6. 如何在Python中实现多态性?-解答:通过使用继承和重写方法,或者通过使用鸭子类型,可以实现多态性。

7. 什么是方法重写?它与多态性有什么关系?-解答:方法重写是子类覆盖父类中相同名称的方法。

多态性的一种表现就是通过方法重写实现,不同的子类可以提供不同的实现。

8. Python中的抽象基类是什么?它与多态性有什么关系?-解答:抽象基类是指包含抽象方法的类,它定义了一组子类必须实现的方法。

通过使用抽象基类,可以确保子类实现了必要的方法,从而实现多态性。

9. 什么是函数重载?Python支持函数重载吗?-解答:函数重载是指可以定义多个同名函数,但它们的参数类型或数量不同。

Python 不直接支持函数重载,因为它是一门动态类型语言,但可以通过默认参数值和可变参数来模拟一些重载的效果。

10. 如何使用`isinstance()`函数实现多态性?-解答:`isinstance()`函数用于检查对象是否属于指定的类型,通过使用该函数,可以在运行时根据对象的类型采取不同的操作,从而实现多态性。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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 、虚函数和引用13、在派生类中重新定义虚函数时,除了(的虚函数保持一致。

14、下面关于构造函数和析构函数的描述,错误的是( A 、析构函数中调用虚函数需用静态联编 B 、对虚析构函数的调用可以采用动态联编C 、当基类的析构函数是虚函数时,其派生类的析构函数也一定是虚函数D 、构造函数可以声明为虚函数18、如果一个类至少有一个纯虚函数,那么就称该类为(A 、抽象类B 、虚基类11、实现运行时的多态性要使用( )。

A 、重载函数B 、构造函数C 、析构函数D 、虚函数12、要实现动态联编,必须通过( )调用虚函数。

A 、对象指针B 、成员名限定C 、对象名D 、派生类名A 、参数个数B 、参数类型C 、函数名称D 、函数体19、以下( )成员函数表示纯虚函数。

A 、 virtual int vf(int);B 、 voidvf(int)=0; C 、 virtual void vf ()=0; 20、下面的描述中.正确的是( D 、 virtual voidvf(int) { }A 、 virtual 可以用来声明虚函数)。

B 、含有纯虚函数的类是不可以用来创建对象的,因为它是虚基类C 、即使基类的构造函数没有参数派生类也必须建立构造函数D 、静态数据成员可以通过成员初始化列表来初始化二、分析下列各程序的运行结果1、源程序如下: #include<iostream>)方面,其他方面都必须与基类中相应)。

15、关于纯虚函数和抽象类的描述中,错误的是( )。

A 、纯虚函数是一种特殊的虚函数,它没有具体的实现B 、抽象类是指具有纯虚函数的类C 、一个基类中说明有纯虚函数,该基类的派生类一定不再是抽象类D 、抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出 16、下列描述中, ( )是抽象类的特性。

A 、可以说明虚函数B 、可以进行构造函数重载C 、可以定义友元函数D 、不能说明其对象17、()是一个在基类中说明的虚函数,它在该基类中没有定义但要求任何派生类都必须定义自己的版本。

A 、虚析构函数B 、虚构造函数C 、纯虚函数D 、静态成员函数)。

C 、派生类D 、以上都不对using namespace std;class Coord{public:Coord(int i=0,int j=0){ x=i; y=j; }void Print() { cout<<"x="<<x<<",y="<<y<<endl; }friend Coord operator ++ (Coord op);private:int x,y;};Coord operator ++(Coord op){++op.x;++op.y;return op;}int main(){Coord obj(1,2);obj.Print();++obj;obj.Print();return 0;}2、源程序如下:#include<iostream> using namespace std; classVector{ public: Vector(){} Vector(int i,intj){x=i;y=j;} friend Vector operator +=(Vectorv1,Vector v2); Vector operator -=(Vector v); void display(){cout<<"("<<x<<","<<y<<")"<<endl; private: int x,y;};Vector operator +=(Vector v1,Vector v2){v1.x+=v2.x;v1.y+=v2.y;return v1;}Vector Vector::operator -=(Vector v){Vector temp; temp.x=x-v.x; temp.y=y-v.y; return temp;}int 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();return 0;}3、源程序如下:#include<iostream.h>#include<string.h>#include<stdlib.h>class Sales{public:void Init(char n[]){ strcpy(name,n); int& operator [](int sub);char *GetName(){ return name; } private:char name[25];int divisionTotals[5];};int& Sales::operator [](int sub){ if(sub<0||sub>4){cerr<<"Bad subscript!"<<sub<<" is not allowed."<<endl; abort();}return divisionTotals[sub];}int main(){int totalSales=0,avgSales;Sales company; company.Init("Swiss Cheese");company[0]=123;company[1]=456;company[2]=789;company[3]=234;company[4]=567;cout<<"Here are the sales for "<<company.GetName()<<"'s division:"<<endl;for(int i=0;i<5;i++)cout<<company[i]<<"\t";for(i=0;i<5;i++) totalSales+=company[i];cout<<endl<<"The total sales are "<<totalSales<<endl;avgSales=totalSales/5;cout<<"The average sales are "<<avgSales<<endl; return 0;}4、源程序如下:#include<iostream.h>class base{ public:virtual void fun1(){ cout<<"base fun1."<<endl; virtual voidfun2(){ cout<<"base fun2."<<endl; void fun3(){ cout<<"base fun3."<<endl;void fun4(){ cout<<"base fun4."<<endl;};class derived:public base{virtual void fun1(){ cout<<"derived fun1."<<endl;virtual void fun2(int x){ cout<<"derived fun2."<<endl; virtual voidfun3(){ cout<<"derived fun3."<<endl; void fun4(){ cout<<"derivedfun4."<<endl; }};int main(){base *pb;derived d;pb=&d;pb->fun1();pb->fun2();pb->fun3();pb->fun4();return 0;}5、源程序如下:#in clude<iostream.h>class B0{public:virtual void dis play()=0;};class B1: public B0{public:void dis play(){ cout<<"B1::dis play()"<<e ndl;};class D1: public B1{public:void dis play(){ cout<<"D1::dis play()"<<e ndl;};void fun (B0 *ptr){p tr->dis play();}int mai n(){B0 *p;B1 b1;D1 d1;p=&b1;fun(p);p=& d1;fun(p);return 0;}三、程序填空(请将最合适的语句填入各标号处,使其成为一个完整、正确的程序1、下列程序定义了一实部为real,虚部为imag的复数类Complex,并在类中重载了复数的+、-操作。

相关文档
最新文档