运算符重载练习题
- 格式:docx
- 大小:51.20 KB
- 文档页数:19
国家二级C++机试(运算符重载、C++流)模拟试卷3(题后含答案及解析)题型有:1. 选择题选择题1.通过运算符重载,可以改变运算符原有的( )。
A.操作数类型B.操作数个数C.优先级D.结合性正确答案:A解析:此题考查的是运算符重载。
运算符重载具有保持其原有的操作数个数、优先级、语法结构和结合性不变的特性。
故本题选项A正确。
知识模块:运算符重载2.下列有关运算符重载的叙述中,正确的是( )。
A.运算符重载是多态性的一种表现B.C++中可以通过运算符重载创造新的运算符C.C++中所有运算符都可以作为非成员函数重载D.重载运算符时可以改变基结合性正确答案:A解析:此题考查的是运算符重载。
C++中运算符重载是多态性的一种表现:运算符重载是针对C++原有运算符进行的,不可能通过重载创造出新的运算符;除了“.”、“.*”、“->*”、“::”、“?:”这五个运算符外,其它运算符都可以重载;但“=”“[]”“->”及所有的类型转换运算符只能作为成员函数重载,运算符重载不可改变其结合性、操作数个数和优先级。
知识模块:运算符重载3.下列关于运算符函数的描述中,错误的是( )。
A.运算符函数的名称总是以operator为前缀B.运算符函数的参数可以是对象C.运算符函数只能定义为类的成员函数D.在表达式中使用重载的运算符相当于调用运算符重载函数正确答案:C解析:C++把重载的运算符视为特殊的函数,称为运算符函数。
编译系统能够依据使用运算符的不同环境,即参数(操作数)的数量或类型的差异,区分同一运算符的不同含义。
运算符函数作为非成员函数时,所有的操作数必须出现在参数表中。
知识模块:运算符重载4.下列关于运算符重载的叙述中,正确的是( )。
A.通过运算符重载机制可以为C++语言扩充新的运算符B.运算符重载的作用是使已有的运算符作用于类的对象C.重载运算符的操作数类型可以全部为基本类型D.所有运算符都可以被重载正确答案:B解析:运算符重载就是赋予已有的运算符多重含义。
运算符重载一.单项选择题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);};答案:D7. 在第33题中,当执行语句d+=m; 时,C++编译器对语句作如下解释: (34)A. d=operator+=(m);B. m=operator+=(d);C. d.operator+=(m);D. m.operator+=(d);答案:C8. 设有以下类定义,其中说明了“+”运算符重载函数的原型。
.《面向对象程序设计》习题班级:学号:姓名:名单序号:成绩:第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. 下列运算符中哪些是不能够被重载的()。
Task8-1/*1. 定义一个复数类 Complex ,重载运算符“ + ”,使之能用于复数的加法运算将运算符函数重载为非成员、非友元的普通函数。
编写程序,求两个复数之和*/#include<iostream>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<<"("<<real<<","<<imag<<"i)";}Complex operator +(Complex &c1,Complex & c2) { Complex p;p.real=c1.real+c2.real;p.imag=c1.imag+c2.imag; return p;}int mai n(){Complex c1(3,5),c2(2,5),c3;c1.display();coutvv"+";c2.display();cout<<"=";c3=c1+c2;c3.display();Task8-2/*2. 定义一个复数类 Complex ,重载运算符“ + ”、”- “、” *”、” / ”,使之能用于复数的加、减、乘、除。
运算符重载函数作为 Complex 类的成员函数,编程,分别求两个复数之和差积商。
*/#include<iostream>using namespace std;class Complex{public:Complex(){real=0;imag=0;}Complex(double r,double i){real=r;imag=i;}Complex operator+(Complex &c2);Complex operator-(Complex &c2);Complex operator*(Complex &c2);Complex operator/(Complex &c2);void display();private:double real;double imag;};Complex Complex::operator +(Complex &c2) {Complex c;c.real=real+c2.real;c.imag=imag+c2.imag;return c;}Complex Complex::operator -(Complex &c2){Complex c;c.real=real-c2.real;c.imag=imag-c2.imag;return c;}Complex Complex::operator *(Complex &c2){Complex c;c.real=real*c2.real;c.imag=imag*c2.imag;return c;}Complex Complex::operator /(Complex &c2){Complex c;c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag); return c; }void Complex::display(){cout<<"("<<real<<","<<imag<<"i)"<<endl;}int main(){Complex c1(3,4),c2(5,-10),c3;c3=c1+c2;cout<<"c1+c2=";c3.display();c3=c1-c2;cout<<"c1-c2=";c3.display();c3=c1*c2;cout<<"c1*c2=";c3.display();c3=c1/c2;cout<<"c1/c2=";c3.display();return 0;}3.有两个矩阵a 和b ,均为n 行m 列(m 、n 的值自己给出)求两个矩阵之和、差、积、商, 重载运算符“ + ”、”使之能用于矩阵向c=a*b 。
1、重新编写所有的Time类范例,使用友元函数来实现所有的重载操作符号。
2、复数由两个部分组成:实数部分和虚数部分。
复数的一种书写方式是:(3.0, 4.0),其中,3.0是实数部分,4.0是虚数部分。
假设a=(A,Bi),c=(C,Di),则下面是一些复数运算:A、加法:a+c = (A + C,(B+D)i)B、减法:a-c = (A - C,(B-D)i)C、乘法:a*c = (A *C – B*D,(A*D + B*C)i)D、乘法:x * c=( x*C, x*Di), 其中x 为实数E、共轭:~a = (A, -Bi)请定义一个复数类,以便下面的程序可以使用它来获得正确的结果:#include <iostream>Using namespace std;#include “complex0.h”Int main(){Complex a(3.0, 4.0); // 初始化一个复数Complex c;Cout << “Enter a Complex number (q to quit): \n”;While (cin >> c){Cout << “ c is ” << c<< ‘\n’;Cout << “C omplex conjugate is” << -c << ‘\n’;Cout << “a is” << a<< ‘\n’;Cout << “a + c is” << a + c<< ‘\n’;Cout << “a - c is” << a - c<< ‘\n’;Cout << “a * c is” << a * c<< ‘\n’;Cout << “2 * c is” << 2 * c<< ‘\n’;Cout << “Enter a Complex number (q to quit): \n”;}Cout << “Done!” << endl;Return 0;}注意,必须重载<< 和>> 操作符。
运算符重载习题一、选择题1、下面关于运算符重载的说法中,错误的是()。
A、可以对C++所有运算符进行重载B、运算符重载保持固有的结合性和优先级顺序C、运算符重载不能改变操作数的个数D、在运算符函数中,不能使用缺省的参数值2、下列运算符能被重载的是()。
A、::B、?:C、.D、%3、下列叙述正确的是()。
A、运算符重载函数只能是一个成员函数B、运算符重载函数既可以是一个成员函数,也可以是友元函数C、运算符重载函数只能是一个非成员函数D、运算符重载函数只能是友元函数4、下列叙述不正确的是()。
A、利用成员函数重载二元运算符时,参数表中的参数必须为两个B、利用成员函数重载二元运算符时,成员函数的this指针所指向的对象作为运算符的左操作数C、利用成员函数重载二元运算符时,参数表中的参数作为此运算符的右操作数D、运算符重载时不能改变运算符的语法结构5、为了区分一元运算符的前缀和后缀运算,在后缀运算符进行重载时,额外添加一个参数,其类型是()。
A、voidB、charC、intD、float6、下列能正确重载运算符的友元函数原型是()。
A、friend B operator?: ( );B、friend B operator+(int x);C、friend B operator+(B b);D、friend B operator+(B b, B a);7、下列叙述正确的是()。
class B{ int a,b;public:B(int aa=0, int bb=0) { a=aa; b=bb; }B operator+ ( int x ) //A{ B r;r.a=a+x;r.b=b+x;return r;}};void main( ){ B x(3,5), y(8,4), z1, z2;z1=x+5;z2=10+y;//B}A、A行有错误B、B行有错误C、A行和B行都有错误D、A行和B行都没有错误8、下列叙述正确的是()。
2000.1019、重载的运算符仍然保持其原来的优先级、结合性和____________。
25、下面程序希望产生的输出为4+3i,但是运行输出是3+3i,请指出错误并改正#include <iostream.h>class complex {int real; // 实部int imag; // 虚部public:complex(int r=0,int i=0): real(r),imag(i) {}void show() { cout<<real<<"+"<<imag<<"i"<<endl;}complex operator++() { real++; return * this; }};void main() {complex c(2,3);++++c;c.show();}Key:complex &operator++() { real++; return * this; }2001.1029.下面是类fraction(分数)的定义,其中重载的运算符<<以分数形式输出结果,例如将三分之二输出为2/3。
在横线处填上适当字句。
class fraction{int den; //分子int num; //分母friend ostream& operator<<(ostream&,fraction);…};ostream& operator <<(ostream& os,fraction fr){_________;return _________;}29.os<<fr.den<<′/′<<fr.num os2002.106.如果表达式++i*k中的“++”和“*”都是重载的友元运算符,则采用运算符函数调用格式,该表达式还可表示为( )A.operator*(i.operator++(),k)B.operator*(operator++(i),k)C.i.operator++().operator*(k)D.k.operator*(operator++(i))33.写出下面程序的输出结果。
二、运算符重载(运算符重载的基本概念、运算符重载方法、运算符重载规则、特殊运算符重载和类型转换)单选题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++编译器解释为()。
国家二级C++机试(运算符重载、C++流)模拟试卷1(题后含答案及解析)题型有:1. 选择题选择题1.运算符重载是对已有的运算符赋予多重含义,因此( )。
A.可以对基本类型(如int类型)的数据,重新定义“+”运算符的含义B.可以改变一个已有运算符的优先级和操作数个数C.只能重载C++中已经有的运算符,不能定义新运算符D.C++中已经有的所有运算符都可以重载正确答案:C解析:此题考查的是运算符重载。
运算符重载是针对C++语言原有的运算符进行的,并不能创造新的运算符。
知识模块:运算符重载2.下列运算符中,不能被重载的是( )。
A.&&B.!=C..D.++正确答案:C解析:此题考查的是运算符重载。
在C++中,只有.、.*、->*、::、?:这五个运算符不能重载。
知识模块:运算符重载3.下列关于运算符重载的叙述中,错误的是( )。
A.有的运算符可以作为非成员函数重载B.所有的运算符都可以通过重载而被赋予新的含义C.不得为重载的运算符函数的参数设置默认值D.有的运算符只能作为成员函数重载正确答案:B解析:“运算符重载”是针对C++中原有运算符进行的,不可能通过重载创造新的运算符。
除了.,.*,->*,::,?:这五个运算符以外,其他运算符都可以重载。
知识模块:运算符重载4.下列关于运算符重载的描述中,错误的是( )。
A.::运算符不能重载B.类型转换运算符只能作为成员函数重载C.将运算符作为非成员函数重载时必须定义为友元D.重载[]运算符应完成“下标访问”操作正确答案:C解析:C++把重载的运算符视为特殊的函数,称为运算符函数。
“运算符重载”是针对CH中原有运算符进行的,不可能通过重载创造出新的运算符。
知识模块:运算符重载5.下列关于运算符重载的叙述中,正确的是( )。
A.通过运算符重载,可以定义新的运算符B.有的运算符只能作为成员函数重载C.若重载运算符+,则相应的运算符函数名是+D.重载一个二元运算符时,必须声明两个形参正确答案:B解析:此题考查的是运算符重载。
国家二级C++机试(运算符重载、C++流)模拟试卷2(题后含答案及解析)题型有:1. 选择题选择题1.关于运算符重载,下列表述中正确的是( )。
A.C++已有的任何运算符都可以重载B.运算符函数的返回类型不能声明为基本数据类型C.在类型转换符函数的定义中不需要声明返回类型D.可以通过运算符重载来创建C++中原来没有的运算符正确答案:C解析:此题考查的是运算符重载的概念。
C++语言规定,“.”、“.*”、“->*”、“::”和“?:”这五个运算符不能被重载,故选项A错误:运算符函数的返回类型由该运算符所组成的表达式的值的类型来决定,故选项B说法是错误的;运算符重载是针对原有运算符,并不能通过重载创造出新的运算符,故选项D错误。
知识模块:运算符重载2.下列关于运算符重载的描述中,正确的是( )。
A.运算符重载为成员函数时,若参数表中无参数,重载的是一元运算符B.一元运算符只能作为成员函数重载C.二元运算符重载为非成员函数时,参数表中有一个参数D.C++中可以重载所有的运算符正确答案:A解析:此题考查的是运算符的重载。
运算符重载为成员函数时,形参个数一般为运算符元数减1:重载为非成员函数时,形参个数一般和运算符元数相等。
所以二元运算符重载为非成员函数时,参数表中应有两个参数,C选项错误;运算符重载为成员函数,若参数表中无参数,重载的是一元运算符,选项A正确:一元运算符中,“-”(取负)、“++”、“--”等均可重载为成员函数;C++语言中,“.”、“.*”、“->*”、“::”、“?:”五个运算符不能重载。
知识模块:运算符重载3.运算符重载时不需要保持的性质是( )。
A.操作数个数B.操作数类型C.优先级D.结合性正确答案:B解析:运算符重载应该体现为原有运算符的功能在新的数据类型上的延伸。
重载的运算符保持原有运算符的操作个数、优先级和结合性三个最基本的特征。
知识模块:运算符重载4.下列关于运算符重载的描述中,错误的是( )。
运算符重载一.单项选择题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<运算符>(<参数,<参数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++解释为:(3)A)c.o p e r a t o r++(m);B)m=o p e r a t o r++(m);C)m.o p e r a t o r++(m);D)o p e r a t o r++(m);class fun{public:....f u n o p e r a t o r+=(f u n);f r i e n d f u n o p e r a t o r++(f u n&,i n t);};答案:D7.在第33题中,当执行语句d+=m;时,C++编译器对语句作如下解释:(34)A.d=operator+=(m);B.m=operator+=(d);C. d.operator+=(m);D.m.operator+=(d);答案:C8.设有以下类定义,其中说明了“+”运算符重载函数的原型。
实验21 运算符重载一、实验目的和要求1.理解运算符重载的作用。
2.掌握实现运算符重载的方法及几种特殊运算符的重载格式。
3.进一步锻炼针对类的编程能力。
二、实验准备☞知识点1.运算符重载定义的一般格式、基本概念。
2.运算符函数重载的两种形式。
3.通过成员函数实现运算符重载的一般格式。
4.通过友元函数实现运算符重载的一般格式。
5.”++”运算符的重载。
6.”=”赋值运算符的重载。
☞课前练习题1.重载运算”+”,实现a+b运算,则。
A.a必须为对象,b可为整数或实数B.a和b必须为对象C.b必须为对象,a可为整数或实数D.a和b均可为整数或实数2.在C++中,运算符的重载有两种实现方法,一种是通过成员函数来实现,另一种则通过_________来实现。
3.不能重载的5个运算符是:______、______、______、______、_________。
4.重载赋值运算符必须通过________函数实现。
5.用成员函数实现前置”--”运算符重载的一般格式为:_______________________________。
6.用友元函数实现后置”--”运算符重载的一般格式为:_______________________________。
☞分析1.有以下程序:#include<iostream.h>class C{private:double x;public:C( ) { x=0.0; }C(double a) { x=a; }friend C operator--(C t) //行A{t.x--;return t;}void show(){cout<<x<<endl;}};void main(){C c(5.6);(--c).show(); //行Bc.show(); //行C}请回答问题:①从行A 的形式上看,这是利用________函数实现__________运算符的重载。
第11章运算符重载一.单项选择题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. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。
习题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、要实现动态联编,必须通过()调用虚函数。
C++中的运算符重载练习题1.RMB类要求:定义⼀个RMB类 Money,包含元、⾓、分三个数据成员,友元函数重载运算符‘+’(加)和 ‘-’(减),实现货币的加减运算例如:请输⼊元、⾓分:2 3 4请输⼊元、⾓分:3 7 3和:6元0⾓7分差:-1元3⾓9分⼜例如:请输⼊元、⾓分:2 3 4请输⼊元、⾓分:3 0 0和:4元6⾓0分差:-0元6⾓6分代码实现:1 #include <iostream>2using namespace std;34class Money5 {6private:7int yuan, jiao, fen;8bool flag; //标志位,0表⽰钱数为正,1表⽰钱数为负 -> 默认结果的钱数为正9public:10 Money();11 Money(int fg, int y=0, int j=0, int f=0): yuan(y), jiao(j), fen(f), flag(fg){}12 friend Money operator+(Money a, Money b);13 friend Money operator-(Money a, Money b);14void display();1516 };1718 Money::Money()19 {20 flag = 0;21 cout << "请输⼊元、⾓分:" <<endl;22 cin >> yuan >> jiao >> fen;23 }2425void Money::display()26 {27if(flag==1) cout << '-';28 cout << yuan << "元" << jiao << "⾓" << fen << "分" << endl;29 }3031//请⽤友元函数重载加/减,并要在类Money中声明为友元32//TODO重载加类外定义Money类的+重载运算33 Money operator+(Money a, Money b)34 {35 Money temp(0);36// 将钱全部转化成分来计算37int money_a = a.yuan*100 + a.jiao*10 + a.fen*1;38int money_b = b.yuan*100 + b.jiao*10 + b.fen*1;39int res = money_a + money_b;40// 因为是相加故应该结果是正的所以不⽤判断符号但是相减时结果可能为负就要判断符号41 temp.yuan = res/100;42 res = res % 100;43 temp.jiao = res/10;44 temp.fen = res % 10;4546// 返回结果对象47return temp;48 }4950//TODO重载减类外定义Money类的-重载运算51 Money operator-(Money a, Money b)52 {53 Money temp(0);54// 将钱全部转化成分来计算55int money_a = a.yuan*100 + a.jiao*10 + a.fen*1;56int money_b = b.yuan*100 + b.jiao*10 + b.fen*1;57int res = money_a - money_b;58// 因为是相减时结果可能为负就要判断符号59if(res < 0)60 {61 temp.flag = 1;62 res = -res;63 }64 temp.yuan = res/100;65 res = res % 100;66 temp.jiao = res/10;67 temp.fen = res % 10;6869// 返回结果对象70return temp;71 }7273int main()74 {75 Money m1, m2, m3(0), m4(0); //m3⽤来记录和,m4⽤来记录差7677// +78 m3=m1+m2;79 cout<<"和:";80 m3.display();8182// -83 m4=m1-m2;84 cout<<"差:";85 m4.display();8687return0;88 }2.⽇期类运算符重载要求:定义⼀个⽇期类Date,包含年、⽉、⽇三个数据成员友元函数重载⾃增运算符(++),实现⽇期的⾃增。
c++运算符重载习题Task8-1/*1. 定义一个复数类Complex,重载运算符“+”,使之能用于复数的加法运算。
将运算符函数重载为非成员、非友元的普通函数。
编写程序,求两个复数之和*/#include<iostream>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<<"("<<real<<","<<imag<<"i)";}Complex operator +(Complex &c1,Complex &c2){Complex p;p.real=c1.real+c2.real;p.imag=c1.imag+c2.imag;return p;}int main(){Complex c1(3,5),c2(2,5),c3;c1.display();cout<<"+";c2.display();cout<<"=";c3=c1+c2;c3.display();}Task8-2/*2. 定义一个复数类Complex,重载运算符“+”、”-“、”*”、”/”,使之能用于复数的加、减、乘、除。
运算符重载函数作为Complex类的成员函数,编程,分别求两个复数之和差积商。
*/#include<iostream>using namespace std;class Complex{public:Complex(){real=0;imag=0;}Complex(double r,double i){real=r;imag=i;}Complex operator+(Complex &c2);Complex operator-(Complex &c2);Complex operator*(Complex &c2);Complex operator/(Complex &c2);void display();private:double real;double imag;};Complex Complex::operator +(Complex &c2){Complex c;c.real=real+c2.real;c.imag=imag+c2.imag;return c;}Complex Complex::operator -(Complex &c2){Complex c;c.real=real-c2.real;c.imag=imag-c2.imag;return c;}Complex Complex::operator *(Complex &c2){Complex c;c.real=real*c2.real;c.imag=imag*c2.imag;return c;}Complex Complex::operator /(Complex &c2){Complex c;c.real=(real*c2.real+imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);c.imag=(imag*c2.real-real*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag); return c;}void Complex::display(){cout<<"("<<real<<","<<imag<<"i)"<<endl;}int main(){Complex c1(3,4),c2(5,-10),c3;c3=c1+c2;cout<<"c1+c2=";c3.display();c3=c1-c2;cout<<"c1-c2=";c3.display();c3=c1*c2;cout<<"c1*c2=";c3.display();c3=c1/c2;cout<<"c1/c2=";c3.display();return 0;}Task8-3/*3. 有两个矩阵a和b,均为n行m列(m、n的值自己给出),求两个矩阵之和、差、积、商,重载运算符“+”、”-“、”*”、”/”,使之能用于矩阵向加减乘除,如c=a+b、 c=a*b。
运算符重载练习题一、选择题1、在C++中不能重载的运算符是()。
A、=B、()C、::D、delete2、在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、友元运算符obj1>obj2被C++编译器解释为()。
A、operator>(obj1,obj2)B、>(obj1,obj2)C、obj2.operator>(obj1)D、obj1.operator>(obj2)8、在表达式x+y*z中,+作为成员函数重载的运算符,*作为非成员函数重载的运算符。
下列叙述中正确的是()。
A、opertator+有两个参数,opertator*有两个参数B、opertator+有两个参数,opertator*有一个参数C、opertator+有一个参数,opertator*有两个参数D、opertator+有一个参数,opertator*有一个参数9、重载赋值运算符时,应声明为重载的()函数。
A、友元B、虚C、成员D、多态10、在一个类中,可以对一个操作符进行()重载。
A、1种B、2种以下C、3种以上D、多种11、在重载一个运算符时,其参数表中没有任何参数,这表明该运算符是().A、作为友员函数重载的一元运算符B、作为成员函数重载的一元运算符C、作为友员函数重载的二元运算符D、作为友员函数重载的二元运算符12、在成员函数中进行双目运算符重载时,其参数表中应带有()个参数。
国家二级C++机试(运算符重载)模拟试卷6(题后含答案及解析) 题型有:1. 选择题选择题1.有如下程序:#inc1ude<iostream>Using namespace std; Class Amount{ int amount; public; Amount(int n=0): amount(n){} Int getAmount( )const {retum amount;} Amount &operator+=(Amount a){ amount+=a.amount; retum ; } };int main( ){ Amount x(3),y(7);x+=y;cout<<x.getAmount( )<<end1; retum 0;} 已知程序的运行结果是10,则下划线处缺失的表达式是( )。
A.*thisB.thisC.&amountD.amount正确答案:A解析:此题考查的是“+”运算符重载和this指针。
语句amount+=a.amount;实现3和7的求和得到amount=10,要使程序的输出结果为10,又因为函数的返回值类型为Amount&,所以横线处填入*this。
知识模块:运算符重载2.如果表达式a>=b中的“>=”是作为非成员函数重载的运算符,则可以等效地表示为( )。
A.a.operator>=(b)B.b.operatotr>=(a)C.operator>=(a,b)D.operator>=(b,a)正确答案:C解析:运算符函数作为非成员函数时,没有隐含的this指针,因此所有的操作数必须出现在参数表中,对于二元运算符,参数表中有两个参数,分别代表第一操作数和第二操作数,且顺序不能改变。
知识模块:运算符重载3.已知表达式++a中的“++”是作为成员函数重载的运算符,则与++a等效的运算符函数调用形式为( )。
A.a.operator++(1)B.operator++(a)C.operator++(a,1)D.a.operator++( )正确答案:C解析:本题主要是对运算符霞载的考查。
运算符重载一.单项选择题1.下列运算符中,运算符在C++中不能重载。
A .?:B.+C.D.<=解: C++中不能被重载的运算符有:·,一,::,?:。
本题答案为A。
2.下列运算符中,运算符在C++中不能重载。
A .&& B.[]C.::D.newc。
解: 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);};答案: D7.在第 33 题中,当执行语句 d+=m; 时, C++ 编译器对语句作如下解释:(34)A. d=operator+=(m);B. m=operator+=(d);C. d.operator+=(m);D. m.operator+=(d);答案: C8.设有以下类定义,其中说明了“+”运算符重载函数的原型。
这是一个友元函数,当类外有语句a=b+c;访问这个友元函数时,C++ 编译器把对语句a=b+c;解释为:operator +(b,c)其中:(35)A. a,b,c C. a,c都必须是Com 的对象都必须是Com 的对象B. a,bD. b,c都必须是都必须是Com 的对象Com 的对象class Com{ ... ...friend Com operator +(... ...); };答案: B二.填空题1.利用成员函数对双目运算符重载,其左操作数为,右操作数为。
解:将双目运算符重载为类的成员函数时,由于this指针在每次非静态成员函数操作对象时都作为第一个隐式参数传递给对象,因此它充当了双目运算符的左操作数,而该成员函数的形参则表示双目运算符的右操作数。
本题答案为:this指针成员函数参数。
2.运算符重载仍然保持其原来的优先级、和。
解:运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算符的语法结构。
本题答案为:结合性语法结构。
3.为了满足运算符“+”的可交换性,必须将其重载为。
解:以友元函数方式重载运算符可满足运算符“+”的可交换性,因为两个操作数都作为参数,例如,有以下程序:#include<iostream . h>class Sample{int n;public:Sample(){}Sample(int i){n=i;}friend Sample operator+(Sample,Sample);void disp() {cout<<“ n=” <<n<<endl;}}Sample operator+(sample s1,Sample s2){return sample(S1.n+s2.n);}void main(){Sample S1(2),s2(5),s3;cout<<” S1:”; S1.disp();cout<<” s2:”; s2.disp();s3=S1+S2 ;cout<<” s3:”; s3 .disp();S3=S2+S1;cout<< ” s3:”; s3.disp();}程序执行结果如下:从中看到,执行 sl+s2 和 s2+sl 的结果是相同的,从而满足运算符“ +”的交换性。
所以本题答案为:友元函数。
4 .在c++中,运算符的重载有两种实现方法,一种是通过成员函数来实现,另一种则通过(4)来实现。
答案:友元5. 当用成员函数重载双目运算符时,运算符的左操作数必定是:(5)答案:对象三.程序分析题1.以下程序的执行结果是#include<iostream . h>class Sample{。
int n;public:Sample(){)Sample(int m){n=mint &operator--(int){n--;return n;}; )void disp() { cout<<”rl=”<<n<<endl;)}void main(){Sample s(10)(S--)++;S .disp();;}解:该程序中,类 Sample 的重载”一”运算符的成员函数返回Sample 对象的私有数据成员 n 的引用。
在main() 函数中执行 (s--)++;语句时,先调用重载成员函数,使S 对象的n 值减 1,这时返回的是S 对象的 n 的引用,再执行++运算,也就是对s 对象的 n 值执行++运算,所以s 对象的 11 值保持不变。
程序的执行结果为:n=lO 。
2.以下程序的执行结果是:#include<iostreamclass Sample{. h>private:int x;public:Sample(){x=0; }void disp(){cout<< void 0perator++(){x+=10”x=”<<x<<endl;; }}}void main() {Sample obj obj . disp();;obj++;cout<<“执行。
obj . disp();bj++ 之后”<<endl;}解:在类该对象的Sample 中设计运算符重载成员函数,使运算符“x 增 10。
本题答案为:++”作为于Sample 类对象时,x=0执行obj++ 之后x=103.阅读下面的程序,在空白处填写出程序运行后的结果。
#include<iostream . h>class complex{float real,imag,public:complex(float r,float i){real=r;imag=i;}complex(){real=O; imag=O ; }void print();friend complex operator+(complex a,complex b);friend complex operator一(complex a,complex b);friend complex operator‘ (complex a,complex b);friend complex operator/(complex a,complex b);}void complex{::print()cout<<real:if(imag>O)cout<<”+”;if(imag!:0) cout<<imag<<” i” <<endl;}complex operator+(complex a,complex b){complex temp;temp . real=a . real+b . real ;temp . imag=a. imag+b. imag;return temp;}complex operator-(complex a,complex b){complex temp;temp . real=a . real-b.real;temp . imag=a. imag-b . imag;return temp;}complex operator *(complex a,complex b){complex temp temp . real;: a. real*b. real-a. imag *b. imag;temp . imag=a. real *b.imag+a.imag *b.real;return temp;}complex operator/(complex a,complex b){complex temp;float tt;tt=l/ (b .real ‘ b.real+b .imag 。
b. imag) ;temp. real=(a . real*b . real+a . imag*b . imag)*tt;temp. imag=(b . real*a . imag-a . real*b . imag)*tt;return temp;}void main(){complex c1(2. 3, 4. 6) , c2(3 . 6, 2. 8) , c3;c1. print();c2. print();c3=c1+c2;c3. print();c3=c1-c2;c3. print();c3=c1*c2;c3. print();c3=c1 / c2;c3. print();}程序运行结果为:2. 3+4. 6i3. 6+2. 8i(1)(2)(3)(4)解: (1) 、 (2) 、 (3) 和 (4) 分别是 2.3+4 .6i 和 3.6+2.8i 除的结果。