c 运算符的重载习题答案

合集下载

最新《C++程序设计案例教程》习题答案第10章 运算符重载

最新《C++程序设计案例教程》习题答案第10章  运算符重载

第10章运算符重载一、选择题1.A2.D3.A4.B5.D6.C二、写出下列程序运行结果(略)三、简答题1.(1)只能重载已有的C++运算符,不可自创新的运算符。

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

(3)重载的功能应当与原有功能相类似。

2.: : . .* ? : sizeof typeid 3.&& | | ,四、编程题1.#include<iostream>class MyString{public:MyString(){strLength=0;pStr=new char[1];*pStr='\0';}MyString(const char*pString){strLength=strlen(pString);pStr=new char[strLength+1];strcpy(pStr,pString);}MyString(char ch,int n){strLength=n;pStr=new char[strLength+1];for(unsigned int i=0;i<strLength;*(pStr+i++)=ch);*(pStr+strLength)='\0';}MyString(int number){char buffer[20];int temp=number;if(number<0)number=-number;int len=0;do{buffer[len++]=static_cast<char>('0'+number%10 );number/=10;}while(number>0);if(temp<0)buffer[len++]='-';buffer[len]='\0';strLength=len;pStr=new char[strLength+1];strcpy(pStr,buffer);char ch=0;for(int i=0,j=len-1;i<j;i++,j--){ch=pStr[i];pStr[i]=pStr[j];pStr[j]=ch;}}MyString(const MyString&rString){strLength=rString.strLength;pStr=new char[strLength+1];strcpy(pStr,rString.pStr);}~MyString(){delete[]pStr;}MyString& operator+(const MyString&rStr)const {return MyString(*this)+=rStr;}};2.#include<iostream>class MyString{public:MyString(){strLength=0;pStr=new char[1];*pStr='\0';}MyString(const char*pString){strLength=strlen(pString);pStr=new char[strLength+1];strcpy(pStr,pString);}MyString(char ch,int n){strLength=n;pStr=new char[strLength+1];for(unsigned int i=0;i<strLength;*(pStr+i++)=ch);*(pStr+strLength)='\0';}MyString(int number){char buffer[20];int temp=number;if(number<0)number=-number;int len=0;do{buffer[len++]=static_cast<char>('0'+number%10 );number/=10;}while(number>0);if(temp<0)buffer[len++]='-';buffer[len]='\0';strLength=len;pStr=new char[strLength+1];strcpy(pStr,buffer);char ch=0;for(int i=0,j=len-1;i<j;i++,j--){ch=pStr[i];pStr[i]=pStr[j];pStr[j]=ch;}}MyString(const MyString&rString){strLength=rString.strLength;pStr=new char[strLength+1];strcpy(pStr,rString.pStr);}~MyString(){delete[]pStr;}MyString& Operator=(const MyString&rStr)const{if(this == &rStr)return *this;delete []str;str = new char[strlen(rStr.str )+1];strcpy(str, rStr.str);return *this;}};。

C程序设计与应用基础第三章重载习题答案

C程序设计与应用基础第三章重载习题答案

第三章重载1、请完成下列填空题1)在C++中,只能重载为类的成员函数的运算符是_=_、__[]__、__()__、__->__。

2)利用成员函数对二元运算符重载,其左操作数为___This___,右操作数为___成员函数参数___。

3)单目运算符作为类成员函数重载时___没有___的参数;双目运算符作为___类成员函数___重载时需声明其右操作数,作为___友元函数___重载时需声明全部操作数。

4)设a和b是两个整型变量,a+b表示这两个变量的和:设c和d为浮点型变量,c+d也表示这两个变量的和。

这里的运算符+具有不同的用途,这是__运算符重载___的例子。

5)重载的运算符仍然保持其原来的优先级、___结合性___和___语法结构___。

6)C++中不能重载的运算符有、__*___、___::___、___?:___和___sizof___。

2、编程题1)字符串连接需要两个操作数,即两个要被连接的字符串。

