第7章 运算符重载-习题
运算符重载练习题.
运算符重载一．单项选择题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. 下列运算符中哪些是不能够被重载的（）。
面向对象程序设计C课后题答案
第一章：面向对象程序设计概述[1_1]什么是面向对象程序设计？面向对象程序设计是一种新型的程序设计范型。
这种范型的主要特征是：程序=对象+消息。
面向对象程序的基本元素是对象，面向对象程序的主要结构特点是：第一：程序一般由类的定义和类的使用两部分组成，在主程序中定义各对象并规定它们之间传递消息的规律。
第二：程序中的一切操作都是通过向对象发送消息来实现的，对象接受到消息后，启动有关方法完成相应的操作。
面向对象程序设计方法模拟人类习惯的解题方法，代表了计算机程序设计新颖的思维方式。
这种方法的提出是软件开发方法的一场革命，是目前解决软件开发面临困难的最有希望、最有前途的方法之一。
[1_2]什么是类？什么是对象？对象与类的关系是什么？在面向对象程序设计中，对象是描述其属性的数据以及对这些数据施加的一组操作封装在一起构成的统一体。
对象可以认为是：数据+操作在面向对象程序设计中，类就是具有相同的数据和相同的操作的一组对象的集合，也就是说，类是对具有相同数据结构和相同操作的一类对象的描述。
类和对象之间的关系是抽象和具体的关系。
类是多个对象进行综合抽象的结果，一个对象是类的一个实例。
在面向对象程序设计中，总是先声明类，再由类生成对象。
类是建立对象的“摸板”，按照这个摸板所建立的一个个具体的对象，就是类的实际例子，通常称为实例。
[1_3]现实世界中的对象有哪些特征？请举例说明。
对象是现实世界中的一个实体，其具有以下一些特征：（1）每一个对象必须有一个名字以区别于其他对象。
（2）需要用属性来描述它的某些特性。
（3）有一组操作，每一个操作决定了对象的一种行为。
（4）对象的操作可以分为两类：一类是自身所承受的操作，一类是施加于其他对象的操作。
例如：雇员刘名是一个对象对象名：刘名对象的属性：年龄：36 生日：1966.10.1 工资：2000 部门：人事部对象的操作：吃饭开车[1_4]什么是消息？消息具有什么性质？在面向对象程序设计中，一个对象向另一个对象发出的请求被称为“消息”。
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。
运算符重载自考习题
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.写出下面程序的输出结果。
类和对象与运算符重载 - 答案
选择题1、若有以下说明，在类外使用对象objx成员的正确语句是（）。
class X{ int a;void fun1();public:void fun2();};A objx.a=0B objx.fun1();C objx.fun2();D X::fun1();2、若有以下说明，对n的正确访问语句是（）。
class Y{ //………;public:static int n;};int Y::n=0;Y objy;A n=1;B Y::n=1;C objy::n=1;D Y->n=1;3、若有以下类Z的说明，函数fstatic的正确定义是（）。
class Z{ int a;public:void fstatic(Z &)static;};A void Z::fstatic(Z &objz){objz.a=0;}B void Z::fs tatic(Z &objz){a=objz.a;}C void Z::fstatic(Z &objz){a=0;}D void Z::fstatic(Z &objz){Z::a=0;}4、若有以下类T的说明，函数ffriend的错误定义是（）。
class T{ int i;friend void ffriend(T &,int);};A void ffriend(T &objt,int k){objt.i=k;}B void ffriend(T &objt,int k){k=objt.i;}C void T::ffriend(T &objt,int k){K+=objt.i;}D void ffriend(T &objt,int k){objt.i+=k;}5、在类定义的外部，可以被访问的成员有（）。
A 所有类成员B 私有或保护类成员C公有的类成员 D 公有或私有的类成员6、关于this指针的说法正确的是（）。
二级复习题7 运算符重载
运算符重载1.以下程序的执行结果是( )#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( );}A.n=8B.n=10C.12D.n=52.以下不属于运算符重载应注意的问题是( )A.重载的运算符应保持其原有的基本语义B.重载的运算符应尽可能保持其原有的特性C.运算符的重载尽量不配套D.使用引用参数还是非引用函数3以下程序的执行结果是________.#include <iostream.h>int add(int x,int y){return x+y;}int add(int x,int y,int z){return x+y+z;}void main( ){ int a=4,b=6,c=10;cout<<add(a,b)<< “,”<<add(a,b,c)<<endl;}4.运算符如果作为成员函数重载时不得重载为静态函数,但( )除外.A.=和[ ]B.new和=C.new和deleteD.->和>5.以下程序的执行结果( )#include <iostream.h>class Sample{ int n;public:Sample(int i){n=i;}operator ++( ){n++;return n;} //前缀重载运算符operator ++(int) {n+=2;return n;} //后缀重载运算符void disp( ){cout<< "n="<<n<<endl;}};void main( ){ Sample A(2),B(2);A++;//调用后缀重载运算符++B;//调用前缀重载运算符A.disp( );B.disp( );}A.n=4B.n=1C.n=3D.n=5n=3 n=2 n=4 n=66.以下程序的执行结果________.#include <iostream.h>class Sample{ int n;public: Sample( ){}Sample(int i){n=i;}friend Sample operator – (Sample &,Sample &); friend Sample operator + (Sample &,Sample &); void disp( ){cout<< “n=”<<n<<endl;}};Sample operator – (Sample &s1,Sample &s2){int m=s1.n-s2.n;return Sample(m);}Sample operator+(Sample &s1,Sample &s2){int m=s1.n+s2.n;return Sample(m);}void main( ){ Sample s1(10),s2(20),s3;s3=s2-s1;s3.disp( );s3=s1+s2;s3.disp( );}。
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++给学生习题第7章练习题
第7章练习题同步练习7.1一、选择题1．在下列运算符中，不能重载的是（）。
（A）! （B）sizeof （C）new （D）delete2．在下列关于运算符重载的描述中，（）是正确的。
（A）可以改变参与运算的操作数个数（B）可以改变运算符原来的优先级（C）可以改变运算符原来的结合性（D）不能改变原运算符的语义3．运算符函数是一种特殊的（）或友元函数。
（A）构造函数（B）析构函数（C）成员函数（D）重载函数4．设op表示要重载的运算符，那么重载运算符的函数名是（）。
（A）operatorop （B）op （C）函数标识符（D）函数标识符op5．用于类运算的运算符通常都要重载。
但有两个运算符系统提供默认重载版本，它们是（）。
（A）->和. （B）++和--（C）=和& （D）new和delete 【解答】 B D C A C同步练习7.2一、选择题1．在下列函数中，不能重载运算符的函数是（）。
（A）成员函数（B）构造函数（C）普通函数（D）友元函数2．在下列运算符中，要求用成员函数重载的运算符是（）。
（A）= （B）== （C）<= （D）++3．在下列运算符中，要求用友元函数重载的运算符是（）。
（A）= （B）[] （C）<< （D）()4．如果希望运算符的操作数（尤其是第一个操作数）有隐式转换，则重载运算符时必须用（）。
（A）构造函数（B）析构函数（C）成员函数（D）友元函数5．当一元运算符的操作数，或者二元运算符的左操作数是该类的一个对象时，重载运算符函数一般定义为（）。
（A）构造函数（B）析构函数（C）成员函数（D）友元函数【解答】 B A C D C二、程序练习1．阅读程序，写出运行结果。
#include <iostream>using namespace 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 ): " <<"a = "<<a<<'\t'<<"b = "<<b<<'\t'<<"c = "<<c<<'\n';(obj2*obj3).get( a, b, c );cout<<"( obj2*obj3 ): " <<"a = "<<a<<'\t'<<"b = "<<b<<'\t'<<"c = "<<c<<'\n';}【解答】2．阅读程序，写出运行结果。
实验七-运算符重载参考答案
实验七-运算符重载参考答案实验七多态性—函数与运算符重载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;}问题一：①处的运算符重载，为什么该函数的返回值要设计成CComplex类型？答：因为在函数中return obj2,obj2是CComplex 类型，所以函数返回值要与return返回的类型相同，即设计成CComplex类型。
问题二：②处的运算符重载函数调用就相当于“obj=operator+(obj1,obj2);”，但是为什么CComplex类中的运算符重载函数只设计了一个参数？答：因为成员函数经编译后会产生this指针，this指针会指向调用该函数的obj1对象，该obj1对象就是就相当于函数的第一个参数。
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行都没有错误八、以下表达正确的选项是（）。
《C++程序设计》电子教案第7章 运算符重载
7.1 7.2 7.3 7.4 7.5 运算符重载概述 运算符重载的实现 一元运算符重载 二元运算符重载 特殊运算符重载
7.1 运算符重载概述
运算符重载是对已有的运算符赋予多重含义， 运算符重载是对已有的运算符赋予多重含义， 同一个运算符作用于不同类型的数据导致不同 类型的行为。 类型的行为。 运算符重载的实质就是函数重载。 运算符重载的实质就是函数重载。在实现过程 中，首先把指定的运算表达式转化为对运算符 函数的调用， 函数的调用，运算对象转化为运算符函数的实 参，然后根据实参的类型来确定需要调用的函 这个过程是在编译过程中完成的。 数，这个过程是在编译过程中完成的。
返回首页
算符有前缀和后缀两 如同 “ ++ ” 运 算符有前缀和 后缀两 种 使用形式 一样 ， 运算符有前缀和后缀两 种使用形式 “++”和“--”重载运算符也有前缀和后缀两种运算符 ” ” 重载形式， 重载形式 ， 以 “ ++” 重载运算符为例 ， 其语法格式如 ” 重载运算符为例， 下： <函数类型 operator ++（）; 函数类型> （ //前缀运算 前缀运算 函数类型 <函数类型 operator ++（int）; //后缀运算 函数类型> 函数类型 （ ） 后缀运算 使用前缀运算符的语法格式如下： 使用前缀运算符的语法格式如下： ++<对象 对象>; 对象 使用后缀运算符的语法格式如下： 使用后缀运算符的语法格式如下： <对象 对象>++; 对象
static char* str; String String::operator+(const String& a) { strcpy(str,name); strcat(str,); return String(str); } void main() { str=new char[256]; String demo1("Visual c++"); String demo2("6.0"); demo1.display(); demo2.display();
C++给学生习题集第7章练习题集
第7章练习题同步练习7.1一、选择题1．在下列运算符中，不能重载的是（）。
（A）! （B）sizeof （C）new （D）delete2．在下列关于运算符重载的描述中，（）是正确的。
（A）可以改变参与运算的操作数个数（B）可以改变运算符原来的优先级（C）可以改变运算符原来的结合性（D）不能改变原运算符的语义3．运算符函数是一种特殊的（）或友元函数。
（A）构造函数（B）析构函数（C）成员函数（D）重载函数4．设op表示要重载的运算符，那么重载运算符的函数名是（）。
（A）operatorop （B）op （C）函数标识符（D）函数标识符op5．用于类运算的运算符通常都要重载。
但有两个运算符系统提供默认重载版本，它们是（）。
（A）->和. （B）++和--（C）=和& （D）new和delete 【解答】 B D C A C同步练习7.2一、选择题1．在下列函数中，不能重载运算符的函数是（）。
（A）成员函数（B）构造函数（C）普通函数（D）友元函数2．在下列运算符中，要求用成员函数重载的运算符是（）。
（A）= （B）== （C）<= （D）++3．在下列运算符中，要求用友元函数重载的运算符是（）。
（A）= （B）[] （C）<< （D）()4．如果希望运算符的操作数（尤其是第一个操作数）有隐式转换，则重载运算符时必须用（）。
（A）构造函数（B）析构函数（C）成员函数（D）友元函数5．当一元运算符的操作数，或者二元运算符的左操作数是该类的一个对象时，重载运算符函数一般定义为（）。
（A）构造函数（B）析构函数（C）成员函数（D）友元函数【解答】 B A C D C二、程序练习1．阅读程序，写出运行结果。
#include <iostream>using namespace 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 ): " <<"a = "<<a<<'\t'<<"b = "<<b<<'\t'<<"c = "<<c<<'\n';(obj2*obj3).get( a, b, c );cout<<"( obj2*obj3 ): " <<"a = "<<a<<'\t'<<"b = "<<b<<'\t'<<"c = "<<c<<'\n';}【解答】2．阅读程序，写出运行结果。
运算符重载综合练习题
运算符重载练习题一、选择题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、在成员函数中进行双目运算符重载时，其参数表中应带有（）个参数。
课本答案
cout << d << endl; // 输出日期
system("PAUSE"); // 调用库函数system( )，输出系统提示信息
return 0; // 返回值, 返回操作系统
}
*3．设计一个时间类Time，要求：
using namespace std; // 使用命名空间std
// 声明复数类
class Complex
{
private:
// 数据成员
double real; // 实部
double image; // 虚部
……
1．定义一个复数类Complex，重载运算符“+”，“-”，“*”，使之能用于复数的加、减、乘。编程序，分别求两个复数之和、差与积。
……
int main() // 主函数main()
{
Complex z1(2, 3), z2(6, -5), z3; // 定义复数对象
z1.Show(); // 输出z1
z2.Show(); // 输出z2
z3 =z1 + z2; // z3=z1+z2
答案：B
填空题
1．若以非成员函数形式为类MyClass重载“！”运算符，其操作结果为一个bool型数，则该运算符重载函数的原型是 。
解析：以非成员函数形式重载一元运算符“!”，一定含有一个参数，此处为类MyClass的常引用。
答案：bool operator!( const MyClass &);
（1）包含时(hour)、分(minute)和秒(second)私有数据成员。
【练习】C给学生习题第7章练习题
【关键字】练习第7章练习题同步练习7.1一、选择题1．在下列运算符中，不能重载的是（）。
（A）! （B）sizeof （C）new （D）delete2．在下列关于运算符重载的描述中，（）是正确的。
（A）可以改变参与运算的操作数个数（B）可以改变运算符原来的优先级（C）可以改变运算符原来的结合性（D）不能改变原运算符的语义3．运算符函数是一种特殊的（）或友元函数。
（A）构造函数（B）析构函数（C）成员函数（D）重载函数4．设op表示要重载的运算符，那么重载运算符的函数名是（）。
（A）operator op （B）op （C）函数标识符（D）函数标识符op5．用于类运算的运算符通常都要重载。
但有两个运算符系统提供默认重载版本，它们是（）。
（A）->和. （B）++和-- （C）=和& （D）new和delete 【解答】 B D C A C同步练习7.2一、选择题1．在下列函数中，不能重载运算符的函数是（）。
（A）成员函数（B）构造函数（C）普通函数（D）友元函数2．在下列运算符中，要求用成员函数重载的运算符是（）。
（A）= （B）== （C）<= （D）++3．在下列运算符中，要求用友元函数重载的运算符是（）。
（A）= （B）[] （C）<< （D）( )4．如果希望运算符的操作数（尤其是第一个操作数）有隐式转换，则重载运算符时必须用（）。
（A）构造函数（B）析构函数（C）成员函数（D）友元函数5．当一元运算符的操作数，或者二元运算符的左操作数是该类的一个东西时，重载运算符函数一般定义为（）。
（A）构造函数（B）析构函数（C）成员函数（D）友元函数【解答】 B A C D C二、程序练习1．阅读程序，写出运行结果。
#include <iostream>using namespace 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 ): " <<"a = "<<a<<'\t'<<"b = "<<b<<'\t'<<"c = "<<c<<'\n';(obj2*obj3).get( a, b, c );cout<<"( obj2*obj3 ): " <<"a = "<<a<<'\t'<<"b = "<<b<<'\t'<<"c = "<<c<<'\n';}【解答】2．阅读程序，写出运行结果。
运算符重载、继承、派生程序题与答案
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的字符序列，即用一个字符数组来存放这个二进制数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《面向对象程序设计》习题班级：学号：姓名：名单序号：成绩：第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. 下列运算符中哪些是不能够被重载的（）。
A. .，.*，sizeof，：：，?:B. ++，--，new，= =C. new，delete，>=，[ ]D. +，-，=，delete10. 在名为BigNumber类的类体中对运算符函数double进行如下声明：operator double(BigNumbe);函数声明中有一个明显的错误，这个错误就是（）。
A．参数表中不应该有任何参数B．缺少对函数返回类型的说明C．参数声明中缺少参数变量D．函数声明中缺少函数体11. 下列关于运算符重载的描述中，正确的是（）。
A. 运算符重载成为成员函数时，若参数表中无参数，重载是一元运算符B. 一元运算符只能作为成员函数重载C. 二元运算符重载成为非成员函数时，参数表中有一个参数D. C++中可以重载所有的运算符12. 在语句“cout<<’A’”中，cout是（）。
A. 类名B. 函数名C. 对象名D. C++的关键字13．下面是重载为非成员函数的运算符的函数原型，其中错误的是（）。
A．Fraction operator +（Fraction, Fraction）B．Fraction& operator =（Fraction&, Fraction）C．Fraction operator -（Fraction，Fraction）D．Fraction& operator *（Fraction, Fraction）14. 下列关于运算符重载的描述中，错误的是（）。
A. 运算符重载不能改变操作数的个数、优先级、结合性和运算符的语法结构B. 所有的运算符都可以重载C. 运算符函数的调用必须使用关键字operatorD. 在C++语言中不可以通过运算符重载创造出新的运算符15. 如果表达式a>=b，中的“>=”是作为非成员函数重载的运算符，则可以等效地表示为（）。
A. a.operator>=(b)B. a.operator>=(a)C. operator>=(a, b)D. a.operator>=(b, a)16. 下列有关运算符函数的描述中，错误的是（）。
A. 运算符函数的名称总是以operator为前缀的B. 运算符函数的参数可以是对象C. 运算符函数只能定义为类的成员函数D. 在表达式中使用重载的运算符相当于调用运算符重载函数17. 将前缀运算符“--”重载为非成员函数，下列原型中，正确的是（）。
A. Decr &operator- - (int);B. Decr operator- - (Decr &, int);C. friend Decr &operator- - (Decr &, int);D. friend Decr &operator- - (Decr &); 18．下列关于C++预定义流对象的叙述中，正确的是（）。
A．cin是C++预定义的标准输入流对象B．cin是C++预定义的标准输入流类C．cout是C++预定义的标准输入流对象D．cout是C++预定义的标准输入流类19．有如下类定义class MyClass{ public:________________________private:int data;};若要为MyClass类重载流输入运算符“>>”，使得程序中可以用“cin>>obj;”的形式改变MyClass 类的对象obj中数据成员data的值，则在下划线处的声明语句应为（）。
A．friend istream& operator>>(istream& is, MyClass &a);B．friend istream& operator>>(istream& is, MyClass a);C．istream& operator>>(istream& is, MyClass &a);D．istream& operator>>(istream& is, MyClass a);20．若要在Viz类中将*重载为一元运算符，下列重载函数声明中肯定有错的是（）。
A．Viz operator *();B．Viz operator *(Viz);C．int operator *(Viz);D．Viz operator *(Viz, Viz);21．已知一运算符函数没有参数，下列关于该运算符函数的表述中错误的是（）。
A．该运算符函数是成员函数B．该运算符是一元运算符C．由于无参数，使用该运算符时不需要操作数D．该运算符不是后缀++或后缀--22．现需要将Matrix类对象使用的关系运算符“==”重载为成员函数，用于判断两个对象是否相等，以下正确且合理的函数声明是（）。
A．Matrix& operator==(const Matrix &a);B．Matrix operator==(const Matrix &a);C．bool& operator==(const Matrix &a);D．bool operator==(const Matrix &a);23. 关于赋值运算符=的重载，下列表述中错误的是（）。
A．=的重载函数必须且只能有一个参数B．一个类即使没有重载=，也可以用=为该类的对象赋值C．为了实现像“x=y=z;”这样的连续赋值，=的重载函数的返回值必须声明为引用D．=可以重载为一个类的友元函数24．下列运算符中，可以重载为类的友元函数的运算符是（）。
A．= B．( ) C．. D．<<25．有如下类的定义：class MyClass{public:MyClass(double d=0.0):val(d){ }//类型转换运算符double的定义private:double val;};若要使下列语句序列能够正常运行，下划线处的语句应为（）。
MyClass x(2.1);cout<<double(x);A．operator double() const {return val;}B．friend operator double() const {return val;}C．double operator () const {return val;}D．friend double operator () const {return val;}26．若为类MyClass重载运算符“+”，下列声明中，错误的是（）。
A．friend MyClass operator+(double, double);B．friend MyClass operator+(double, MyClass);C．friend MyClass operator+(MyClass, double);D．friend MyClass operator+(MyClass, MyClass);27．下列关于运算符重载的叙述中，正确的是（）。
A．运算符重载的作用是使已有的运算符作用于类的对象B．通过运算符重载机制可以为C++语言扩充新的运算符C．重载运算符的操作类型可以全部为基本类型D．C++中已有的任何运算符都可以重载28. 运算符重载时以下性质一定会保持的是（）。
A．返回值类型、操作数类型B．操作数类型、优先级C．优先级、操作数个数D．返回值类型、结合性29．下列关于运算符重载的描述中错误的是（）。
A．不能通过运算符重载在C++中创建新的运算符B．赋值运算符=只能重载为成员函数C．运算符函数重载为类的成员函数时，第一操作数是该类对象D．重载类型转换运算符时，应声明返回值为void30．重载流插入运算符<<时，下列做法不合理的是（）。
A．将运算符函数的返回值类型设为ostream &B．将运算符函数的第一个参数设为ostream &C．为运算符函数设置两个参数D．将运算符定义为类的成员函数二、填空题（共28分，每空1分）1．利用成员函数对二元运算符重载，其左操作数为，右操作数为。
2．对双目运算符而言，成员运算符函数带有参数，而友元运算符函数带有参数；对单目运算符而言，成员运算符函数参数，而友元运算符函数带参数。
3．重载运算符的函数不能有参数，否则就改变了运算符参数的个数。
4．对于用户自定义的类类型与其他数据类型之间的转换，通常有两种方法：通过进行类型转换；通过进行类型转换。
5．运算符重载函数一般采用两种形式：一是；二是。