C++中预定义的运算符的操作对象只能是基本数据类型，实际上，对于很多用户自定义类型，也需要有类似的运算操作。例如：
class complex
{
public:
complex(double r=0.0,double I=0.0){real=r;imag=I;}
void display();
private:
double real;
double imag;
};
complex a(10,20),b(5,8);
“a+b”运算如何实现？这时候我们需要自己编写程序来说明“+”在作用于complex类对象时，该实现什么样的功能，这就是运算符重载。运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。
运算符重载的实质是函数重载。在实现过程中，首先把指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参，然后根据实参的类型来确定需要调用达标函数，这个过程爱编译过程中完成。
一、运算符重载的规则
运算符重载规则如下：
①、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。
②、重载之后运算符的优先级和结合性都不会改变。
③、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。
不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。
运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。
运算符重载为类的成员函数的一般语法形式为：
函数类型 operator 运算符（形参表）
{
函数体；
}
运算符重载为类的友元函数的一般语法形式为：
friend 函数类型 operator 运算符（形参表）
{
函数体；
}
其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。
当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类
的友元函数时，参数个数与原操作数个数相同。原因是重载为类的成员函数时，如果某个对象使用重载了的成员函数，自身的数据可以直接访问，就不需要再放在参数表中进行传递，少了的操作数就是该对象本身。而重载为友元函数时，友元函数对某个对象的数据进行操作，就必须通过该对象的名称来进行，因此使用到的参数都要进行传递，操作数的个数就不会有变化。
运算符重载的主要优点就是允许改变使用于系统内部的运算符的操作方式，以适应用户自定义类型的类似运算。
二、运算符重载为成员函数
对于双目运算符B，如果要重载B为类的成员函数，使之能够实现表达式oprd1 B oprd2,其中oprd1为类A的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载后，表达式oprd1 B oprd2 就相当于函数调用
oprd1.operator B(oprd2).
对于前置单目运算符U，如“-”（负号）等，如果要重载U为类的成员函数，用来实现表达式U oprd，其中oprd为A类的对象，则U应当重载为A类的成员函数，函数没有形参。经过重载之后，表达式U oprd相当于函数调用oprd.operator U().
对于后置运算符“++”和“- -”，如果要将它们重载为类的成员函数，用来实现表达式oprd++或oprd--，其中oprd为A类的对象，那么运算符就应当重载为A类的成员函数，这时函数要带有一个整型形参。重载之后，表达式oprd++和oprd—就想当于函数调用oprd.operator++(0)和oprd.operator—(0);
运算符重载就是赋予已有的运算符多重含义。通过重新定义运算符，使它能够用于特定类的对象执行特定的功能，这便增强了C++语言的扩充能力。
1. 运算符重载的作用:
运算符重载允许C/C++的运算符在用户定义类型(类)上拥有一个用户定义的意义。重载的运算符是函数调用的语法修饰：
class Fred
{
public:
// ...
};
#if 0
// 没有算符重载：
Fred add(Fred, Fred);
Fred mul(Fred, Fred);
Fred f(Fred a, Fred b, Fred c)
{
return add(add(mul(a,b), mul(b,c)), mul(c,a)); // 哈哈，多可笑...
}
#else
// 有算符重载：
Fred operator+ (Fred, Fred);
Fred operator* (Fred, Fred);
Fred f(Fred a, Fred b, Fred c)
{
return a*b + b*c + c*a;
}
#endif
2. 可以用作重载的运算符:
算术运算符：+,-,*,/,%,++,--;
位操作运算符：&,|,~,^,＜＜,＞＞
逻辑运算符：!,&&,||;
比较运算符：＜,＞,＞=,＜=,==,!=;
赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*。
下列运算符不允许重载：
.,.*,::,?:
3. 运算符重载后，优先级和结合性:
用户重载新定义运算符，不改变原运算符的优先级和结合性。这就是说，对运算符重载不改变运算符的优先级和结合性，并且运算符重载后，也不改变运算符的语法结构，即单目运算符只能重载为单目运算符，双目运算符只能重载双目运算符。
4. 编译程序如何选用哪一个运算符函数:
运算符重载实际是一个函数，所以运算符的重载实际上是函数的重载。编译程序对运算符重载的选择，遵循着函数重载的选择原则。当遇到不很明显的运算时，编译程序将去寻找参数相匹配的运算符函数。
5. 重载运算符有哪些限制:
(1) 不可臆造新的运算符。必须把重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中。
(2) 重载运算符坚持4个“不能改变”。
·不能改变运算符操作数的个数；
·不能改变运算符原有的优先级；
·不能改变运算符原有的结合性；
·不能改变运算符原有的语法结构。
6. 运算符重载时必须遵循哪些原则:
运算符重载可以使程序更加简洁，使表达式更加直观，增加可读性。但是，运算符重载使用不宜过多，否则会带来一定的麻烦。
(1) 重载运算符含义必须清楚。
(2) 重载运算符不能有二义性。
运算符重载函数的两种形式
运算符重载的函数一般地采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。
1. 重载为类的成员函数
这里先举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码：
#include ＜iostream.h＞
class complex
{
public:
complex() { real=imag=0; }
complex(double r, double i)
{
real = r, imag = i;
}
complex operator +(const complex &c);
complex operator -(const complex &c);
complex operator *(const complex &c);
complex operator /(const complex &c);
friend void print(const complex &c);
private:
double real, imag;
};
inline complex complex::operator +(const complex &c)
{
return complex(real + c.real, imag + c.imag);
}
inline complex complex::operator -(const complex &c)
{
return complex(real - c.real, imag - c.imag);
}
inline complex complex::operator *(const complex &c)
{
return complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
}
inline complex complex::operator /(const complex &c)
{
return complex((real * c.real + imag + c.imag) / (c.real * c.real + c.imag * c.imag), (imag * c.real - real * c.imag) / (c.real * c.real + c.imag * c.imag));
}
void print(const complex &c)
{
if(c.imag＜0)
cout＜＜c.real＜＜c.imag＜＜'i';
else
cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i';
}
void main()
{
complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
c3 = c1 + c2;
cout＜＜"\nc1+c2=";
print(c3);
c3 = c1 - c2;
cout＜＜"\nc1-c2=";
print(c3);
c3 = c1 * c2;
cout＜＜"\nc1*c2=";
print(c3);
c3 = c1 / c2;
cout＜＜"\nc1/c2=";
print(c3);
c3 = (c1+c2) * (c1-c2) * c2/c1;
cout＜＜"\n(c1+c2)*(c1-c2)*c2/c1=";
print(c3);
cout＜＜endl;
}
该程序的运行结果为：
c1+c2=6+1i
c1-c2=-2+5i
c1*c2=14+8i
c1/c2=0.45+0.8i
(c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i
在程序中，类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下：
＜类名＞operator ＜运算符＞(＜参数表＞)
其中，operator是定义运算符重载函数的关键字。
程序中出现的表达式：
c1+c2
编译程序将给解释为：
c1.operator+(c2)
其中，c1和c2是complex类的对象。operator+()是运算+的重载函数。
该运算符重载函数仅有一个参数c2。可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是this指针。this指针是指向调用该成员函数对象的指针。
2. 重载为友元函数:
运算符重载函数还可以为友元函数。当重载友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是：=,(),[]和-＞。
重载为友元函数的运算符重载函数的定义格式如下：
friend ＜类型说明符＞operator ＜运算符＞(＜参数表＞)
{……}
下面用友元函数代码成员函数，重载编写上述的例子，程序如下：
#include ＜iostream.h＞
class complex
{
public:
complex() { real=imag=0; }
complex(double r, double i)
{
real = r, imag = i;
}
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);
friend
void print(const complex &c);
double real, imag;
};
complex operator +(const complex &c1, const complex &c2)
{
return complex(c1.real + c2.real, c1.imag + c2.imag);
}
complex operator -(const complex &c1, const complex &c2)
{
return complex(c1.real - c2.real, c1.imag - c2.imag);
}
complex operator *(const complex &c1, const complex &c2)
{
return complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real); }
complex operator /(const complex &c1, const complex &c2)
{
return complex((c1.real * c2.real + c1.imag * c2.imag) / (c2.real * c2.real + c2.imag *
c2.imag),
(c1.imag * c2.real - c1.real * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag));
}
void print(const complex &c)
{
if(c.imag＜0)
cout＜＜c.real＜＜c.imag＜＜'i';
else
cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i';
}
void main()
{
complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
c3 = c1 + c2;
cout＜＜"\nc1+c2=";
print(c3);
c3 = c1 - c2;
cout＜＜"\nc1-c2=";
c3 = c1 * c2;
cout＜＜"\nc1*c2=";
print(c3);
c3 = c1 / c2;
cout＜＜"\nc1/c2=";
print(c3);
c3 = (c1+c2) * (c1-c2) * c2/c1;
cout＜＜"\n(c1+c2)*(c1-c2)*c2/c1=";
print(c3);
cout＜＜endl;
}
该程序的运行结果与上例相同。前面已讲过，对又目运算符，重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。因此，程序中出现的c1+c2
编译程序解释为：
operator+(c1, c2)
调用如下函数，进行求值，
complex operator +(const coplex &c1, const complex &c2)
3. 两种重载形式的比较
一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。其他运算符的重载举例
1).下标运算符重载
由于C语言的数组中并没有保存其大小，因此，不能对数组元素进行存取范围的检查，无法保证给数组动态赋值不会越界。利用C++的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符[]。
下面一个例子：
#include ＜iostream.h＞
class CharArray
{
public:
CharArray(int l)
{
Length = l;
Buff = new char[Length];
}
~CharArray() { delete Buff; }
int GetLength() { return Length; }
char & operator [](int i);
private:
int Length;
char * Buff;
};
char & CharArray::operator [](int i)
{
static char ch = 0;
if(i＜Length&&i＞=0)
return Buff[i];
else
{
cout＜＜"\nIndex out of range.";
return ch;
}
}
void main()
{
int cnt;
CharArray string1(6);
char * string2 = "string";
for(cnt=0; cnt＜8; cnt++)
string1[cnt] = string2[cnt];
cout＜＜"\n";
for(cnt=0; cnt＜8; cnt++)
cout＜＜string1[cnt];
cout＜＜"\n";
cout＜＜string1.GetLength()＜＜endl;
}
该数组类的优点如下：
(1) 其大小不一定是一个常量。
(2) 运行时动态指定大小可以不用运算符new和delete。
(3) 当使用该类数组作函数参数时，不心分别传递数组变量本身及其大小，因为该对象中已经保存大小。
在重载下标运算符函数时应该注意：
(1) 该函数只能带一个参数，不可带多个参数。
(2) 不得重载为友元函数，必须是非static类的成员函数。2). 重载增1减1运算符.
增1减1运算符是单目运算符。它们又有前缀和后缀运算两种。为了区分这两种运算，将后缀运算视为又目运算符。表达式
obj++或obj--
被看作为：
obj++0或obj--0
下面举一例子说明重载增1减1运算符的应用。
#include ＜iostream.h＞
class counter
{
public:
counter() { v=0; }
counter operator ++();
counter operator ++(int );
void print() { cout＜＜v＜＜endl; }
private:
unsigned v;
};
counter counter::operator ++()
{
v++;
return *this;
}
counter counter::operator ++(int)
{
counter t;
t.v = v++;
return t;
}
void main()
{
counter c;
for(int i=0; i＜8; i++)
c++;
c.print();
for(i=0; i＜8; i++)
++c;
c.print();
}
3). 重载函数调用运算符
可以将函数调用运算符()看成是下标运算[]的扩展。函数调用运算符可以带0个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。
#include ＜iostream.h＞
class F
{
public:
double operator ()(double x, double y) const;
};
double F::operator ()(double x, double y) const
{
return (x+5)*y;
}
void main()
{
F f;
cout＜＜f(1.5, 2.2)＜＜endl;
}
实验十三 1．实验目的 通过本次实验 （1）理解友元函数与运算符重载函数的概念； （2）学会友元函数的定义与使用方法； （3）掌握运算符重载函数的定义与使用方法； 2．实验要求 （1）编写实验程序 （2）在VC++运行环境中，输入源程序 （3）编译运行源程序 （4）输入测试数据进行程序测试； （5）写出运行结果。 3．实验内容 （1）定义一个复数类，重载“-=”运算符，使这个运算符能直接完成复数的“-=”运算。分别用成员函数与友元函数编写运算符重载函数。在主函数中定义复数对象c1(10,20)、c2(15,30)，进行c2-=c1的复数运算，并输出c1、c2的复数值。 参考资料： （1）成员函数 # include 运算符重载 一．单项选择题 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); }; 答案：D 7. 在第33题中，当执行语句d+=m; 时，C++编译器对语句作如下解释： (34) A. d=operator+=(m); B. m=operator+=(d); C. d.operator+=(m); D. m.operator+=(d); 答案：C 8. 设有以下类定义，其中说明了“+”运算符重载函数的原型。这是一个友元函数，当类 实验五运算符重载 【实验目的】 1.进一步了解运算符重载的概念和使用方法。 2.掌握几种常用的运算符重载的方法。 3.了解转换构造函数的使用方法。 4.了解在Visual C++6.0环境下进行运算符重载要注意的问题. 【实验要求】 1.硬件基本配置：Intel PentiumIII以上级别的CPU，大于64MB的内存。 2.软件要求：Window 2000操作系统，Visual Studio 6.0或更高版本开发环境。 3.实验学时：2学时 4.实现实验内容中的题目。 5.写实验报告 【实验内容】 (1)声明一个复数类Complex，重载运算符“+’’，“一”，“*”，“/”使之能用于复数的加、减、乘、除.运算符重载函数作为Complex类的成员函数，重载流提取运算符实现对复数的输出。编程序，分别求两个复数之和、差、积和商并用重载后的流运算符进行输出。 请思考:你编的程序能否用于一个整数与一个复数的算术运算?如4+ (5-2i). (2)声明一个复数类Complex,重载运算符“+“，使之能用于复数的加法运算。 参加运算的两个运算量可以都是类对象.也可以其中有一个是整数，顺序任意。例如， cl+c2， i+cl，cl+i均合法(设i为整数，c1, c2为复数)。 运行程序.分别求两个复数之和、整数和复数之和。 (3)有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符“+”，使之能用于矩阵相加。如c=a+b。重载流提取运算符实现对矩阵的输出如：cout< 实验十运算符重载1.实验目的及要求 1)掌握运算符重载的基本概念和方法。 2)熟习几种特殊的运算符的重载。 2.实验内容 1.分析下面的程序,指出程序运行的结果: 1） #include 运行结果为： 30,30 Press any key to continue 2）分析下面程序,指出程序运行的结果: #include 国家二级C++机试（运算符重载、模板和C++流）模拟试卷7 (总分：58.00，做题时间：90分钟) 一、选择题(总题数：29，分数：58.00) 1.下列关于函数模板的描述中，正确的是( )。 （分数：2.00） A.函数模板是一个实例函数 B.使用函数模板定义的函数没有返回类型 C.函数模板的类型参数与函数的参数相同 D.通过使用不同的类型参数，可以从函数模板得到不同的实例函数√ 解析：解析：函数模板是一系列相关函数的模型或样板，这些函数的源代码相同，只是所针对的数据类型不同。数据类型成了函数模板的参数，所以函数模板是一种参数化类型的函数。 2.有如下函数模板定义： template＜typename T1，Typename T2＞ T1 Fun(T2 n){ return n*5．0；} 若要求以int型数据9作为函数实参调用该模板，并返回一个double型数据，则该调用应表示为( )。 （分数：2.00） A.FUN(9) B.FUN＜9＞ C.FUN＜double＞[9] √ D.FUN＜9＞(double) 解析：解析：根据函数模板的定义，在选项C的调用中，把double类型传递给T1，int型传递给T2。 3.下列关于模板的描述中，错误的是( )。 （分数：2.00） A.类模板的成员函数都是模板函数 B.函数模板是一种参数化类型的函数 C.满足一定条件时可以省略模板实参 D.模板形参只能由关键字typename声明√ 解析：解析：同一模板的声明和定义中，模板形参的名字不必相同。每个模板类型形参前面必须带上关键字typename／class，每个非类型形参前面必须带上类型名字。 4.已知主函数中通过如下语句序列实现对函数模板swap的调用： int a[10]，b[10]； swap(a，b，10)；下列对函数模板swap的声明中，会导致上述语句序列发生编译错误的是( )。 （分数：2.00） 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)； 解析：解析：由题目中函数swap(a，b，10)调用语句可知，在对函数模板swap的声明语句中，应将第一、二个参数设为数组变量，第三个参数为整型变量。 5.在定义函数模板或类模板时，开头的保留字是( )。 （分数：2.00） A.typename B.template √ C.class D.typedef 解析：解析：定义函数模板或类模板时，开头的保留字是template。 6.若有函数模板mySwap和一些变量定义如下：( )。template＜class T＞void mySwap(T x，T y)；double d1，d2；int i1，i2；下列对mySwap的调用中，错误的是 （分数：2.00） A.mySwap(i1，i2) . 《面向对象程序设计》习题 班级：学号：姓名：名单序号：成绩： 第7章运算符重载和多态性 一、选择题（共30分，每题1分） 1．下列运算符中，（）运算符在C++中不能重载。 A.?: B.[] C. new D.++ 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. +，-，=，delete 10. 在名为BigNumber类的类体中对运算符函数double进行如下声明： operator double(BigNumbe); 函数声明中有一个明显的错误，这个错误就是（）。 A．参数表中不应该有任何参数 B．缺少对函数返回类型的说明 C．参数声明中缺少参数变量 D．函数声明中缺少函数体 11. 下列关于运算符重载的描述中，正确的是（）。 A. 运算符重载成为成员函数时，若参数表中无参数，重载是一元运算符 B. 一元运算符只能作为成员函数重载 C. 二元运算符重载成为非成员函数时，参数表中有一个参数 实验五运算符重载、继承 ●实验目的 1、了解类的两种使用方式。 2、学习从现有类派生出新类的方式。 3、了解在派生类中如何使用基类的成员。 4、了解基类成员在派生类中的访问控制。 5、掌握运算符重载的方法。 ●实验内容 1、从类Person中派生出一个教师类，新增的属性有专业（Specialty）、职称（Position）和主讲课程（MajorCourse，一门），并为这些属性定义相应的方法。 [实现要求] Person类的设计如下，请将空白处补充完整。 class Person { string Name; int Age; string Sex; public: void Register(char *name,int age,char *sex) { ; Age=age; Sex=sex; } string GetName() { } string GetSex() { return Sex; } int GetAge() { } void ShowMe() { cout< //带参数的构造函数去初始化各个成员的值，使其显示运行结果的第一行t.TeacherRegister("张三",40, "f","计算机","副教授","C++"); t.ShowMe(); return 0; } 运行结果如下： XXX m 0 XXX XXX XXX 张三 f 40 计算机副教授C++ [思考问题] ①在Teacher类中是否要需要重新定义ShowMe成员函数？不重新定义ShowMe成员函数能否得到上述要求的运行结果？为什么？ 2、从Point类中派生出一个Line类。Line类增加一个数据成员EndPoint，计算线的长度。 [实现提示] Point类可以按下面方式进行设计： class Point{ int x,y; public: Point(int a=0,int b=0){SetPoint(a,b);} void SetPoint(int a,int b); //设置点的坐标值 int GetX(){return x;} int GetY(){return y;} void Print(); //显示点的坐标值 }; Line类增加一个数据成员EndPoint为Point类对象，注意在设计Line类的构造函数时应为其基类和对象成员EndPoint提供形参。 为了检验Line类的功能，主函数按如下方式设计： int main(){ Line line(1,1,10,10); cout<<"Line line:"; line.Print(); cout<<"\n线line的长度："; cout< 运算符重载就是对一个已有的运算符赋予新的含义，使之实现新功能。下面将通过简单的几个例程阐叙其用法。 例10.1 通过函数来实现复数相加。 #include int main( ) {Complex c1(3,4),c2(5,-10),c3; //定义3个复数对象c3=https://www.doczj.com/doc/61550535.html,plex_add(c2); //调用复数相加函数cout<<″c1=″; c1.display( ); //输出c1的值cout<<″c2=″; c2.display( ); //输出c2的值 cout<<″c1+c2=″; c3.display( ); //输出c3的值 return 0; } 例10.2 改写例10.1，重载运算符“+”，使之能用于两个复数相加。#include //定义Student类，Date类，类定义与成员函数，实现分离。 //将Student类声明为Date的友元类。Student类需要提前声明。 //Student类的成员函数可以访问Date类的私有成员。 //成员函数：构造函数，构造函数重载，析构函数， //输出函数，求成绩最低者函数，排序函数。 //使用new,delete，动态分配内存。实现班级人数不固定，可以从键盘输入。 //定义Doctor类（研究生）-公共继承于Student类 //增加私有成员：string thesis（论文评价），int sci_value（科研分值） //增加相应的成员函数 //增加友元函数-运算符重载<<，>> //增加成员函数--按照科研分值高低排序 //student.h---头函数，类的定义 #include 一、运算符重载的规则 运算符重载规则如下： ①、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。 运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为： 函数类型 operator 运算符（形参表） { 函数体； } 运算符重载为类的友元函数的一般语法形式为： friend 函数类型 operator 运算符（形参表） { 函数体； } 其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类的友元函数时，参数个数与原操作数个数相同。原因是重载为类的成员函数时，如果某个对象使用重载了的成员函数，自身的数据可以直接访问，就不需要再放在参数表中进行传递，少了的操作数就是该对象本身。而重载为友元函数时，友元函数对某个对象的数据进行操作，就必须通过该对象的名称来进行，因此使用到的参数都要进行传递，操作数的个数就不会有变化。 运算符重载的主要优点就是允许改变使用于系统内部的运算符的操作方式，以适应用户自定义类型的类似运算。 一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。 二、运算符重载为成员函数 对于双目运算符B，如果要重载B为类的成员函数，使之能够实现表达式oprd1 B oprd2,其中oprd1为类A的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载后，表达式oprd1 B oprd2 就相当于函数调用 oprd1.operator B(oprd2). 实验十六运算符重载 一、实验目的 1、理解运算符重载作用和意义； 2、掌握类运算符和友元运算符重载的定义和使用； 3、掌握常用运算符(++、--、+、-、*、/、=、+=、-=、*=、/=、<<（插入）、>>（提取）)的重载。 二、实验内容 1、下列程序定义了一个复数类，重载"+"运算符以实现复数的加法运算。 #include Task8-1 /* 1. 定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。将运算符函数重载为非成员、非友元的普通函数。编写程序，求两个复数之和*/ #include return false; } bool operator <(Date &d1,Date &d2) { if(d1.year 《面向对象程序设计》习题 班级：学号：姓名：名单序号：成绩： 第7章运算符重载和多态性 一、选择题（共30分，每题1分） 1．下列运算符中，（）运算符在C++中不能重载。 A.?: B.[] C. new D.++ 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. +，-，=，delete 10. 在名为BigNumber类的类体中对运算符函数double进行如下声明： operator double(BigNumbe); 函数声明中有一个明显的错误，这个错误就是（）。 A．参数表中不应该有任何参数 B．缺少对函数返回类型的说明 C．参数声明中缺少参数变量 D．函数声明中缺少函数体 11. 下列关于运算符重载的描述中，正确的是（）。 实验5 运算符重载 1．实验目的 通过本次实验 （1）理解运算符重载函数的概念； （2）掌握运算符重载函数的定义与使用方法； 2．实验要求 （1）编写实验程序 （2）在运行环境中，输入源程序 （3）编译运行源程序 （4）输入测试数据进行程序测试； （5）写出运行结果。 3．实验内容 （1）定义一个复数类，重载“-=”运算符，使这个运算符能直接完成复数的“-=”运算。分别用成员函数与友元函数编写运算符重载函数。在主函数中定义复数对象c1(10,20)、c2(15,30)，进行c2-=c1的复数运算，并输出c1、c2的复数值。 （2）定义一个数组类Array，其私有数据成员为整型一维数组a[10]。通过构造函数给a[10]赋初值。用Show函数显示a[10]的元素值。用成员函数重载运算符“+”，直接实现两个一维数组对应元素相加的运算。在主函数中定义数组a、b分别为： int a[10]={1,2,3,4,5,6,7,8,9,10}; int b[10]={4,5,6,7,8,9,10,11,12,13}; 用Array定义三个数组对象arr1(a)、arr2(b)、arr3，执行arr3=arr1+arr2运算，输出arr3的数组元素值。 （3）定义一个人民币类Money，类中数据成员为元、角、分。用成员函数与友元函数重载“――”运算符，实现人民币对象的减1运算。在主函数中定义人民币对象m1=10元8角5分及对象m2、m3。对m1作前置“――”并赋给m2。对m1作后置“――”并赋给m3。显示m1、m2、m3的结果。 （4）定义描述字符串的类String，编写字符串运算符“+=”的重载函数，使运算符“+=”用于两个字符串联接操作，即用str1+=str2实现字符串函数strcat(str1,str2)的操作功能。要求分别用成员函数与友元函数编写运算符重载函数。在主函数中定义字符串对象s1("software and ")与s2("hardware")，进行s1+=s2的字符串联接，并输出s1、s2的值。 C++中预定义的运算符的操作对象只能是基本数据类型，实际上，对于很多用户自定义类型，也需要有类似的运算操作。例如： class complex { public: complex(double r=0.0,double I=0.0){real=r;imag=I;} void display(); private: double real; double imag; }; complex a(10,20),b(5,8); “a+b”运算如何实现？这时候我们需要自己编写程序来说明“+”在作用于complex类对象时，该实现什么样的功能，这就是运算符重载。运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据导致不同类型的行为。 运算符重载的实质是函数重载。在实现过程中，首先把指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参，然后根据实参的类型来确定需要调用达标函数，这个过程爱编译过程中完成。 一、运算符重载的规则 运算符重载规则如下： ①、C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。 ②、重载之后运算符的优先级和结合性都不会改变。 ③、运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。 不能重载的运算符只有五个，它们是：成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。 运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。 运算符重载为类的成员函数的一般语法形式为： 函数类型 operator 运算符（形参表） { 函数体； } 运算符重载为类的友元函数的一般语法形式为： friend 函数类型 operator 运算符（形参表） { 函数体； } 其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类 运算符重载的应用 【实验目的】 1、理解重载运算符的意义。 2、掌握用成员函数、友元函数重载运算符的特点。 3、掌握重载运算符函数的调用方法。 【实验内容】 1.定义一个复数类，通过重载运算符：*，/，直接实现二个复数之间的乘除运算。编写 一个完整的程序，测试重载运算符的正确性。要求乘法“*”用友元函数实现重载，除法“/” 用成员函数实现重载。 ⑴分析 两复数相乘的计算公式为：(a+b i)*(c+d i)=(ac–bd )+(ad+bc) i 两复数相除的计算公式为：(a+b i)/(c+d i)=(ac+bd)/(c*c+d*d)+(bc-ad)/(c*c+d*d) i 复数类及运算符重载函数可定义为： 2.根据下面描述定义完整的日期类: class Date{ //成员变量 void IneDay();//日期增加1天 int DayCalc()const;//距基准日期的天数 static const int day[];//每月的天数 public: Date(int y,int m,int d); Date(int m, int d); Date(); void SystmDate();//读取系统当前时间 void SetDate(int yy,int mm,int dd);//设置日期 void SetDate(int mm,int dd); bool IsLeapYear(int yy) const;//是否闰年 bool IsEndofMonth()const ；//是否月末 //重载cout<<,cout>>完成读入和输出日期工作 //重载+，+=，-，-=，++，--，等运算符，完成日期的运算符操作。 //成员函数：判读一个日期是否是系统的当前日期运算符重载练习题.
实验五 运算符重载
实验十_运算符重载
国家二级C++机试(运算符重载、模板和C++流)模拟试卷7
运算符重载知识题
实验5-运算符重载、继承 ( 1 )
C++运算符重载例程详解
Student类(友元,运算符重载,继承)综合题
C++运算符重载
实验十六运算符重载解读
c++运算符重载习题
第7章 运算符重载-习题
实验5 运算符重载
C++运算符重载讲解与经典实例 (2)
运算符重载实验
相关主题
文本预览