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++的运算符，⽀持的数据类型，仅限于基本数据类型。

问题：⼀头⽜+⼀头马 = ？（⽜马神兽？）⼀个圆 +⼀个圆 = ？（想要变成⼀个更⼤的圆）⼀头⽜ – ⼀只⽺ = ？ (想要变成4只⽺，原始的以物易物：1头⽜价值5只⽺)解决⽅案：使⽤运算符重载⽅式⼀, 使⽤成员函数重载运算符需求：把⽜⾁换猪⾁, ⽺⾁换猪⾁规则：⼀⽄⽜⾁：2⽄猪⾁⼀⽄⽺⾁：3⽄猪⾁实现:⽜ + ⽜ = ?猪⾁⽜ + ⽺ = ?猪⾁Cow类> Cow.h#pragma onceclass Pork;class Sheep;class Cow{ //⽜类public:Cow(int weight = 0);//使⽤运算符重载, 实现⽜⾁ + ⽜⾁ = 猪⾁Pork operator+(const Cow& cow);//使⽤运算符重载, 实现⽜⾁ + ⽺⾁ = 猪⾁Pork operator+(const Sheep& sheep);private:int weight; //重量};_________________________________________________________________________________________________________________________________ > Cow.cpp#include "Cow.h"#include "Pork.h"#include "Sheep.h"Cow::Cow(int weight){this->weight = weight;}//⼀⽄⽜⾁换两⽄猪⾁Pork Cow::operator+(const Cow& cow){return Pork((this->weight + cow.weight) * 2);}//⼀⽄⽜⾁换两⽄猪⾁, ⼀⽄⽺⾁换三⽄猪⾁Pork Cow::operator+(const Sheep& sheep){int tmp = (this->weight * 2) + (sheep.getWeight() * 3);return Pork(tmp);}Sheep类> Sheep.h#pragma once//⽺类class Sheep{public:Sheep(int weight = 0);int getWeight() const;private:int weight; //重量};_________________________________________________________________________________________________________________________________ > Sheep.cpp#include "Sheep.h"Sheep::Sheep(int weight){this->weight = weight;}int Sheep::getWeight() const{return weight;}Pork类> Pork.h#pragma once#include <string>using namespace std;class Pork{ //猪⾁类public:Pork(int weight = 0);string description() const;private:int weight;};_________________________________________________________________________________________________________________________________ > Pork.cpp#include <sstream>#include "Pork.h"Pork::Pork(int weight){this->weight = weight;}string Pork::description() const{stringstream ret;ret << this->weight << "⽄";return ret.str();}main.cpp#include <iostream>#include <Windows.h>#include "Cow.h"#include "Pork.h"#include "Sheep.h"using namespace std;int main(void) {Pork p1;Cow c1(100);Cow c2(200);Sheep s1(100);//调⽤运算符重载 Pork operator+(const Cow& cow);p1 = c1 + c2;cout << "⽜ + ⽜ = 猪⾁:" << p1.description() << endl;//调⽤运算符重载 Pork operator+(const Sheep& c1);p1 = c1 + s1;cout << "⽜ + ⽺ = 猪⾁:" << p1.description() << endl;//⽺+⽜会报错, 因为没有定义对应的⽺+⽜运算符重载//p1 = s1 + c1;system("pause");return 0;}⽅式⼆, 使⽤⾮成员函数【友元函数】重载运算符实现:⽜ + ⽜ = ?猪⾁⽜ + ⽺ = ?猪⾁Cow类> Cow.h#pragma onceclass Pork;class Sheep;class Cow{ //⽜类public:Cow(int weight = 0);//使⽤友元运算符重载, 实现⽜⾁ + ⽜⾁ = 猪⾁friend Pork operator+(const Cow& c1, const Cow& c2);//使⽤友元运算符重载, 实现⽜⾁ + ⽺⾁ = 猪⾁friend Pork operator+(const Cow& c1, const Sheep& s1);private:int weight; //重量};_________________________________________________________________________________________________________________________________ > Cow.cpp#include "Cow.h"Cow::Cow(int weight){this->weight = weight;}Sheep类> Sheep.h#pragma once//⽺类class Sheep{public:Sheep(int weight = 0);int getWeight() const;private:int weight; //重量};_________________________________________________________________________________________________________________________________ > Sheep.cpp#include "Sheep.h"Sheep::Sheep(int weight){this->weight = weight;}int Sheep::getWeight() const{return weight;}Pork类> Pork.h#pragma once#include <string>using namespace std;class Pork{ //猪⾁类public:Pork(int weight = 0);string description() const;private:int weight;};_________________________________________________________________________________________________________________________________ > Pork.cpp#include <sstream>#include "Pork.h"Pork::Pork(int weight){this->weight = weight;}string Pork::description() const{stringstream ret;ret << this->weight << "⽄";return ret.str();}main.cpp#include <iostream>#include <Windows.h>#include "Cow.h"#include "Pork.h"#include "Sheep.h"using namespace std;//要想访问类的私有数据成员, 就把这个函数定义为友元Pork operator+(const Cow& c1, const Cow& c2) {return ((c1.weight + c2.weight) * 2);}//要想访问类的私有数据成员, 就把这个函数定义为友元Pork operator+(const Cow& c1, const Sheep& s1) {return((c1.weight * 2) + (s1.getWeight() * 3));}int main(void) {Pork p1;Cow c1(100); //100⽄的⽜Cow c2(200); //200⽄的⽜Sheep s1(100); //100⽄的⽺//调⽤ friend Pork operator+(const Cow& c1, const Cow& c2);p1 = c1 + c2;cout << "使⽤友元⽜ + ⽜ = 猪⾁:" << p1.description() << endl;//调⽤ friend Pork operator+(const Cow& c1, const Sheep& s1);p1 = c1 + s1;cout << "使⽤友元⽜ + ⽺ = 猪⾁:" << p1.description() << endl;system("pause");return 0;}两种⽅式的区别区别：使⽤成员函数来实现运算符重载时，少写⼀个参数，因为第⼀个参数就是this指针。