请按照以平方式实现operator +操作:string1=string2+string3答案:#include <>#include <>class String{public:String(int size=80){length=size;buf=new char[length+1];*buf='\0';}String(char *s){length=strlen(s);buf=new char[length+1];strcpy(buf,s);}String(const String& str){length=strlen;buf=new char[length+1];strcpy(buf,;}~String(){delete[]buf;}String& operator =(const String& str){length=;strcpy(buf,;return *this;}void Print(){cout<<buf<<endl;}friend String operator +(const String& str1,const String& str2){String temp(strlen+strlen+1);strcpy,;strcat,;return temp;}private:char *buf;int length;};void main(){String str1,str2("Hello,"),str3("everyone!");str1=str2+str3;();}2)给th类:class Three-d{public:Three_d(int I,int j,int k){x=I;y=j;z=k;}.Three_d()){x=0;y=0;z=0;}V oid Get(int &I,int &j,int &k({I=x;j=y;k=z;}private:int x,y,z;};针对给出的类,重载"+"、"++"与"一"运算符(只重载前缀方式即可)。

国家二级C++机试(运算符重载)模拟试卷5(题后含答案及解析)

国家二级C++机试(运算符重载)模拟试卷5(题后含答案及解析)

国家二级C++机试(运算符重载)模拟试卷5(题后含答案及解析) 题型有:1. 选择题选择题1.运算符重载是对已有的运算符赋予多重含义,因此( )。

A.可以对基本类型(如int类型)的数据,重新定义“+”运算符的含义B.可以改变一个已有运算符的优先级和操作数个数C.只能重载C++中已经有的运算符,不能定义新运算符D.C++中已经有的所有运算符都可以重载正确答案:C解析:此题考查的是运算符重载。

运算符重载是针对C++语言原有的运算符进行的,并不能创造新的运算符。

知识模块:运算符重载2.关于运算符重载,下列表述中正确的是( )。

A.C++已有的任何运算符都可以重载B.运算符函数的返回类型不能声明为基本数据类型C.在类型转换符函数的定义中不需要声明返回类型D.可以通过运算符重载来创建C++中原来没有的运算符正确答案:C解析:此题考查的是运算符重载的概念。

C++语言规定,“,”、“*”、“—>.”、“∷”和“?:”这五个运算符不能被重载,故选项A错误;运算符函数的返回类型由该运算符所组成的表达式的值的类型来决定,故选项B说法是错误的;运算符重载是针对原有运算符,并不能通过重载创造出新的运算符,故选项D 错误。

知识模块:运算符重载3.通过运算符重载,可以改变运算符原有的( )。

A.操作数类型B.操作数个数C.优先级D.结合性正确答案:A解析:此题考查的是运算符重载。

运算符重载具有保持其原有的操作数个数、优先级、语法结构和结合性不变的特性。

故本题选项A正确。

知识模块:运算符重载4.下列运算符中,不能被重载的是( )。

A.&&B.!=C..D.++正确答案:C解析:此题考查的是运算符重载。

在C++中,只有.、.*、—>*、∷、?:这五个运算符不能重载。

知识模块:运算符重载5.下列关于运算符重载的描述中,正确的是( )。

A.运算符重载为成员函数时,若参数表中无参数,重载的是一元运算符B.—元运算符只能作为成员函数重载C.二元运算符重载为非成员函数时,参数表中有一个参数D.C++中可以重载所有的运算符正确答案:A解析:此题考查的是运算符的重载。

国家二级C++机试(运算符重载、模板和C++流)模拟试卷6(题后含答案及解析)

国家二级C++机试(运算符重载、模板和C++流)模拟试卷6(题后含答案及解析)

国家二级C++机试(运算符重载、模板和C++流)模拟试卷6(题后含答案及解析)题型有:1. 选择题选择题1.若在表达式y/x中,’’/’’是作为成员函数重载的运算符,则该表达式还可以表示为( )。

A.x.operator/(y)B.operator/(x,y)C.y.operator/(x)D.operator/(y,x)正确答案:C解析:运算符函数的函数名是由运算符前加关键字operator构成的。

所以当“/”作为运算符重载后,其格式为operator/。

所以其作为成员函数调用时的格式为y.operator/(x)。

