第11章 友元与运算符重载
第11章 友元与运算符重载
3．用虚函数实现动态多态性的方法
（1）在基类中定义虚函数 （2）在派生类中定义与基类虚函数同名同参数同 返回类型的成员函数，即派生类中的虚函数。 （3）在主函数中操作步骤： ①用基类定义指针变量。 ②将基类对象地址或派生类对象地址赋给该指 针变量。 ③用<指针变量>→ <虚函数>（实参）；方式 去调用数为友元函数
（2）重载函数的调用格式 <operator><重载运算符>(实参1，实参2)； 其中实参1，实参2分别是重载运算符的左操作数 和右操作数。
【例11.3】用友元运算符重载函数实现【例11.2】 中复数的加法运算。 例程
成员函数与友元函数作为重载函数的差别
（3）成员函数与友元函数作为重载函数的差别： ①用成员函数与友元函数作为运算符重载函数， 就运算符的使用来讲是一样，但编译器处理方 法是不同的。 ②当重载函数为成员函数时，二元运算符的左 操作数为调用重载函数的对象。右操作数为实 参。当重载函数为友元函数时，二元运算符的 左操作数为调用重载函数的第一个实参。右操 作数为第二个实参。
运算符重载函数为类的成员函数
（2）重载函数的调用格式
<对象名>.<operator><重载运算符>(实参表)；
注意：在进行两个对象的二元运算时，其程序中所用到 语法格式为：
<左操作对象><二元运算符><右操作数>；
如：c1+c2 而执行上述语句时，系统将自动转换成对重载函数 的调用格式：
<左操作对象>.<operator><二元运算符>(右操作数)；
11.1.2 友元注意事项
（1）友元关系是不传递的 （2）友元关系不具有交换性 （3）友元关系是不能继承的
运算符重载语法
运算符重载语法运算符重载是一种强大的编程技术，它允许我们改变已定义的运算符的行为，使其适应我们自定义的数据类型。
通过重载运算符，我们可以使程序更加简洁、易于理解，并更加接近我们自然语言的表达方式。
本文将详细介绍运算符重载的语法，帮助读者全面理解并运用此技术。
运算符重载的语法非常简单，以下是一些基本规则：1. 重载运算符函数必须是类的成员函数或友元函数。
如果是成员函数，则形参列表至少有一个参数；如果是友元函数，则形参列表为空。
2. 重载运算符函数的返回类型通常是该运算符所针对的数据类型，以满足运算符的语义要求。
3. 不适合重载的运算符包括`sizeof`、`.`、`.*`、`::`和`?:`等。
4. 重载运算符函数可以是类中定义的普通成员函数，也可以是全局函数。
对于全局函数，建议使用友元函数来实现。
5. 一些运算符重载函数需要改变对象的状态，因此要使用成员函数来实现，以便访问对象的私有成员。
重载运算符函数的声明和实现示例如下：```cpp// 类中定义的成员函数class MyClass {public:MyClass operator+(const MyClass& other); // 加法运算符重载声明};MyClass MyClass::operator+(const MyClass& other) {// 加法运算符重载实现}// 友元函数class MyClass {public:friend MyClass operator+(const MyClass& lhs, const MyClass& rhs); // 加法运算符重载声明};MyClass operator+(const MyClass& lhs, const MyClass& rhs) {// 加法运算符重载实现}```通过运算符重载，我们可以为不同的数据类型定义不同的行为。
友元和运算符重载
// 哈哈，多可笑...
Date:27 November 2018
IT Education & Training
1. 运算符重载概念
• 4).算符重载的好处是什么？ 通过重载类上的标准算符，你可以发掘类的用户的 直觉。使得用户程序所用的语言是面向问题的，而 不是面向机器的。
Date:27 November 2018
Date:27 November 2018
IT Education & Training
1. 运算符重载概念
• 9). 重载运算符有哪些限制？ (1) 不可臆造新的运算符。必须把重载运算符限制在C++语言 中已有的运算符范围内的允许重载的运算符之中。 (2) 重载运算符坚持4个“不能改变”。
· 不能改变运算符操作数的个数； · 不能改变运算符原有的优先级； · 不能改变运算符原有的结合性； · 不能改变运算符原有的语法结构。
• 访问对象中的成员必须通过对象名。
Date:27 November 2018
IT Education & Training
例10 使用友元函数计算两点距离
运算符重载
1、多态性的基本概念2、派生类对象替换基类对象3、虚函数的定义4、抽象类的定义5、宠物类的设计6、运算符重载7、日期类对象判断大小8、分数类对象运算符重载☐运算符重载指赋予运算符新的操作功能，主要用于对类的对象的操作☐运算符+意味着多少对象类型的加法呢？☐还可以定义新的对象类型加法☐运算符重载定义形式：<类型><类名>::operator<操作符>(<参数表>){函数体}☐首先定义虚数类☐虚数可以描述为：a+bi☐a与b看成实数，定义成double类型☐成员函数除了构造与析构外，还有：☐输出虚数、修改虚数、得到实部a、得到虚部b ☐相加+、判相等==#include <iostream>using namespace std;class Complex{private:double real, imag;public:Complex(double r = 0, double i = 0): real(r), imag(i){ }double Real(){return real;}double Imag(){return imag;}Complex operator +(Complex&);Complex operator +(double);bool operator ==(Complex);~Complex(){ };Complex Complex::operator +(Complex &c)// 重载运算符＋，两边是虚数对象{Complex temp;temp.real = real+c.real;temp.imag = imag+c.imag;return temp;}Complex Complex::operator +(double d)// 重载运算符＋，左边是虚数对象，右边是双精度数{Complex temp;temp.real = real+d;temp.imag=imag;return temp;}bool Complex::operator ==(Complex c)// 重载运算符=={if (real == c.real && imag == c.imag)return true;elseint main(){Complex c1(3,4),c2(5,6),c3;cout << "C1 = " << c1.Real() << "+j" << c1.Imag() << endl;cout << "C2 = " << c2.Real() << "+j" << c2.Imag() << endl;c3 = c1+c2;cout << "C3 = " << c3.Real() << "+j" << c3.Imag() << endl;c3 = c3+6.5;cout << "C3 + 6.5 = " << c3.Real() << "+j" << c3.Imag() << endl;if ( c1==c2 )cout<<“两个复数相等”;elsecout<<“两个复数不相等”;return 0;☐运算符++分前置运算符和后置运算符☐例如: ++Y与Y++☐前置运算符定义Complex Complex::operator ++ () {real+=1;return *this;}☐后置运算符定义Complex Complex::operator ++ (int) {real+=1;return *this;}。
C++重载（主要介绍使用友元函数重载）
C++重载（主要介绍使⽤友元函数重载）重载限制多数C++运算符都可以⽤下⾯的⽅式重载。
重载的运算符不必是成员函数，但必须⾄少有⼀个操作数是⽤户⾃定义的类型。
下⾯详细介绍C++对⽤户定义的运算符重载的限制。
1 重载后的运算符必须⾄少有⼀个操作数是⽤户⾃定义的类型，这将防⽌⽤户为标准类型重载运算符。
因此，不能将减法运算符（-）重载为double值的和，⽽不是它们的差。
虽然这种限制将对创造性有所影响，但可以确保程序正常运⾏。
2 使⽤运算符时不能违反运算符原来的句法规则。
例如，不能将求模运算符（%）重载成使⽤⼀个操作数。
同样，不能修改运算符的优先级。
因此，如果将加号运算符重载成将两个类相加，则新的运算符与原来的加号具有相同的优先级。
3 不能创建新的运算符。
例如，不能定义operator**（）函数来表⽰求幂。
4 不能重载下⾯的运算符sizeof：sizeof运算符.：成员运算符.*：成员指针运算符:: ：作⽤域解析运算符？:：条件运算符typeid：⼀个RTTI运算符const_cast：强制类型转换运算符dynamic_cast：强制类型转换运算符reinterpret_cast：强制类型转换运算符static_cast：强制类型转换运算符然⽽，下表中的所有运算符都可以被重载5 下表中的⼤多数运算符都可以通过成员或⾮成员函数进⾏重载，但下⾯的运算符值能通过成员函数进⾏重载=：赋值运算符（）：函数调⽤运算符[]：下标运算符->：通过指针访问类成员的运算符可重载的运算符除了这些正式限制之外，还应在重载运算符时遵循⼀些限制。
例如，不要将*运算符重载成交换两个对象的数据成员。
友元C++控制对类对象私有部分的访问。
通常，公有类⽅法提供唯⼀的访问途径，这种限制太严格，以⾄于不适合特定的编程问题。
在这种情况下，C++提供了另外⼀种形式的访问权限：友元。
友元有3种：友元函数友元类友元成员函数通过让函数成为类的友元，可以赋予该函数与类的成员函数相同的访问权限。
友元和运算符重载解读
友元
• 友员有3种: 友员函数 友员类 友员成员函数
Date:27 September 2018
IT Education & Training
友元
• 友元是C++提供的一种破坏数据封装和数据隐藏 的机制。 • 通过将一个模块声明为另一个模块的友元，一个 模块能够引用到另一个模块中本是被隐藏的信息。 • 可以使用友元函数和友元类。 • 为了确保数据的完整性，及数据封装与隐藏的原 则，建议尽量不使用或少使用友元。
Date:27 September 2018
IT Education & Training
1. 运算符重载概念
• • • • • 1). 什么叫重载？ 重载既赋予新的含义。 2).什么叫运算符重载？ 指对已知的运算符，在新的场合，通过程序实现新的行为。 3). 运算符重载的作用是什么？ 它允许你为类的用户提供一个直觉的接口。 运算符重载允许C/C++的运算符在用户定义类型(类)上拥有 一个用户定义的意义。重载的运算符是函数调用的语法修饰：
Date:27 September 2018
IT Education & Training
友元函数
• 友元函数是在类声明中由关键字friend修饰说明的 非成员函数，在它的函数体中能够通过对象名访 问 private 和 protected成员 • 作用：增加灵活性，使程序员可以在封装和快速 性方面做合理选择。
Date:27 September 2018
IT Education & Training
double Distance( Point& a, Point& b) { double dx=a.X-b.X; double dy=a.Y-b.Y; return sqrt(dx*dx+dy*dy); } int main() { Point p1(3.0, 5.0), p2(4.0, 6.0); double d=Distance(p1, p2); cout<<"The distance is "<<d<<endl; return 0; }
C++运算符重载模板友元newdelete++=+=
C++运算符重载模板友元newdelete++=+=今天的重载是基于C++ 类模板的，如果需要⾮类模板的重载的朋友可以把类模板拿掉，同样可以参考，谢谢。
⼀、类模板中的友元重载本⼈喜好类声明与类成员实现分开写的代码风格，如若您喜欢将类成员函数的实现写在类声明中，那么可以跳过该部分。
请看下⾯这段代码：头⽂件：#pragma oncetemplate<typename T>class CLA{T m_value;public:CLA(const T&);friend CLA operator+(const CLA&, const CLA&);};template<typename T>CLA<T>::CLA(const T& a):m_value(a){ }template<typename T>CLA<T> operator+(const CLA<T>& lhs, const CLA<T>& rhs){return CLA<T>(lhs.m_value + rhs.m_value);}源⽂件：（已包含上述的头⽂件）int main(){CLA<int> a{ 0 }, b{ 1 }, c{ 2 };a + b;return0;}我们去执⾏上述代码的时候，编译器就会报错：⼀个⽆法解析的外部指令。
当然，将实现放⼊声明中是可以的，但是为了维护类的书写风格，我们还是希望有⼀种⽅法可以去维护这个风格。
那么我们可以将类中友元函数的声明写成如下形式：friend CLA operator+<T>(const CLA&, const CLA&);原因很简单，类模板具有抽象性，⽽刚刚那个友元函数就是普通的函数，不具有模板的抽象性。
即使参数为CLA<T> ... 还是⼀样，它代表的只不过是⼀个参数的类型，函数本⾝依旧是⼀个普通的函数。
C++重载函数运算符的两种定义方法（类中类外（友元））、重载操作运算符
C++重载函数运算符的两种定义⽅法（类中类外（友元））、重载操作运算符⼀、C++中重载运算符函数的⽅式：以重载‘-’号为例，⾃定义为乘法。
第⼀种是直接在类内声明定义：（返回值是本类的对象）#include <iostream>using namespace std;class test{public:test() {}test(int t1){item = t1;}test operator-(test &t2){this->item = this->item*t2.item;return *this;}void show(){cout << this->item;}private:int item;};int main(){test t1(10);test t2(20);test t3 = t1 - t2;t3.show();system("pause");return0;}第⼆种是在类中声明为友元函数，类外定义，返回值的是⼀个类的对象。
（⼀般为了能在类外直接调⽤成员⽽不⽤通过成员函数间接调⽤成员数据）#include <iostream>using namespace std;class test{public:test() {}test(int t1){item = t1;}void show(){cout << this->item;}friend test operator-(test &t1, test &t2);private:int item;};test operator-(test &t1, test &t2){test t;t.item = t1.item*t2.item;return t;}int main(){test t1(10);test t2(20);test t3 = t1 - t2;t3.show();system("pause");return0;}/*注意，如果新建⽴⼀个对象test t4(30);test t3=t1-t2-t4;此时运算符重载函数依然可以使⽤，但是，如果将运算符重载函数声明定义为返回的是⼀个对象的引⽤，t1-t2这⼀步骤完成后，做-t4这⼀步骤，此时会出现乱码，因为运算符重载函数返回的是⼀个对象的引⽤时，产⽣临时变量temp，但是会消失，此时对temp进⾏引⽤时已经不存在这个值了，所以出现乱码*/⼆、C++中操作符重载函数操作符重载函数中的重载左移操作符，其函数定义不建议写在类中，因为cout<<test,左边是ofstream对象，如果放到类中定义，其调⽤是test.operator<<，变成test<<cout右移操作符⼤同⼩异#include <iostream>using namespace std;class test{public:test(){}test(int t){temp=t;}void show(){cout<<temp;}friend ostream& operator<<(ostream &os,test &t1); //为了能直接调⽤类的数据成员，声明为友元函数private:int temp;};ostream& operator<<(ostream &os,test &t1) //<<操作符重载函数只写在全局，{os<<t1.temp<<endl;return os;}int main(){test t1(10);cout<<t1;system("pause");return0;}注！操作符重载函数返回引⽤⽬的是为了能够连续赋值。
运算符重载
在C++中，只有类的成员函数和类的友元函数才能够访问类的私有数据成员，因此只有将运算符重载为数据类的成员函数或是友元函数时，才能使被重载的运算符应用于新的数据类型。
运算符重载为类的成员函数的一般语法形式为：函数类型operator 运算符（形参表）{函数体；}运算符重载为类的友元函数的一般语法形式为：friend 函数类型operator 运算符（形参表）{函数体；}当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类的友元函数时，参数个数与原操作数个数相同。
原因是重载为类的成员函数时，如果某个对象使用重载了的成员函数，自身的数据可以直接访问，就不需要再放在参数表中进行传递，少了的操作数就是该对象本身。
而重载为友元函数时，友元函数对某个对象的数据进行操作，就必须通过该对象的名称来进行，因此使用到的参数都要进行传递，操作数的个数就不会有变化。
只能重载为成员函数的运算符C++要求,像赋值“=”、下标“[]”、调用“()”、以及成员访问箭头“->”等,这些第一个操作数一定是本类对象的运算符,重载时必须被定义为类的成员函数,任何把这些运算符重载为非类成员函数的做法都会产生编译时刻的错误。
这样做的原因在于类的所有非静态成员函数都隐含有指向对象自己的this指针(类的友元函数不具有),如果将运算符重载为类的成员函数,则运算符的第一个操作数系统默认就是this对象(本类的对象)。
也正是由于this指针的存在,当运算符被重载为成员函数的形式时,第一个操作数不作为函数参数,这样一来,对于单目运算符可以不写参数,而双目运算符可以只写一个参数,即第二个操作数(或称右操作数)。
运算符重载为成员函数格式如下:<函数返回值类型> operator <运算符名> (<参数表>);例如有一个表示时间的time类,求将已有时间推后x小时后的时间,重载“+”运算符为time类的成员函数,格式如下:time operator + (int x);只能重载为友元函数的运算符与第1)种情况正好相反,像插入运算符“<<”和提取运算符“>>”等第一个操作数一定不是本类对象的运算符,只能被重载为类的友元函数。
C++运算符重载三种形式（成员函数，友元函数，普通函数）详解
C++运算符重载三种形式（成员函数，友元函数，普通函数）详解三种重载⽅式⾸先，介绍三种重载⽅式：1//作为成员函数重载（常见）2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时，*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载（不推荐）2class Person{3public://注意，重载运算符为普通函数时，使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种：bool Person::operator<(const Person& b)，bool是函数返回类型，Person::只是指定了成员函数所属类名。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
运算符 ？： 运算符的含义 三目运算符 成员操作符 成员指针操作符 作用域运算符 求字节数操作符 不允许重载的原因 在C++中没有定义一个三目运算符的语法 为保证成员操作符对成员访问的安全性，故 不允许重载 同上 因该操作符左边的操作数是一个类型名，而 不是一个表达式 其操作数是一个类型名，而不是一个表达式
一元运算符重载函数为友元函数
（2）重载函数调用格式 ①前置“++”运算符重载函数调用格式： operator ++(<操作对象名>)； ②后置“++”运算符重载函数的调用格式： operator ++(<操作对象名>，1)； 【例11.5】定义一个描述时间计数器的类，其三个数据成 员分别用于存放：时、分和秒。用友元函数重载“++” 运算符，实现计数器对象的加1运算。 例程 【例11.6】定义描述三维空间点(x,y,z)的类，用成员函数 实现空间两个点相加的“+”运算符重载，用友元函数实 现空间一个点“++”运算符的重载。 例程
C++中允许重载的运算符
（4）C++中允许重载的运算符如下表所示。
+ ~ ++ += <<= － ! －－ －= >>= * , << *= [] / = >> /= () % < == %= －> ^ > != ^= & <= && &= | >= || != delete
－ >* new
C++中不允许重载的运算符
11.2.4 字符串类运算符重载
举例说明字符串运算符重载函数的定义与调用 方法，及重载后字符串运算符的使用方法。 【例11.7】编写字符串运算符“=”与“+”的重载函 数，使运算符“=”与“+”能完成两个字符串的赋值 与拼接运算，实现字符串直接操作运算。分别用成员 函数与友员函数编写重载函数。 例程 【例11.8】编写字符串运算符“>”的重载函数，使运 算符“>”能完成两个字符串的比较运算，实现字符串 直接比较。分别用成员函数与友元函数编写重载函数。 例程
一元运算符重载函数为类的成员函数
（2）重载函数的调用格式
①前置“++”运算符，调用格式： <操作对象>.operator ++( )； ②后置“++”运算符，调用格式： <操作对象>.operator ++(1)； 【例11.4】定义一个描述时间计数器的类，其三个 数据成员分别用于存放：时、分和秒。用成员函数 重载“++”运算符，实现计数器对象的加1运算。 例程
如c1.operator+(c2); 【例11.2】定义一个复数类 ，重载“+”运算符，使这个 运算符能直接完成两个复数的加法运算，以及一个复 数与一个实数的加法运算。 例程
运算符重载函数为类的成员函数说明
（3）对于运算符重载，必须说明以下几点：
①运算符重载函数名必须为：operator <运算符> ②运算符的重载是通过调用运算符重载函数实现的。调 用函数时，左操作数为调用重载函数的对象，右操作数 作为函数的实参，实参可以是对象、实数等其它类型。 ③形参说明：若重载函数为成员函数，则参加二元运算 的左操作数为调用重载函数的对象。因此，重载函数为 成员函数的参数通常为一个，即右操作数。 ④运算符重载函数的返回类型。若二个同类对象进行二 元运算后的结果类型仍为原类型，则运算符重载函数的 返回类型应为原类型。
3．用虚函数实现动态多态性的方法
（1）在基类中定义虚函数 （2）在派生类中定义与基类虚函数同名同参数同 返回类型的成员函数，即派生类中的虚函数。 （3）在主函数中操作步骤： ①用基类定义指针变量。 ②将基类对象地址或派生类对象地址赋给该指 针变量。 ③用<指针变量>→ <虚函数>（实参）；方式 去调用基类或派生类中的虚函数。
·
* ：： sizeof
2.运算符重载函数为友元函数
（1）重载运算符的定义格式
<类型> <operator><运算符>(形参1，形参2) {函数体} 其中，形参1与形参2常为参加运算的两个对象的引 用。 当重载函数为友元普通函数时，该重载函数不能用 对象调用，因此参加运算的两个对象必须以形参方式传 送到重载函数体内，所以形参通常为两个参加运算的对 象。
11.3 多态性与虚函数
11.3.1 多态性技术
1.多态性技术的概念 （1）多态性技术：调用同名函数完成不同的 函数功能，或使用同名运算符完成不同的运算 功能。 （2）多态性常用重载技术与虚函数来实现。 （3）多态性分为两类：编译时的多态性和运 行时的多态性。
多态性技术
2．编译时的多态性 通过函数的重载或运算符的重载来实现的。 也称静态多态性。
第11章 友元与运算符重载
目的与要求 11.1 友元函数 11.2 运算符重载 11.3 多态性与虚函数 11.4 类与对象的特性 本章小结
目的与要求
通过本章的学习，应理解友元的概 念，掌握将普通函数定义为类友元函 数的方法。理解运算符重载的概念， 掌握运算符重载函数的定义方法、调 用过程及实际应用。掌握多态性技术 的概念及实现方法。了解虚函数与纯 虚函数的概念、定义格式及使用方法。
3．运行时的多态性
运行时的多态性也称为动态多态性，运 行时的多态性是指在程序执行前，根据函数名 和参数无法确定应该调用哪一个函数，必须在 程序执行过程中，根据具体执行情况来动态地 确定。 运行时的多态性是通过类的继承关系和虚 函数来实现的。
11.3.2 虚函数
1．虚函数概念 在基类中用关键字 virtual修饰的成员 函数称为虚函数。 2．虚函数定义格式 virtual <类名> <函数名>（参数） {函数体}
运算符重载函数为友元函数
（2）重载函数的调用格式 <operator><重载运算符>(实参1，实参2)； 其中实参1，实参2分别是重载运算符的左操作数 和右操作数。
【例11.3】用友元运算符重载函数实现【例11.2】 中复数的加法运算。 例程
成员函数与友元函数作为重载函数的差别
（3）成员函数与友元函数作为重载函数的差别： ①用成员函数与友元函数作为运算符重载函数， 就运算符的使用来讲是一样，但编译器处理方 法是不同的。 ②当重载函数为成员函数时，二元运算符的左 操作数为调用重载函数的对象。右操作数为实 参。当重载函数为友元函数时，二元运算符的 左操作数为调用重载函数的第一个实参。右操 作数为第二个实参。
虚函数的说明
（3）虚函数必须是类的一个成员函数，不能是友元函数， 也不能是静态的成员函数。 （4）若派生类中没有定义虚函数，将派生类对象地址赋 给基类定义的指针变量后，用指针变量→虚函数(实参)； 方式去调用虚函数时，调用的虚函数是基类的虚函数。 （5）可将析构函数定义为虚函数，但不能将构造函数定 义为虚函数。 （6）虚函数与一般函数相比较，调用时执行速度要慢一 些。为了实现多态性。在每一个派生类中均要保持相应 虚函数的入口地址表，函数调用机制也是间接实现的。
2.一元运算符重载函数为友元函数
（1）重载函数定义格式 <类型><类名>:: operator <一元运算符>(类名 &对象) {函数体} ①前置“++”运算符重载函数定义格式： <类型> <类名>:: operator++ ( 类名 & <对象>) {函数体} ②后置“++”运算符重载函数定义格式： <类型> <类名>:: operator ++ ( 类名 & <对象>，int ) {函数体} 其中，int 只是用于区分是前置还是后置运算符， 并无实际意义。
friend <类型> <友元函数名> (形参表)；
【例11.1】用友元函数的方法求长方体的 例程 体积。
友元函数的说明：
（1）友元函数不是类的成员函数，它不带this指针。所 以必须用对象或对象的引用作为友元函数的形参，并在 函数体内使用运算符“.”来访问对象的成员 （2）友元函数必须在类内进行函数原型说明，函数定义 部分写在类外。 （3）友元函数与一般函数的区别： 友元函数可访问类内的任一数据成员或成员函数； 一般函数只能访问类的公有数据成员或公有成员函数。 （4）由于友元函数不是类的成员函数，所以类的访问权 限对友元函数不起作用。 （5）友元函数可使用类内的所有成员，破坏了数据的安 全性，使用友元函数必须谨慎。Βιβλιοθήκη 11.1.2 友元注意事项
（1）友元关系是不传递的 （2）友元关系不具有交换性 （3）友元关系是不能继承的
11.2 运算符重载
11.2.1 运算符重载的概念
1．引例 用“+”运算符完成两个实数、两个复数、两个字符 串的相关运算。 （1）实数。设：c1=10 ，c2=20，则：c1+c2=10+20=30。 （2）复数。设：c1=10+10i，c2=20+20i，则： c1+c2=30+30i 。 （3）字符串。设：c1=“ABCD”，c2=“EFGH” ，则 c1+c2="ABCDEFGH“ 这就是“+”运算符的重载。
1．运算符重载函数为类的成员函数
（1）重载函数的定义格式 <类型><类名>::<operator><重载运算符>(形参) {函数体} 其中，类型为重载函数的返回类型。 类名为成员函数所属类的类名。 关键词“operator”加上“重载运算符”为重载函数 名，即：<重载函数名>=<operator><重载运算符>。 形参常为参加运算的对象或数据。