国家二级C++机试（运算符重载、模板和C++流）模拟试卷1(总分：58.00，做题时间：90分钟)一、选择题(总题数：29，分数：58.00)1.运算符重载是对已有的运算符赋予多重含义，因此( )。

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

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

2.关于运算符重载，下列表述中正确的是( )。

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

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

3.通过运算符重载，可以改变运算符原有的( )。

（分数：2.00）A.操作数类型√B.操作数个数C.优先级D.结合性解析：解析：此题考查的是运算符重载。

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

故本题选项A正确。

4.下列运算符中，不能被重载的是( )。

（分数：2.00）A.&&B.!=C.．√D.++解析：解析：此题考查的是运算符重载。

在C++中，只有.、*、-＞*、：：、?：这五个运算符不能重载。

5.下列关于运算符重载的描述中，正确的是( )。

国家二级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解析：在重载类型转换符时，由于运算符本身已经表示出返回值类型，因此不需要返回值类型的声明。

运算符重载一．单项选择题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 的形式上看，这是利用________函数实现__________运算符的重载。

实验七-运算符重载参考答案实验七多态性—函数与运算符重载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对象就是就相当于函数的第一个参数。

一、选择题一、下面关于运算符重载的说法中，错误的选项是（）。

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

第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++中的运算符重载练习题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，包含年、⽉、⽇三个数据成员友元函数重载⾃增运算符（++），实现⽇期的⾃增。

