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中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。

程序设计教程课后习题答案第7章操作符重载

第7章操作符重载1、为什么要对操作符进行重载？是否所有的操作符都可以重载？答：通过对C++操作符进行重载，我们可以实现用C++的操作符按照通常的习惯来对某些类（特别是一些数学类）的对象进行操作，从而使得程序更容易理解。

除此之外，操作符重载机制也提高了C++语言的灵活性和可扩充性，它使得C++操作符除了能对基本数据类型和构造数据类型进行操作外，也能用它们来对类的对象进行操作。

不是所有的操作符都可以重载，因为“.”，“.*”，“::”，“?:”，sizeof这五个操作符不能重载。

2、操作符重载的形式有哪两种形式？这两种形式有什么区别？答：一种就是作为成员函数重载操作符；另一种就是作为全局（友元）函数重载操作符。

当操作符作为类的非静态成员函数来重载时，由于成员函数已经有一个隐藏的参数this，因此对于双目操作符重载函数只需要提供一个参数，对于单目操作符重载函数则不需提供参数。

当操作符作为全局函数来重载时，操作符重载函数的参数类型至少有一个为类、结构、枚举或它们的引用类型。

而且如果要访问参数类的私有成员，还需要把该函数说明成相应类的友元。

对于双目操作符重载函数需要两个参数，对于单目操作符重载函数则需要给出一个参数。

操作符=、 ( )、[ ]以及->不能作为全局函数来重载。

另外，作为类成员函数来重载时，操作符的第一个操作数必须是类的对象，全局函数重载则否。

3、定义一个时间类Time，通过操作符重载实现：时间的比较（==、!=、>、>=、<、<=）、时间增加/减少若干秒（+=、-=）、时间增加/减少一秒（++、--）以及两个时间相差的秒数（-）。