知识模块:运算符重载2.有类定义如下:class Type{ public:Type(int i=0);Type operator-(int);friend Type operator+(Type,Type);private:int val;};若有对象定义Type c1;则下列语句序列中,错误的是( )。

A.Type(3)+c1;B.e1+Type(3);C.3-c1:D.c1-3;正确答案:C解析:由于在类Type中对“-”进行了重载,所以根据“-”重载的形式定义,c1-3是正确的,而3-c1是错误的表达式。

知识模块:运算符重载3.若要对Data类中重载的加法运算符成员函数进行声明,下列选项中正确的是( )。

A.Data+(Data);B.Data operator+{Data};C.Data+operator{Data};D.operator+(Data,Data);正确答案:B解析:“+”是一个二元运算符,因此作为成员函数重载时参数表中只有一个参数,对应于第二个操作数,而第一个操作数是对象本身。

运算符函数的函数名是由运算符前加关键字operator构成的。

知识模块:运算符重载4.若要对类BigNumber中重载的类型转换运算符long进行声明,下列选项中正确的是( )。

A.operator long( )const;B.operator long(bigNumber);C.long operator long( )const;D.long operator long(BjgNumber);正确答案:A解析:在重载类型转换符时,由于运算符本身已经表示出返回值类型,因此不需要返回值类型的声明。

c运算符的重载习题答案

c运算符的重载习题答案

1.概念填空题1.1运算符重载是对已有的运算符赋予多重含义,使同一个运算符在作用于不同类型对象时导致不同的行为。

运算符重载的实质是函数重载,是类的多态性特征。

1.2可以定义一种特殊的类型转换函数,将类的对象转换成基本数据类型的数据。

但是这种类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。

类类型转换函数既没有参数,也不显式给出返回类型。

类类型函数中必须有return 表达式的语句返回函数值。

一个类可以定义多个类类型转换函数。

1.3运算符重载时其函数名由operator运算符构成。

成员函数重载双目运算符时,左操作数是对象,右操作数是函数参数。

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++运算符重载题库及答案

运算符重载一.单项选择题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.设有以下类定义,其中说明了“+”运算符重载函数的原型。

C运算符重载习题

C运算符重载习题

一、选择题一、下面关于运算符重载的说法中,错误的选项是()。

A、能够对C++所有运算符进行重载B、运算符重载维持固有的结合性和优先级顺序C、运算符重载不能改变操作数的个数D、在运算符函数中,不能利用缺省的参数值二、以下运算符能被重载的是()。

A、::B、?:C、.D、%3、以下表达正确的选项是()。

A、运算符重载函数只能是一个成员函数B、运算符重载函数既能够是一个成员函数,也能够是友元函数C、运算符重载函数只能是一个非成员函数D、运算符重载函数只能是友元函数4、以下表达不正确的选项是()。

A、利用成员函数重载二元运算符时,参数表中的参数必需为两个B、利用成员函数重载二元运算符时,成员函数的this指针所指向的对象作为运算符的左操作数C、利用成员函数重载二元运算符时,参数表中的参数作为此运算符的右操作数D、运算符重载时不能改变运算符的语法结构五、为了区分一元运算符的前缀和后缀运算,在后缀运算符进行重载时,额外添加一个参数,其类型是()。

A、voidB、charC、intD、float六、以下能正确重载运算符的友元函数原型是()。

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;=a+x;=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行都没有错误八、以下表达正确的选项是()。

第11章 运算符重载 习题解答

第11章  运算符重载 习题解答

第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. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。

实验4 运算符重载参考答案

实验4  运算符重载参考答案

运算符重载1、实验目的和要求:掌握运算符重载的语法要点,学会运算符重载的编程方法。

2、实验内容(1)先读程序,写出程序的输出结果,再运行程序验证程序的输出。

用友元重载方式重新编写程序。

