第08章_运算符重载
运算符重载
void complex::print( ) { if (imag==0) cout<<real<<endl; else if(imag>0) cout<<real<<"+"<<imag<<"i\n"; else cout<<real<<imag<<"i\n"; } complex operator -(complex obj) { complex temp; temp. real= -obj.real ; temp. imag= -obj.imag; return temp; }
10
void main( ) { complex com1(2.3,4.6),com2(3.6,2.8),result; cout<<"complex com1 and com2 orderly:\n"; com1.print( ); com2.print( ); result=com1+com2; cout<<"com1+com2="; result.print( ); result=com1-com2; cout<<"com1-com2="; result.print( ); result=com1*com2; cout<<"com1*com2="; result.print( ); result=com1/com2; cout<<"com1/com2="; result.print( ); }
2、双目运算符的重载
第八讲 运算符重载(8.2)
另一类是“=”即直接赋值的运算符
#include <iostream.h> class Vector { int x,y; public: Vector(){}; Vector(int x1,int y1){x=x1;y=y1;} 对于标准数据类型，“+=”和”-=”的作 friend Vector operator +=(Vector v1,Vector v2) //友 用是将一个数据与另一个数据进行加法和 元函数方式实现 { 减法运算后，再将结果回送给赋值号左边 v1.x+=v2.x; v1.y+=v2.y; return v1; } Vector operator -=(Vector v) //成员函数方式实现 的变量中。对它们重载后，使其实现其他 { Vector tmp; tmp.x=x-v.x; 相关的功能 tmp.y=y-v.y; return tmp; } void display(){cout<<"("<<x<<","<<y<<")"<<endl; } }; void main() { Vector v1(6,8),v2(3,6),v3,v4; cout<<"v1=";v1.display();cout<<"v2=";v2.display(); v3=v1+=v2; cout<<"v3=v1+=v2后,v3=";v3.display(); v4=v1-=v2; cout<<"v4=v1-=v2后,v4=";v4.display();
C_运算符重载_各类详细介绍
▪ 说明
运算符重载函数 operator@()可以返回任何类型，甚至可 以是 void类型，但通常返回类型与它所操作的类的类型 相同，这样可使重载运算符用在复杂的表达式中。例如， 在例7-2中，可以将几个复数连续进行加、减、乘、除的 运算。
用友元函数重载单目运算符时，需要一个显式的操作数， 例7-3中，用友元函数重载单目运算符“-”
#include<iostream.h> class nclass{ int a,b; public:
nclass(int x=0,int y=0) { a=x;b=y;} friend nclass operator -(nclass obj); void show(); };
▪ complex operator+(complex com1,complex com2) { return complex(com1.real+com2.real,com1.imag+com2.imag;}
▪ 这种方法是直接将一个无名临时对象创建到主调函数中，那么 运行效率高于前一种。
▪ 单目运算符重载
nclass operator-(nclass obj) { obj.a=-obj.a;
obj.b=-obj.b; return obj;} void nclass::show() { cout<<"a="<<a<<" b"<<b;} ▪ main() ▪{ ▪ nclass ob1(10,20),ob2; ▪ ob1.show(); ▪ ob2=-ob1; ▪ ob2.show(); ▪ return 0; ▪}
运算符重载
24
运算符重载
思考:如果希望表达式i+c1有意义, 思考:如果希望表达式i+c1有意义,应该 i+c1有意义 如何定义重载运算符函数? 如何定义重载运算符函数?
friend Complex operator+(int &i,Complex &c); Complex operator+(int &i, Complex &c) {return Complex(i+c.real,c.imag);}
2
什么是运算符重载
代码分析: 代码分析: 例10.1 通过函数来实现复数 相加。 相加。
CCS E
3
运算符重载的方法
运算符重载的方法是定义一个重载运 算符的函数， 算符的函数，在需要执行被重载的运 算符时，系统就自动调用该函数， 算符时，系统就自动调用该函数，以 实现相应的运算。也就是说， 实现相应的运算。也就是说，运算符 重载是通过定义函数实现的。 重载是通过定义函数实现的。运算符 重载实质上是函数的重载。 重载实质上是函数的重载。
CCS E
21
运算符重载
如果将运算符重载函数作为成员函数， 如果将运算符重载函数作为成员函数， 它可以通过this this指针自由地访问本类 它可以通过this指针自由地访问本类 的数据成员， 的数据成员，因此可以少写一个函数 的参数。 的参数。但必须要求运算表达式第一 个参数(即运算符左侧的操作数) 个参数(即运算符左侧的操作数)是一 个类对象， 个类对象，而且与运算符函数的类型 相同。 相同。因为必须通过类的对象去调用 该类的成员函数，而且只有运算符重 该类的成员函数， 载函数返回值与该对象同类型， 载函数返回值与该对象同类型，运算 结果才有意义。 结果才有意义。
简述运算符重载的规则。
简述运算符重载的规则。
篇一：运算符重载是C/C++语言中一种强大的功能,允许程序员自定义函数的行为,以处理不同类型的数据。
运算符重载允许程序员在函数中重载算术、逻辑和位运算符,从而能够处理数组、结构体和指针等不同类型的数据。
以下是运算符重载的规则:1. 算术运算符重载算术运算符包括加号、减号、乘号和除号。
每个算术运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
例如,重载加号运算符可以使函数接受一个整数参数,并返回一个新的整数。
下面是一个简单的例子,演示了如何重载加号运算符:```c++struct MyStruct {int value;};MyStruct operator+(const MyStruct& other, int value) {return MyStruct(value + other.value);}int main() {MyStruct mystruct1 = { 10 };MyStruct mystruct2 = { 20 };int result = mystruct1 + mystruct2;std::cout << "result = " << result << std::endl;return 0;}```在上面的例子中,我们定义了一个名为`MyStruct`的结构体类型,其中包含一个整数类型。
然后,我们定义了一个重载加号运算符的函数,该函数接受一个整数类型的参数,并返回一个新的`MyStruct`对象。
在`main`函数中,我们定义了两个`MyStruct`对象`mystruct1`和`mystruct2`,并将它们相加,结果存储在`result`变量中。
2. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。
每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。
Python编程基础之运算符重载详解
Python编程基础之运算符重载详解
⽬录
学习⽬标
⼀、运算符重载
（⼀）概述
（⼆）加法运算重载符
1、概述
2、案例演⽰
总结
学习⽬标
1.掌握运算符重载
2.会定制对象字符串的形式
⼀、运算符重载
（⼀）概述
运算符重载是通过实现特定的⽅法使类的实例对象⽀持Python的各种内置操作。
例如：+运算符是类⾥提供的__add__这个函数，当调⽤+实现加法运算的时候，实际上是调⽤了__add__⽅法。
⽅法说明何时调⽤⽅法
__add__加法运算对象加法：x+y，x+=y
__sub__减法运算对象减法：x-y，x-=y
__mul__乘法运算对象乘法：xy，x=y
__div__除法运算对象除法：x/y，x/=y
__getitem__索引，分⽚x[i]、x[i:j]、没有__iter__的for循环等
__setitem__索引赋值x[i]=值、x[i:j]=序列对象
__delitem__索引和分⽚删除del x[i]、del x[i:j]
（⼆）加法运算重载符
1、概述
加法运算是通过调⽤__add__⽅法完成重载的，当两个实例对象执⾏加法运算时，⾃动调⽤__add__⽅法。
2、案例演⽰
编写程序 - 演⽰加法运算符重载.py
运⾏程序，查看结果
如果两个数组长度不相等，那么就会抛出异常
总结
本篇⽂章就到这⾥了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!。
运算符重载——精选推荐
运算符重载运算符重载学习运算符重载，让运算符能做⼀些原来做不了的事情，⽅便它的使⽤⼀、运算符重载的概念1、什么是运算符重载1.重载：重新载⼊，就像之前学的函数重载，对⼀个已有的函数赋值⼀个新的定义，因此同⼀个函数名就可以有不同的含义。
2.运算符也是可以重载的，⽐如cout在输出⼀个变量的时候，能接受不同类型的数据并输出，他就是重载了<<运算符，这个就是运算符重载3.所以运算符重载指的是对已有的运算符重新定义新的运算规则，以适应不同的数据类型，当然重载之后之前的运算规则还是有的2、为什么要进⾏运算符重载1.运算符重载之后可以让运算符去适应不同的数据类型，对于基本数据类型，系统给出了运算符的操作规则，对于⾃定义数据类型来说，系统不知道该给出什么规则class student{int id;int age;char name[20];public:student(int id,int age,const char* name){this->id=id;this->age=age;strcpy(this->name,name);}}student stu1(1,23,"张三");student stu2(2,24,"李四");stu1+stu2;//如果是这样相加，那么应该加的是什么呢？编译器是不知道的，所以编译器就提供了运算符重载这个机制，让⽤户⾃定义运算符的运算规则⼆、运算符重载1、运算符重载类中定义1.关键字：operator，通过关键字来定义运算符重载(跟写个函数⼀样)2.定义：函数返回值类型 operator 要加载的运算符(参数列表){函数体；}这⾥把运算符的使⽤，理解为调⽤函数，只是和平时的调⽤函数有⼀点区别#include<iostream>#include<string>using namespace std;class student{int id;int age;string name;public:student(int age){this->age = age;id = 1;name = "sss ";}student(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showstudent(){cout << id << "\t" << age << "\t" << name << endl;}student operator+(student& p1)//这个函数会返回⼀个新的对象{int x=this->age + p1.age;student p(x);return p;//返回的是⼀个对象，会调⽤拷贝构造}int operator-(int x){return this->id - x;}void operator+(student&p2){cout << this->id + p2.id << endl;}};//1.操作这个运算符之后，返回值类型是什么int main(){student p1(0, 1, "yunfei");int x = p1.operator-(1);cout << x << endl;student stu1(1, 23, "张三");student stu2(2, 24, "李四");//student stu3 = stu1.operator+(stu2);//student stu3 = stu1 + stu2;stu1 + stu2;//stu3.showstudent();system("pause");return 0;}注意：因为我们这个运算符是在类中写的，所以是通过对象调⽤的，那么this指针会占⼀个参数，⽽且是第⼀个参数，也就是说我们重载⼀个运算符，是在类中，⽽这个运算符是个单⽬运算符，那么参数列表就不⽤写东西了，是双⽬运算符，那么就需要传另⼀个参数进来绝⼤部分的运算符重载都可以参照上⾯这个+号重载2、运算符重载的特点1.⼏乎所有的运算符都可以被重载，除了 . :: ()?() ) sizeof()2.运算符重载基本出现在类中和结构体中3.运算符可以理解为函数的⼀个表现3、运算符重载的注意事项1.重载运算符，这个重载的运算符还是满⾜原来的原则，但不能说重载+号，结果做的事-号的事，这样会使运算符的运⽤上增加很⼤的难度2.运算符重载的参数，类中重载调⽤对象会占⼀个参数，就是this会占⼀个参数，参数列表就是⽤来表⽰运算符的操作的3.对于运算符重载的调⽤，可以直接使⽤运算符，也可以通过对象 . 出来调⽤4.考虑返回值，不同的运算符有不同的返回值，要记得满⾜运算符原来的规则4、使⽤友元函数，实现运算符重载1.类在已经实现且部分修改的情况下下，需要进⾏运算符重载，就可以通过友元的⽅式来进⾏重载#include<iostream>#include<string>using namespace std;class person{int id;int age;string name;public:person(int id, int age, string name){this->id = id;this->age = age;this->name = name;}void showperson(){cout << id << "\t" << age << "\t" << name << endl;}friend int operator+(person&p1, person&p2);};//形参使⽤的是类对象的引⽤，在实参传对象的时候不会调⽤拷贝构造int operator+(person&p1, person&p2){return p1.id + p2.id;}//1.操作这个运算符之后，返回值类型是什么int main(){person stu1(1, 23, "张三");person stu2(2, 24, "李四");int x = operator+(stu1, stu2);//显⽰调⽤int y = stu1 + stu2;//隐式调⽤cout << x << endl << y << endl;system("pause");return 0;}容器：#include<iostream>#include<vector>using namespace std;int main(){//int 是v1这个容器存的类型vector<int> v1;for (int i = 0; i < 10; i++){//push_back()是⼀个函数，功能是尾插元素v1.push_back(i + 1);}for (int i = 0; i < 10; i++){cout << v1[i] << "\t";}system("pause");return 0;}左移右移运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载，必须在类外重载，通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);cin >> p1 >> p2;cout << p1 << endl << p2 << endl;system("pause");return 0;}前++，后++运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}person& operator++()//前++{this->id++;return *this;}person& operator++(int)//后++,int是⼀个占位符，⽤来区分前++和后++的{static person temp = *this;//引⽤不能返回局部变量，要⽤静态变量this->id++;return temp;}friend ostream& operator<<(ostream& os, person& p1);friend istream & operator>>(istream & in, person & p2);};//左移右移运算符重载，必须在类外重载，通过友元实现ostream& operator<<(ostream& os, person& p1)//左移运算符{os << p1.id << endl;return os;//返回的是⼀个cout,⽽且只能⽤引⽤}istream & operator>>(istream & in, person & p2)//右移运算符{in >> p2.id;return in;}int main(){person p1(10), p2(20);//cin >> p1 >> p2;//cout << p1 << endl << p2 << endl;cout << p1 ;//10cout << p1++ ;//10cout << p1 ;//11cout << ++p1 ;//12cout << p1 ;//12system("pause");return 0;}等号运算符重载：#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}person& operator=(person&p1)//⽤不⽤引⽤传参，要看返回的对象会不会消失 {if (this->name != NULL){delete[]this->name;this->name = NULL;}this->name = new char[strlen() + 1];strcpy(this->name, );return *this;}void show(){cout << name << endl;}~person()//如果有申请函数，就要加上析构函数{if (name != NULL){delete[]name;name = NULL;}}};int main(){{person p1("张三"), p2("李四"), p3("王五");p1 = p2 = p3;p1.show();p2.show();p3.show();}//加上⼤括号，让对象死亡，就能调⽤析构函数system("pause");return 0;}智能指针和==号运算符重载：#include<iostream>using namespace std;class person{int id;public:person(int id){this->id = id;}void show(){cout << id << endl;}bool operator==(person& p){return this->id == p.id;}~person(){cout << "person的析构函数" << endl;}};class smartpointer{person* ps;//包含你要new出来的对象的类的指针public:smartpointer(person* p){ps = p;}//重载->person* operator->()//传回来的是地址，不是对象，不⽤引⽤{return ps;}//重载*person& operator*()//返回的是对象，会调⽤拷贝构造，所以⽤返回值⽤引⽤，就不会再调⽤拷贝构造了 {return *ps;//得到⼀个对象，}~smartpointer(){if (ps != NULL){delete ps;ps = NULL;}}};int main(){{smartpointer p(new person(5));p->show();(*p).show();person p1(1), p2(3);cout << (p1 == p2) << endl;}//有三个对象，所以析构函数执⾏了三次system("pause");return 0;}[]运算符重载：#include<iostream>using namespace std;class person{char* name;public:person(const char* name){this->name = new char[strlen(name) + 1];strcpy(this->name, name);}char& operator[](int index){return name[index];}~person(){if (name != NULL){delete[]name;name = NULL;}cout << "这是析构函数" << endl;}};int main(){person p("asdfg");cout << p[3] << endl;system("pause");return 0;}c++引⽤作为函数返回值：1.以引⽤返回函数值，定义函数时需要在函数名前加 &2.⽤引⽤返回⼀个函数值的最⼤好处是，在内存中不产⽣被返回值的副本3.返回值为引⽤的时候，返回的是⼀个地址，隐形指针4.当返回值不是引⽤时，编译器会专门给返回值分配出⼀块内存的引⽤作为返回值，必须遵守以下规则：（1）不能返回局部变量的引⽤。
运算符重载
sizeof (长度运算符)
(3) 重载运算符的函数不能有默认的参数，否则就改变了 运算符参数的个数。 (4) 重载的运算符必须和用户自定义类型的对象一起使用， 其参数至少应有一个是类对象(或类对象的引用)。也 就是说，参数不能全部是C++的标准类型，以防止用 户修改用于标准类型数据的运算符的性质。
operator+(Complex &c2)，进行求值，得到两 个复数之和。
为了重载运算符，必须定义一个函数，并告诉编译器， 遇到这个重载运算符就调用该函数，由这个函数来完成 该运算符应该完成的操作。 这种函数称为运算符重载函数，它通常是类的成员函数 或者是友元函数。 运算符的操作数通常也应该是类的对象。 运算符被重载后，其原有的功能仍然保留，没有丧失或 改变。 通过运算符重载，扩大了C++已有运算符的作用范围， 使之能用于类对象。
void String∷display( ) { cout<<p;}l operator>(String &string1,String &string2) 函数 { if(strcmp(string1.p,string2.p)>0) return true; else return false; } int main( ) { String string1(″Hello″),string2(″Book″); cout<<(string1>string2)<<endl; }
//定义3个复数对象 //调用复数相加函数 //输出c1的值 //输出c2的值 //输出c3的值
调用方式不直观、不方便、太烦琐。
能否也和整数的加法运算一样，直接用加号“+”
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
新建工程时，不要建立在默认路径上 定义类的时候，最后必须有一个分号
2014-6-29
1
using namespace std;
namespace是指标识符的可见范围。C++标准
程序库中的所有标识符都被定义于一个名为
std的namespace中。 使用using namespace std后，命名空间std内定 义的所有标识符都有效。
14-6-29 23
§8.2 重载运算符
三、二元运算符
方式二，友员函数重载运算符：
type operator@( X obj1，X obj2) { …… }; 显式调用方式：operator@( objX1, objX2 ) 隐式调用方式：objX1 @ objX2 二元运算符超载函数operator@所需的两个操作数都 必须通过函数参数传递，因此，它需两个参数。 用成员函数和友元函数重载运算符，它们传递的参 数不一样，也就导致它们实现的代码不一样。
2014-6-29
2
iostream和iostream.h的区别
C语言版本中，将标准库功能定义在全局空间
里，声明在带.h后缀的头文件里
C++标准为了和C区别开，也为了正确使用命
名空间，规定头文件不使用后缀.h。
当使用<iostream.h>时，相当于在C中调用库 函数，使用的是全局命名空间 当使用< iostream>的时候，该头文件没有定义 全局命名空间，必须使用namespace std；
1+2j 2+3j 3+5j
13
对于两个复数相加，定义了成员函数
add_Com( Com)实现该操作，使用
obj1.add_Com( obj2);表示函数调用，不太直观，
能否表示为obj1 + obj2呢？ C++约定，由关键字operator加上一个运算符， 如operator + 组成一个特殊的函数名，定义成员 函数，则可以用obj1 + obj2表示该成员函数调 用，即：obj1.operator+(obj2)。
隐式调用方式：@ objX 或objX@
由于友元函数没有this指针，因此必须有一个 参数。
2014-6-29
22
§8.2 重载运算符
三、二元运算符
二元运算符，需要两个操作数。
方式一，成员函数重载运算符：
type X::operator@( X obj) { …… }; 显式调用方式：objX1.operator@( objX2 ) 隐式调用方式：objX1 @ objX2 二元运算符重载函数operator@所需的第一个操 作数通过this指针隐含的传递，第二个操作数通 过函数参数传递，因此，它只需一个参数。
2014-6-29 9
§8.1 概述
C++中，运算符的重载是通过运算符函数
进行的。
C++中有一个特殊的成员函数：类型转换 函数，它与运算符函数语法相似。
2014-6-29
10
§8.1 概述
C++中大部分运算符都可以被重载。
+ * / % ^ &
|
-= << >= ->
~
*= >> && []
main() { Com obj1(1, 2), obj2(2,3); Com obj3 = obj1.operator+(obj2); Com obj4 = obj2 + obj3; } operator + (……)称为运算符重载函数 obj1.operator+(obj2)称为显式调用 obj1 + obj2称为隐式调用
18
unsigned int counter::operator () ( ) { return value; my_counter = 1 } my_counter = 2 main() my_counter = 3 { my_counter = 4 counter my_counter; my_counter = 5 for( int i = 0; i < 6; i++) my_counter = 6 { my_counter = 5 my_counter ++; cout << “my_counter = ” << my_counter() << endl; } my_counter --; cout << “my_counter = ” <<my_counter() << endl; }
2014-6-29 8
//例：一个字符串类的例子 void main() class String { { String x, y; int length; x.set_contents(5, “Hello”); char * contents; public: y.set_contents(5, “World!”); String(); y = x.strcat( y ); ~String(); } void set_contents( int, char *); 如果能表示为： String strcat( String); y = x + y; }; 就更简洁了。 为了表达上的方便，希望已定义好的运算符，也可以在 特定类的对象上以新含义进行解释，如在String类中， 运算符“+”能表示两个字符串的合并。这就是对运算符 进行重载，使其能对新类的对象进行操作。
2014-6-29
4
第八章 运算符重载
概述
重载运算符
几种典型运算符重载
不同类型数据间的转换
2014-6-29
5
§8.1 概述
面向对象的核心概念之一是多态性。
所谓多态性是指一个名字（或符号）
具有多种含义。
在静态编译时支持的多态性称为编 译时多态性，也称静态多态性。 在动态运行时支持的多态性称为运 行时多态性，称为动态多态性。
three_d operator ++ ( );
2014-6-29 24
例：创建一个名为three_d的类，该类含有三维空间中 一对象的坐标。现要求重载“+”运算符，“=”运算符 和“++”运算符。 class three_d
{
int x, y, z; public: three_d operator + ( three_d); three_d operator = (three_d);
2014-6-29
19
§8.2 重载运算符
一、运算符重载的语法形式
运算符重载时，运算符重载函数只能定义为两
种方式，即类的成员函数方式和友元函数方式。
两者的差别在于：成员函数具有this指针，而友 元函数没有this指针。 由于运算符重载能对旧运算符赋予新的含义， 因此使用运算符重载时，一定要注意一点：即
运算符的新的含义应该与旧的含义相近，以避
免阅读程序中带来麻烦。
2014-6-29 20
§8.2 重载运算符
二、一元运算符
一元运算符，不论是前缀还是后缀，都 需要一个操作数。 方式一，成员函数重载运算符：
type X::operator@( ) { …… };
显式调用方式：objX.operator@( ) //( )不能少 隐式调用方式：@ objX 或objX@
15
§8.2 重载运算符
一、运算符重载的语法形式
运算符重载是通过一个运算符重载函数进行的 运算符函数是成员函数
函数返回类型 类名 关键字 被重载的运算符 type ClassName::operator@(参数表) { 运算符函数名称 //相对于该类而定义的操作 } 运算符函数是友元函数 type operator@(参数表) { //相对于该类而定义的操作 }
2014-6-29 3
namespace std及头文件包含中的错误
using namespace std后面必须有分号。
当使用<iostream.h>时，就不要语句：
using namespace std；
当使用< iostream>的时候，必须用语句：
using namespace std；
一元运算符重载函数operator@所需的一个
操作数通过this指针隐含的传递，因此，它的 参数表为空。
2014-6-29 21
§8.2 重载运算符
二、一元运算符
方式二，友元函数重载运算符：
type operator@( X obj) { …… }; 显式调用方式：operator@( objX )
!
/= >>= || ()
=
%= <<= ++ new
<
^= == -delete
>
&= != ->* new[ ]
+=
!= <= „ delete[ ]
少数C++运算符不能被重载。
. .* :: ?: sizeof
2014-6-29
11
§8.1 概述
C++只能重载已有的运算符，而不能创造
2014-6-29
6
§8.1 概述
静态多态性是通过重载来实现的：包
括函数重载和运算符重载。
应用重载过程中应注意二义性问题。
动态多态性通过虚函数来实现。
2014-6-29