解：class Time{private :int hour, minute, second;public :Time(){ hour=minute=second=0;}Time(int h){ hour=h;minute=second=0;}Time(int h, int m){ hour=h;second=0;}Time(int h, int m, int s){ hour=h;minute=m;second=s;}Time(const Time &t){ hour=;minute=;second=;}bool operator ==(Time &t){ if (hour== && minute== && second== return true;return false;}bool operator !=(Time &t){ return !(*this == t);}bool operator > (Time &t){ if (hour>return true;else if (hour== && minute>return true;else if (hour== && minute== && second> return true;elsereturn false;}bool operator >=(Time &t){ return *this > t || *this == t;}bool operator <(Time &t){ return !(*this >= t);}bool operator <=(Time &t){ return !(*this > t);}Time &operator +=(int s){ second+=s;while (second>=60){ second-=60;}while (minute>=60){ minute-=60;hour++;}while (hour>=24)hour-=24;return *this;}Time &operator -=(int s){ second-=s;while (second<0){ second+=60;minute--;}while (minute<0){ minute+=60;hour--;}while (hour<0)hour+=24;return *this;}Time &operator ++() eal = -real;= -imag;return temp;}friend bool operator ==(const Complex &c1,const Complex &c2); friend bool operator !=(const Complex &c1,const Complex &c2); friend bool operator > (const Complex &c1,const Complex &c2); friend bool operator >=(const Complex &c1,const Complex &c2); friend bool operator < (const Complex &c1,const Complex &c2); friend bool operator <=(const Complex &c1,const Complex &c2);friend Complex operator+(const Complex &c1,const Complex &c2);friend Complex operator-(const Complex &c1,const Complex &c2);friend Complex operator*(const Complex &c1,const Complex &c2);friend Complex operator/(const Complex &c1,const Complex &c2); };bool operator ==(const Complex &c1,const Complex &c2){ return == && == ;}bool operator !=(const Complex &c1,const Complex &c2){ return !(c1 == c2);}bool operator >(const Complex &c1,const Complex &c2){ return () > ();}bool operator >=(const Complex &c1,const Complex &c2){ return () >= ();}bool operator <(const Complex &c1,const Complex &c2){ return () < ();}bool operator <=(const Complex &c1,const Complex &c2){ return () <= ();}Complex operator+(const Complex &c1,const Complex &c2){ Complex temp;=+;=+;return temp;}Complex operator-(const Complex &c1,const Complex &c2){ Complex temp;= = return temp;}Complex operator*(const Complex &c1,const Complex &c2){ Complex temp;=* =*+*;return temp;}Complex operator/(const Complex &c1,const Complex &c2){ double d=();if (d != 0){ Complex temp;=*+*/d;=* return temp;}else{ cout << "Error in operation / of Complex" << endl;exit(-1);}}4、定义一个多项式类Polynomial，其实例为多项式：a0+a1x+a2x2+...+a n x n，该类具有如下的接口：class Polynomial{ ......static void *operator new(size_t size);static void operator delete(void *p);static void free_blocks(); //归还申请的所有存储块。

运算符重载知识题

.《面向对象程序设计》习题班级：学号：姓名：名单序号：成绩：第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. 下列运算符中哪些是不能够被重载的（）。

运算符重载自考习题

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.写出下面程序的输出结果。

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

实验七-运算符重载参考答案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;}问题一：以上程序中的三个运算符重载都有错误，试改正过来，使程序输出正确结果。

国家二级C%2b%2b机试(运算符重载)模拟试卷3.doc

控制面板试卷遒分:分试题数量:答题120分-钟一剩余时间:调整字号：12 14 16 1820调整背景：国家二级C++机试（运算符重载）模拟试卷3全部题型1.选择题选择题1.运算符重载是对已有的运算符赋予多重含义，因此（）。

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

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

2.通过运算符重载，可以改变运算符原有的（）。

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

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

故本题选项A正确。

答题卡1A B C D2 A B C D3 A B C D4 A B C D5 A B C D6A B C D7 A B C p8 A B C D9 A B C D WA B C D11 A B CD12A BCD13A BCD14A B C D -----15 A B C D 16A B C D 17A BCD18A B C D 19A BCD20A BCD21A BCD 22 A B C D3.下列关于运算符重载的描述中，正确的是（）。

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

运算符重载为成员函数时，形参个数一般为运算符元数减1;重载为非成员函数时，形参个数一般和运算符元数相等。

所以二元运算符重载为非成员函数时，参数表中应有两个参数，C选项错误：运算符重载为成员函数，若参数表中无参数，重载的是一元运算符，选项A 正确：一元运算符中，“・”（取负）、"++”、"・・”等均可重载为成员函数：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行都没有错误八、以下表达正确的选项是（）。

运算符重载程序例题解答

/*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.定义描述一个三维点，利用友元函数重载"++"和"--"运算符，并区分这两种运算符的前置和后置运算。

C 运算符重载实例

1.赋值函数的重载示例程序代码如下#include "stdafx.h"#include <malloc.h>class stack{private:int *sp, top, max;void inflate();public:stack(int size = 10){sp = (int *)malloc(sizeof(int) * size); max = size;top = 0;}int pop();void push(int value);stack & operator=(stack & rightValue); };//栈的容量增倍void stack::inflate(){int index, *tp;tp = (int *)malloc(sizeof(int) * max * 2); for(index = 0; index < top; index++){tp[index] = sp[index];}max += max;free(sp);sp = tp;}//出栈int stack::pop(){if(top <= 0)throw 1;return sp[--top];}//入栈void stack::push(int value){if(top == max)inflate();sp[top++] = value;}//赋值函数stack & stack::operator=(stack & rightValue){top = rightValue.top;max = rightValue.max;sp = (int *)malloc(sizeof(int) * max);for(int index = 0; index < max; index++){sp[index] = rightValue.sp[index];}return *this;}void main(){stack x(100), y, z;z = y = x;}这里要注意的是赋值函数的返回值是stack &，这是为了实现链式表达式，如z = y = x;。

c++练习题实验7 多态性和运算符重载.

cout<<"使基类指针指向子类对象"<<endl;
employee *ptr[3]={&m1,&t1,&s1};
for(int i=0;i<3;i++)
ptr[i]->displayStatus();
}
1.完善【实例2】程序，写出实现以下功能的代码并上机调试。
（1）将成员函数displayStatus设置成虚函数，运行程序，观察运行结果。体会如何正确使用虚函数实现运行时的多态性。
根据题目要求，设计一个基类Employee，然后派生出Technician（兼职技术人员）类、Manager（经理）类和Salesman（兼职销售员）类。
#include <iostream.h>
#include <string>
using namespace std;
/////////////定义职员基类
{
hourlyRate=100; //每小时酬金100元
}
void technician::pay()
{
cout<<"输入本月工作时数：";cin>>workHours;
sumPay=hourlyRate*workHours;//月薪=工作小时*每小时酬金
}
void technician::displayStatus()
Y1 b(3,4),*bp=&b;
Z1 c(5,6),*cp=&c;
X1 *p[2]={&b,&c};
for(int i=0;i<2;i++)
p[i]->output();

实验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 重载习题资料

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程序设计与应用基础第三章重载习题答案

{
public:
Polynomial();
Polynomial operator+(const Polynomial&)const;
Polynomial operator-(const Polynomial&)const;
Polynomial operator*(const Polynomial&);
friend Three_d operator + (Three_d& t1,Three_d& t2);
private:
int x,y,z;
};
Three_d operator +(Three_d& t1,Three_d& t2)
{
return Three_d(t1.x+t2.x,t1.y+t2.y,t1.z+t2.z);
第三章重载
1、请完成下列填空题
1）在C++中,只能重载为类的成员函数的运算符是_=_、__[]__、__()__、__->__。
2)利用成员函数对二元运算符重载,其左操作数为___This___,右操作数为___成员函数参数___。
3)单目运算符作为类成员函数重载时___没有___的参数；双目运算符作为___类成员函数___重载时需声明其右操作数,作为___友元函数___重载时需声明全部操作数。
}
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;}
Void Get(int &I,int &j,int &k({I=x;j=y;k=z;}

习题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、要实现动态联编，必须通过（）调用虚函数。

运算符重载练习题1

运算符重载一．单项选择题1．下列运算符中，运算符在C++中不能重载。

A．?： B．+ C． D．<=2．下列运算符中，运算符在C++中不能重载。

A．&& B．[] C．：： D．new3．下列关于运算符重载的描述中，是正确的。

A．运算符重载可以改变操作数的个数B．运算符重载可以改变优先级C．运算符重载可以改变结合性D．运算符重载不可以改变语法结构4．友元运算符objl>obj2被C++编译器解释为。

A．operator>(objl，obj2) B．>(obj1，obj2)C．obj2．operator：>(obj1) D．objl．operator>(obj2) 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++解释为：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);};7. 在第6题中，当执行语句d+=m; 时，C++编译器对语句作如下解释：A. d=operator+=(m);B. m=operator+=(d);C. d.operator+=(m);D. m.operator+=(d);8. 设有以下类定义，其中说明了“+”运算符重载函数的原型。

运算符重载综合练习题

运算符重载练习题一、选择题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、在成员函数中进行双目运算符重载时，其参数表中应带有（）个参数。

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

选择题
1．在下列运算符中，能重载的是( )。

(a) ! (b) sizeof (c) new (d) delete
2．在下列运算符中，不能重载的是( )。

(a) <= (b) >> (c) ：：(d) &=
3．下列关于运算符重载的描述中，( )是正确的。

(a) 可以改变参与运算的操作数个数(b) 可以改变运算符原来的优先级
(c) 可以改变运算符原来的结合性(d) 不能改变原运算符的语义
4．下列函数中，能重载运算符的函数是( )。

(a) 成员函数(b) 构造函数(c) 析构函数(d) 友员函数
5．不能用友员函数重载的是( )。

(a) = (b) = = (c) += (d) !=
6．下面描述中，错误的是( )。

(a) 只有系统预先定义的运算符才可能被重载
(b) 使用类型转换函数不能把一个类转换为另一个类
(c) 使用类型转换函数可以把类转换为基本类型
(d) 类型转换函数只能定义为一个类的成员函数，不能定义为类的友员函数
1、a,c,d
2、c
3、d
4、b,c
5、a
6、b
阅读下列程序，写出执行结果
1．#include〈iostream.h〉
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;
}
void 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 = 75
2．#include〈iostream.h〉
class vector
{ public:
vector( ){ }
vector(int i,int j)
{ x = i ; y = j ; }
friend vector operator + ( vector v1, vector v2 )
{ vector tempvector ;
tempvector.x = v1.x + v2.x ;
tempvector.y = v1.y + v2.y ;
return tempvector ;
}
void display( )
{ cout << "( " << x << ", " << y << ") "<< endl ; }
private:
int x , y ;
};
void main( )
{ vector v1( 1, 2 ), v2( 3, 4 ), v3 ;
cout << "v1 = " ;
v1.display( ) ;
cout << "v2 = " ;
v2.display( ) ;
v3 = v1 + v2 ;
cout << "v3 = v1 + v2 = " ;
v3.display( ) ;
}
【答案】
v1 = ( 1, 2 )
v2 = ( 3, 4 )
v3 = v1 + v2 = ( 4, 6 )。