#include <iostream>using namespace std;class Vector{ public:Vector(int i = 0,int j = 0) {x=i;y=j;}Vector operator+=(Vector v){ Vector temp;temp.x = x+v.x;temp.y = y+v.y;return temp;}Vector operator-=(Vector v){ Vector temp( x-v.x, y-v.y);return temp;}void display(){ cout<<"("<<x<<","<<y<<")"<<endl;}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();//1,2cout<<"v2="; v2.display();//3,4cout<<"v3="; v3.display();//4,6cout<<"v4="; v4.display();//-2,-2}用友元方式实现:#include <iostream>using namespace std;class Vector{public:Vector(int i = 0,int j = 0){x=i;y=j;}friend Vector operator+=(Vector &v1,Vector &v2) {v1.x+=v2.x;v1.y+=v2.y;return v1;}friend Vector operator-=(Vector &v1,Vector &v2){v1.x=v1.x-v2.x;v1.y=v1.y-v2.y;return Vector( v1.x, v1.y);}void display(){cout<<"("<<x<<","<<y<<")"<<endl;}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();//1,2cout<<"v2="; v2.display();//3,4cout<<"v3="; v3.display();//4,6cout<<"v4="; v4.display();//1,2}(2)定义一个有理数类Rational,重载算术运算符。

大学c习题答案习题13答案

大学c习题答案习题13答案

习题13答案一、简答题1.什么是运算符重载?实现运算符重载有几种方法?如何实现?答案:C++提供的运算符重载机制能够实现将已有运算符应用到新的数据类型变量上,赋予运算符新的含义。

C++对运算符重载有一些限制,见13.2.1节。

有两种方法可以实现运算符重载,它们是:类的成员函数方式和有友元函数方式。

定义友元的目的是在友元函数中直接访问类的私有成员。

实际上,可以通过类的公有函数接口访问类的私有成员,所以实现运算符重载,可以使用非成员、非友元实现运算符的重载。

但是这种实现方法增加了访问私有数据成员的公有函数的调用时间,不值得提倡。

见13.2.2节。

2.如何实现本类对象与其它类对象之间的相互类型转换?答案:可以使用“类型转换函数”将本类对象转换成其他类对象。

而“类型转换函数”本质上就是运算符的重载。

另外,可以使用“构造函数”将其他类对象转换成本类对象。

3.什么是虚函数?什么是纯虚函数?它们的作用是什么?答案:多态性是面向对象程序设计的重要特性,它与前面讲的封装性和继承性构成面向对象程序设计的三大特性。

这三大特性是互相关联的,封装性是基础,继承性是关键,而多态性是补充。

多态分为静态多态和动态多态。

函数重载和运算符重载属于静态多态。

动态多态是运行时的多态,如某些函数的调用关系在运行阶段才能确定。

为了实现函数调用关系的动态多态,可以将函数定义成虚函数。

将一个成员函数定义成虚函数的方法是,在函数定义的返回值类型前加virtual。

在抽象类中,有时无法实现某一功能(即无法决定某一函数的具体实现),只能将函数定义成纯虚函数。

虚函数具有函数实现的函数体,而纯虚函数没有函数体,即没有函数实现。

对纯虚函数,只能在其派生类中实现该函数的功能。

4.试比较虚函数与虚基类的概念及作用。

答案:虚函数用于实现动态多态。

而虚基类用于实现在多重继承情况下,基类数据成员在派生类中保留一个副本,见12.6节。

二、选择题答案:1. C2. D3. A4. D5. B6. C7. D8. C三、运行结果、完善程序1.运行结果:n=4n=32.答案:先看虚线框中的程序,运行结果为:D::show( ) called. 8若将A行的virtual去掉,则结果为:B::show( ) called. 5对本题,若将虚线框中的fun( )和main( )函数同时修改成右侧实线框中的对应函数,则若A 行有virtural时,结果为:D::show( ) called. 8 ;若A行无virtual时,结果为:B::show( ) called. 5 。

运算符重载、继承、派生程序题与答案

运算符重载、继承、派生程序题与答案

1. (10分)栈类——类模板题目描述用类模板方式设计一个链栈类stack<T>,其中有两个私有数据成员:Node<T> *head(链首指针,即栈顶元素指针),int num(栈里结点数)以及3个公有成员函数:push(元素入栈)、pop(元素出栈)和stackempty(判断栈是否为空),并建立一个整数栈和一个字符栈。