A(int v1)(v1) { f( ); }public: A(int v1)(v1) {}M(1, M(2, 3, M(4,5,6,7), ,9 ,10)一、单选1.C2.D3.D4.C5.B6.D7.A8.C9.B 10.D二、多选1. ABC2. ACD3. ABD4. AC5. BCD三、判断对错1. 对2. 错如可有两个成员函数,int f();和int f() const;3. 错是否真正内联，由编译器决定。

如函数是递归函数，那么永远不会内联。

4. 对5. 错可通过类的静态成员函数创建实例，如单件模式。

6. 对7. 错如可通过继承自基类的成员函数访问基类中的x.8. 错友员关系不具有传递性。

9. 对10.对四、写结果。

目的是考察虚函数的调用，包括普通成员函数中调用其它虚函数和在构造、析构函数中只会调用虚函数的本地版本。

五、写结果。

是一个使用Handle类进行引用计数的例子。

六、回答问题1. 重点是基类中的任何Private在派生类中都是不可访问的。

2. 可在A类中定义一个构造函数：A(const B&);或在B类中定义一个自动转换函数：operator A( ) const;3. 只有纯虚函数、非静态的成员函数可以是常量成员函数。

(这题有点问题，析构函数可以是纯虚函数，但不能是常量函数)4. 如类A中有函数int f(void);和int f(int);为重载(overload) (同名，参数不同)如类A中有函数int f(void);，A的派生类B中给int f(void)一个新的实现体，为redefine如类A中有虚函数virtual int f(void);,A的派生类B中给virtual int f(void)一个新的实现体,为override.5. A(const A& one ).当调用此拷贝构造函数时，需将参数压栈，若不使用&，就需要在栈内创建一个one的副本，而这需要用拷贝构造函数。

国家二级C++机试（运算符重载）模拟试卷2(题后含答案及解析) 题型有：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解析：此题考查的是运算符的重载。

习题13答案一、简答题1．什么是运算符重载？实现运算符重载有几种方法？如何实现？答案：运算符重载机制能够实现将已有运算符应用到新的数据类型上，赋予运算符新的含义。

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

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

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

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

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

见13.2.2节。

2．如何实现本类对象与其它类对象之间的相互类型转换？答案：使用运算符重载中的“类型转换函数”将本类对象转换成其他类对象。

使用“构造函数”将其他类对象转换成本类对象。

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

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

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

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

静态多态也称为编译时多态。

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

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

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

在抽象类中，有时无法实现某一功能（即无法给出某一函数的具体实现），可以将实现该功能的函数定义成纯虚函数。

虚函数具有函数实现的函数体，而纯虚函数一般没有函数体，即没有函数实现。

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

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

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

虚基类用于实现在多重继承情况下基类同名成员在派生类中的访问二义性问题。

如果基类是虚基类，则同名数据成员在派生类中只保留一个副本，见12.6节。

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(题后含答案及解析) 题型有：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解析：本题主要是对运算符霞载的考查。

运算符重载基础概念练习题2运算符重载基础概念练习题1.在下列运算符中，（c）运算符在c++中不能重载。

a=b（）c:：D删除2、下列运算符中,（a）运算符在c++中不能重载。

a?:b[]cnewd&&3.在下面对C++运算符函数的返回类型的描述中，错误为（C）。

a可以是类类型b可以是int类型c可以是void类型d可以是float类型4.以下运算符不能用友元函数is（b）重载。

a+b=c*d<<5.重载运算符函数时，以下运算符（d）必须作为类成员函数重载。

a+b-c++d->6.在以下关于操作员过载的描述中，正确的描述是（d）。

a运算符重载可以改变运算符的操作数的个数b运算符重载可以改变优先级c运算符重载可以改变结合性D运算符重载无法更改语法结构7、友元运算符obj>obj2被c++编译器解释为（a）。

aoperator>(obj1,obj2)b>(obj1,obj2)cobj2。

操作员>（obj1）dobj1。

oprator>（obj2）8、在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。

下列叙述中正确的是（c）。

A operator+有两个参数，operator*有两个参数，B operator+有两个参数，operator*有一个参数，copier+有一个参数，operator*有两个参数，DopOperator+有一个参数，operator*有一个参数9、重载赋值操作符时,应声明为（c）函数。

朋友B虚拟C成员D多态性10、在一个类中可以对一个操作符进行（d）重载。

A1物种B2物种低于C3物种低于D物种11、在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（b）。

a、一元运算符重载为友元函数B.一元运算符重载为成员函数C.二元运算符重载为友元函数D.二元运算符重载为成员函数12、在成员函数中进行双目运算符重载时，其参数表中应带有（b）个参数。