template <class T>class stack{};注意:为了能够生成结点类型不同的链式栈,结点类的设计也需要用类模板。

template<class T>class Node{};输入描述输入整数栈的数据元素和字符栈的数据元素输出描述输出整数栈的数据元素出栈序列和字符栈的数据元素出栈序列输入样例4 8 3 2a db c输出样例2 3 8 4c bd a我的代码:#include<iostream>using namespace std;template <class T>class stacktemplate <class T1>class Node{T1 a ;Node<T1> *next ;public:Node(T1 x):a(x){}void show(){cout << a << endl ;}friend class stack<T1> ;};Node<T> *head ;int num ;public:stack(){num = 0 ;head = NULL ;}void push(T x){Node<T> *p = new Node<T>(x) ;p->next = head ;head = p ;num++ ;}T pop(){Node<T> *p = head ;head = head->next ;T t = p->a ;delete p ;num-- ;return t ;}bool stackempty(){if( head == NULL )return true;elsereturn false;}};int main(){stack<int> a ;stack<char> b ;int x ;char y ;for(int i = 0 ; i < 4 ; i ++ ){cin >> x ;a.push(x) ;}for( int i = 0 ; i < 4 ; i ++ ){cin >> y ;b.push(y);}for( int i = 3 ; i >= 0 ; i -- ) {a.stackempty() ;cout << a.pop() << " " ;}cout << endl ;for( int i = 3 ; i >= 0 ; i -- ) {b.stackempty();cout << b.pop() << " " ;}cout << endl ;return 0 ;}2. (10分)二进制类(1)——运算符重载题目描述将一个16位二进制数表示成0和1的字符序列,即用一个字符数组来存放这个二进制数。

国家二级C++机试(运算符重载)模拟试卷6(题后含答案及解析)_0

国家二级C++机试(运算符重载)模拟试卷6(题后含答案及解析)_0

国家二级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解析:本题主要是对运算符霞载的考查。

国家二级C++机试(运算符重载、模板和C++流)模拟试卷7(题后含答案及解析)

国家二级C++机试(运算符重载、模板和C++流)模拟试卷7(题后含答案及解析)

国家二级C++机试(运算符重载、模板和C++流)模拟试卷7(题后含答案及解析)题型有:1. 选择题选择题1.下列关于函数模板的描述中,正确的是( )。

A.函数模板是一个实例函数B.使用函数模板定义的函数没有返回类型C.函数模板的类型参数与函数的参数相同D.通过使用不同的类型参数,可以从函数模板得到不同的实例函数正确答案:D解析:函数模板是一系列相关函数的模型或样板,这些函数的源代码相同,只是所针对的数据类型不同。

数据类型成了函数模板的参数,所以函数模板是一种参数化类型的函数。

知识模块:模板2.有如下函数模板定义:template<typename T1,Typename T2>T1 Fun(T2 n){ return n*5.0;} 若要求以int型数据9作为函数实参调用该模板,并返回一个double型数据,则该调用应表示为( )。

A.FUN(9)B.FUN<9>C.FUN<double>[9]D.FUN<9>(double)正确答案:C解析:根据函数模板的定义,在选项C的调用中,把double类型传递给T1,int型传递给T2。

知识模块:模板3.下列关于模板的描述中,错误的是( )。

A.类模板的成员函数都是模板函数B.函数模板是一种参数化类型的函数C.满足一定条件时可以省略模板实参D.模板形参只能由关键字typename声明正确答案:D解析:同一模板的声明和定义中,模板形参的名字不必相同。

每个模板类型形参前面必须带上关键字typename/class,每个非类型形参前面必须带上类型名字。

知识模块:模板4.已知主函数中通过如下语句序列实现对函数模板swap的调用:inta[10],b[10];swap(a,b,10);下列对函数模板swap的声明中,会导致上述语句序列发生编译错误的是( )。

A.template<typename T>void swap(T a[],T b[],int size);B.template<typename T>void swap(int size,T a[],T b[]);C.template<typename T1,typename T2>void swap(T1 a[],T2 b[],int size};D.template<class T1,class T2>void swap(T1 a[],T2 b[],int size);正确答案:B解析:由题目中函数swap(a,b,10)调用语句可知,在对函数模板swap的声明语句中,应将第一、二个参数设为数组变量,第三个参数为整型变量。

运算符重载程序例题解答

运算符重载程序例题解答

/*1.定义一个复数类,通过重载运算符:+、-、*、/ 等,实现两个复数之间的各种运算。

编写一个完整的程序。

*/#include<iostream.h>class Complex{float Real,Image;public:Complex(float x=0,float y=0){Real=x;Image=y;}friend Complex operator + (Complex &,Complex &);friend Complex operator - (Complex &,Complex &);friend Complex operator * (Complex &,Complex &);friend Complex operator / (Complex &,Complex &);void show(){cout<<"Real="<<Real<<'\t'<<"Image="<<Image<<endl;}};Complex operator + (Complex &a,Complex &b){Complex t;t.Real=a.Real+b.Real;t.Image=a.Image+b.Image;return t;}Complex operator - (Complex &a,Complex &b){Complex t;t.Real=a.Real-b.Real;t.Image=a.Image-b.Image;return t;}Complex operator * (Complex &a,Complex &b){Complex t;t.Real=a.Real*b.Real-a.Image*b.Image;t.Image=a.Real*b.Image+a.Image*a.Real;return t;}Complex operator / (Complex &a,Complex &b){Complex t;t.Real=(a.Real*b.Real+a.Image*b.Image)/(b.Real*b.Real+b.Image*b.Image);t.Image=(a.Image*a.Real-a.Real*b.Image)/(b.Real*b.Real+b.Image*b.Image);return t;}{Complex c1(10,20),c2,c3(50,40);c2=c1+c3;c2.show();c2=c1-c3;c2.show();c2=c1*c3;c2.show();c2=c1/c3;c2.show();}/*2.定义描述一个三维点,利用友元函数重载"++"和"--"运算符,并区分这两种运算符的前置和后置运算。

第11章运算符重载习题解答

第11章运算符重载习题解答

第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. 以下类中分别说明了“+=”和“++”运算符重载函数的原型。

C重载习题

C重载习题

C++重载习题01.分析以下程序执行结果#include<iostream.h>int add(int x,int y){return x+y;}double add(double x,double y){return x+y;}void main(){int a=4,b=6;double c=2.6,d=7.4;cout<<add(a,b)<<","<<add(c,d)<<endl;}解:本题说明函数重载的使用方法,这里有两个add()函数,一个add()函数的参数与返回值为int型,另一个的参数与返回值为double型,它们是根据参数类型自动区分的。

所以输出为: 10,10-----------------------------------------------02.分析以下程序的执行结果#include<iostream.h>class Sample{int i;double d;public:void setdata(int n){i=n;}void setdata(double x){d=x;}void disp(){cout<<"i="<<i<<",d="<<d<<endl;}};void main(){Sample s;s.setdata(10);s.setdata(15.6);s.disp();}解:本题说明重载成员函数的使用方法。

setdata()成员函数有两个,根据其参数类型加以区分。

所以输出为:i=10, d=15.6-----------------------------------------------03.分析以下程序的执行结果#include<iostream.h>class Sample{int n;public:Sample(){}Sample(int i){n=i;}Sample &operator =(Sample);void disp(){cout<<"n="<<n<<endl;}};Sample &Sample::operator=(Sample s){Sample::n=s.n;return *this;}void main(){Sample s1(10),s2;s2=s1;s2.disp();}解:本题说明重载运算符(=)的使用方法。

c++运算符重载习题

c++运算符重载习题

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。

C++Primer 第14章-重载操作符与转换-课后习题答案

C++Primer 第14章-重载操作符与转换-课后习题答案

第十四章重载操作符与转换1。

在什么情况下重载操作符与内置操作符不同?在什么情况下重载操作符与内置操作符相同?重载操作符必须具有至少一个类类型或枚举类型的操作数。

重载操作符不保证操作数的求值顺序,例如对&& 和|| 的重载版本不再具有“短路求值”的特性,两个操作数都要进行求值,而且不规定操作数的求值顺序。

对于优先级和结合性及操作数的数目都不变。

2。

为Sales_item编写输入、输出。

加以及复合赋值操作符的重载声明。

class Sales_item{friend std::istream& operator >> ( std::istream&, Sales_item& );friend std::ostream& operator <<(std::ostream&, const Sales_item&);public:Sales_item& operator += ( const Sales_item& );};Sales_item operator+ ( const Sales_item&, const Sales_item& )3。

解释如下程序,假定Sales_item构造函数的参数是一个string,且不为explicit.解释如果构造函数为explicit会怎样。

string null_book = “0-000-00000-0”;Sales_item item(cin);item += null_book;第一句:调用接受一个C风格的字符串形参的string构造函数,创建一个string临时对象,然后使用string复制构造函数用这个临时对象初始化string对象null_book,第二句:从标准输入设备读入数据,创建Sales_item对象item。

第三句:首先调用接受一个string参数的Sales_item构造函数,创建一个临时对象,然后调用Sales_item的复合重载操作符+=,将这个Sales_item临时对象加到item对象上,如果构造函数为explicit,则不能进行从string对象到Sales_item对象的隐式转换,第三句将不能被编译。

实验七-运算符重载参考答案

实验七-运算符重载参考答案

实验七-运算符重载参考答案LT实验七多态性—函数与运算符重载7.1 实验目的1.理解掌握成员函数方式运算符重载;2.理解掌握友元函数方式运算符重载;3.理解掌握++、--运算符的重载。

7.2 实验内容7.2.1程序阅读1.理解下面的程序,并运行查看结果,回答程序后面的问题。

#include <iostream>using namespace std;class CComplex{public:CComplex(){real = 0;imag = 0;}CComplex(int x,int y){real = x;imag = y;}int real;int imag;CComplex operator + (CComplex obj1)//---------------------------------------------①{CComplex obj2(real - obj1.real, imag - obj1.imag);return obj2;}};int main(){CComplex obj1(100,30);CComplex obj2(20, 30);CComplex obj;obj = obj1+obj2; //------------------------------------------------------------------②cout << obj.real <<endl;cout << obj.imag << endl;return 0;++obj.imag ;return obj;}void print(){cout<<real<<"+"<<imag<<"i"<<endl;}private:float real;float imag;};CComplex &operator--(CComplex &x) //重载前置自减运算符{--x.real;--x.imag;return x;}int main(){CComplex obj1(2.1,3.2);CComplex obj2(3.6,2.5);cout<<"obj1=";cout<<"obj2=";obj2.print();CComplex obj3 = obj1 + obj2;cout<<"before++, obj3=";obj3.print();++obj3;cout<<"after++, obj3=";obj3.print();--obj3;cout<<"after--, obj3=";obj3.print();CComplex obj4 = ++obj3;cout<<"obj4=";obj4.print();return 0;}问题一:以上程序中的三个运算符重载都有错误,试改正过来,使程序输出正确结果。

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

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 )。

A.operator+有两个参数,operator*有两个参数B.operator+有两个参数,operator*有一个参数C.operator+有一个参数,operator*有两个参数D.operator+有一个参数,operator*有一个参数4.写出下列程序运行结果4.1#include <iostream>#using namesoace std;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;}int main(){T obj1( 1,2,3),obj2( 5,5,5),obj3;int a,b,c;obj3=obj1 * obj2;obj3.get( a, b, c);cout<<”(obj1 * obj2):\t”<<”a=”<<a<<’\t’<<“b=”<<b<< '\t'<<”c=”<<c<<’\t’<<endl;(obj2 * obj3 ).get( a, b, c);cout<<“(obj2*obj3):\t”<<“a=”<<a<<'\t'<<”b=”<<b<<’\t’<<“c=”<<c<<'\t’<<endl;}(obj1*obj2): a=5 b=10 c=15(obj2*obj3): a=25 b=50 c=755.编程题5.1将第4章练习5.7的分数类Fraction的算术运算改写成运算符重载函数,使分数类能实现通常的分数+、-、*、/等运算。

#include <iostream>using namespace std;class Fraction{int numerator,denominator;int common_divisor(); //计算最大公约数void contracted(); //分数化简public:Fraction(int=0,int=1);Fraction(Fraction&);Fraction operator+(Fraction);Fraction operator-(Fraction);Fraction operator*(Fraction);Fraction operator/(Fraction);void Set(int=0,int=1);void disp(){cout<<"fraction= "<<numerator<<"/"<<denominator<<endl;}};Fraction::Fraction(int num,int deno){Set(num, deno);}Fraction::Fraction(Fraction& f){numerator=f.numerator;denominator=f.denominator;}Fraction Fraction::operator+(Fraction f){FractionTemp(numerator*f.denominator+f.numerator*denominator,denominator*f.denominator) ;Temp.contracted();return Temp;}Fraction Fraction::operator-(Fraction f){FractionTemp(numerator*f.denominator-f.numerator*denominator,denominator*f.denominator) ;Temp.contracted();return Temp;}Fraction Fraction::operator*(Fraction f){Fraction Temp(numerator*f.numerator,denominator*f.denominator);Temp.contracted();return Temp;}Fraction Fraction::operator/(Fraction f){Fraction Temp(f.denominator,f.numerator );Temp=operator*(Temp);Temp.contracted();return Temp;}int Fraction::common_divisor(){int residue;int dividend=numerator,divisor=denominator;while(residue=dividend%divisor){dividend=divisor;divisor=residue;}return divisor;}void Fraction::contracted(){int residue=common_divisor();numerator/=residue;denominator/=residue;if(denominator<0){numerator*=-1;denominator*=-1;}}void Fraction::Set(int num,int deno){if(deno!=0){numerator=num;denominator=deno;contracted();}}void main(){Fraction f1(1,3),f2(2,5),f3,f4,f5(2,8),f6,f7(8,3),f8(8,3),f9(1,4);f4=f1+f2;f4.disp();f6=f2/f5/f7;f6.disp();f5.disp();f6=f1-f2;f6.disp();}5.2设向量X=(x1,x2,…,x n)和Y=(y1,y2…,y n),它们之间的加、减分别定义为: X+Y=(x1+y1,x2+y2,…,x n+y n)X-Y=(x1-y1,x2-y2,…,x n-y n)编程序定义向量类Vector ,重载运算符”+”、”-“、”=”,实现向量之间的加、减和赋值运算;用重载运算符”>>”、”<<”做向量的输入/输出操作。

注意检测运算的合法性。

#include <iostream.h>//using namespace std;class Vector{int vec[10];public:Vector(int v[10]);Vector();Vector(Vector&);Vector operator+(Vector&);Vector operator-(Vector&);friend ostream& operator<<(ostream& out, Vector&); };Vector::Vector(int v[10]){int i;for(i=0;i<10;i++)vec[i]=v[i];}Vector::Vector(){int i;for(i=0;i<10;i++)vec[i]=0;}Vector::Vector(Vector& v){int i;for(i=0;i<10;i++)vec[i]=v.vec[i];}Vector Vector::operator+(Vector& v){Vector z;int i;for(i=0;i<10;i++)z.vec[i]=vec[i]+v.vec[i];return z;}Vector Vector::operator-(Vector& v){Vector z;int i;for(i=0;i<10;i++)z.vec[i]=vec[i]-v.vec[i];return z;}ostream& operator<<(ostream& out, Vector& v){ for(int i=0;i<10;i++)out<<v.vec[i]<<",";return out;}void main(){int a[10]={-4,1,0,10,5,-9,8,13,6,2,};int b[10]={-11,8,10,17,-6,9,6,7,12,5};Vector v1(a),v2(b),v3,v4;v3=v1+v2;v4=v2-v1;cout<<v3<<endl;cout<<v4<<endl;}5.3定义一个类nauticalmile_kilometer,它包含两个数据成员kilometer(km)和meter(m)。

相关文档
最新文档