函数重载和运算符重载

编程技术中的运算符重载和函数重载编程技术中的运算符重载和函数重载是两个非常重要的概念。

它们可以让程序员更加灵活地使用已有的运算符和函数，从而提高编程效率和代码可读性。

本文将分别介绍运算符重载和函数重载的概念、用法和应用场景。

一、运算符重载运算符是编程语言中的一种特殊符号，用于表示不同的数学和逻辑运算。

在传统的编程语言中，每个运算符都有固定的语义和操作对象。

但是，在某些情况下，我们可能希望对已有的运算符进行自定义的操作。

这就是运算符重载的概念。

运算符重载可以让程序员重新定义运算符的操作行为。

通过重载运算符，我们可以使得运算符对用户自定义的类型也能够进行操作。

例如，我们可以定义一个名为"Vector"的类，然后重载"+"运算符，使得两个"Vector"对象可以相加。

这样，我们就可以像操作普通的整数或浮点数一样，对"Vector"对象进行加法运算。

运算符重载的语法和用法因编程语言而异。

在C++中，运算符重载通过定义特殊的成员函数来实现。

例如，重载"+"运算符的成员函数的定义如下：```cppclass Vector {public:Vector operator+(const Vector& other) {Vector result;// 实现向量相加的逻辑return result;}};```通过重载运算符，我们可以使得代码更加简洁和易读。

例如，我们可以使用如下方式对两个"Vector"对象进行相加：```cppVector v1, v2;Vector sum = v1 + v2;```二、函数重载函数重载是指在同一个作用域中，可以定义多个同名函数，但是这些函数的参数列表必须不同。

函数重载可以让程序员使用相同的函数名来实现不同的功能，从而提高代码的可读性和复用性。

函数重载的用法非常灵活。

C++基础系列——运算符重载1. 运算符重载简介所谓重载，就是赋予新的含义。

函数重载（Function Overloading）可以让⼀个函数名有多种功能，在不同情况下进⾏不同的操作。

同样运算符重载（Operator Overloading）可以让同⼀个运算符可以有不同的功能。

可以对 int、float、string 等不同类型数据进⾏操作<< 既是位移运算符，⼜可以配合 cout 向控制台输出数据也可以⾃定义运算符重载：class Complex{public:Complex();Complex(double real, double imag);Complex operator+(const Complex &a) const;void display() const;private:double m_real;double m_imag;};// ...// 实现运算符重载Complex Complex::operator+(const Complex &A) const{Complex B;B.m_real = this->m_real + A.m_real;B.m_imag = this -> m_imag + A.m_imag;return B;// return Complex(this->m_real + A.m_real, this->m_imag + A.m_imag);}int main(){Complex c1(4.3, 5.8);Complex c2(2.7, 3.7);Complex c3;c3 = c1 + c2; // 运算符重载c3.display();return 0;}运算结果7 + 9.5i运算符重载其实就是定义⼀个函数，在函数体内实现想要的功能，当⽤到该运算符时，编译器会⾃动调⽤这个函数，它本质上是函数重载。

使用重载函数注意：
不要使用重载函数描述不相干的函数 在类中，构造函数和普通成员函数均可以
重载 避免与函数的默认参数产生二义性
二、运算符重载
运算符重载(operate overloading)就是 赋予已有的运算符多重含义。
运算符重载实质是函数重载，运算符重载 的选择与函数重载类似，会根据运算符的 操作数的类型、个数和顺序来进行运算符 函数的选择。
#include<iostream.h> str#iinngc:l:usdter<isntgr(icnhga.rh>*s) v{}ossccsssc{s{{ittohtttolsstlsssls*drruarrrueptrepttepsi1trii3tc{pn=rin=rrn=pmn.<nn.<lprgncngncign=agp<*ggp<auitepgtepnte'irssrssbv\hwy:hwyghwnsit1ssitsla0=(:=(:=(tnr=ttnrit'scssscs:sc)rt1"rrt3scesss~ivci;thpt1hpsih1(.T23(.t::tttsnohn}ra,r.a,tza()gh(()grrrrttiatlrsilrsrer";eass;eiiiirdre[)ne[1i;[Ttt1ttnnnniglnl;gnl.nlhl)rlggggnep*e(e}(gesgeiei;2e(((gtrsnsnstnp(nsns)ncsi(lipg)gthg)ig(;(htn)en;t;tr;t;nti)a)artnthhih}ths<<ri{((;+n++<p<snd))}1g1s1aere*ige;]]i]nonszl{{;&;z;ddgd)&eercseelrl;s=teo1)m;a;/18etu)om/)0ut..;)构sr<""/;pn<造);//;s;/复}lp函构e<制n<数造ge构tn函hd造;l数};重} 载

c++ 运算符重载规则
运算符重载是C++中的一项重要特性，它允许程序员重新定义已有的运算符，使其能够适应自定义的数据类型和类。

但是，对于运算符重载的规则，有一些需要注意的地方。

首先，运算符重载必须具有至少一个操作数是自定义的数据类型或类。

其次，运算符重载必须遵循相同的优先级和结合性规则，以确保程序的正确性。

另外，运算符重载需要通过成员函数或全局函数来实现，每个运算符只能被重载一次。

此外，在运算符重载函数中，参数的数量和类型必须与运算符本身的参数数量和类型相匹配。

最后，运算符重载可以被用于自定义类的对象之间的操作，如加减乘除等基本运算。

但是，应该注意运算符重载可能会导致代码可读性和维护性的问题，因此应该谨慎使用。

总之，运算符重载是 C++ 中一个强大且灵活的特性，但需要注意其规则和使用方式，以确保程序的正确性和可读性。

- 1 -。

简述面向对象中的多态
面向对象中的多态是指一个对象可以以多种形态存在。

简单来说，多态就是同一个方法可以有不同的实现方式。

在面向对象的程序设计中，多态是一种非常重要的概念。

它能够提高代码的灵活性和可扩展性，使得代码更易于维护和扩展。

多态的实现方式主要有两种：静态多态和动态多态。

静态多态是通过函数的重载和运算符的重载来实现的。

函数的重载是指在同一个类中定义多个同名函数，但这些函数具有不同的参数列表。

运算符的重载是指对于某个运算符，可以定义多个不同的操作方式。

在编译时，编译器会根据调用时的参数类型来确定具体调用的函数或运算符。

动态多态是通过继承和虚函数来实现的。

继承是指子类可以继承父类的属性和方法，通过定义一个指向父类对象的指针或引用，可以调用子类对象中重写的方法。

虚函数是在父类中声明为虚函数的函数，子类可以对其进行重写。

在运行时，根据实际对象的类型来调用相应的方法。

多态具有很多优点。

首先，它可以提高代码的重用性，一个类的方法可以被多个类继承并重写，这样可以减少代码的重复编写。

其次，多态可以使代码更加灵活，可以根据需要动态地根据对象的类型来调用相应的方法。

再次，多态可以提高代
码的可扩展性，当需要添加新的功能时，只需要在子类中重写相应的方法即可，而不需要修改已有的代码。

总之，多态是面向对象编程中非常重要的概念，通过使用多态可以使代码更灵活、可扩展和易于维护。

它是面向对象编程中的重要特性之一，值得我们深入理解和应用。

7.3 运算符重载
•7.3.2 单目运算符的重载 单目运算符重载时参数只有一个。
class Matrix{ public: Matrix operator –( ); //其他成员 //成员函数，参数表为空
}; Matrix Matirx::operator –( ) { Matirx m(rows,cols); //临时对象 for(int i=0;i<rows;i++) for(int j=0;j<cols;j++) m(m,j)= –(*this)(i,j); return m; }
7.3 运算符重载
Matrix & Matrix::operator=(Matrix &src) { //将 src 的所有元素都复制过来 for(int i=0;i<rows*cols;i++) mem[i]=src.mem[i]; return *this; }
7.3 运算符重载
3. 插入抽取运算符的重载 我们可以通过重载插入和抽取运算符来 获得这种效果。重载的运算符形式如下：
7.3 运算符重载
•7.3.4 特殊运算符的重载 1. 自增自减运算符的重载 如果将自增自减运算符定义为类的成员函数， 则应该没有参数。但是为了区分前缀和后缀， C++规定：后缀自增自减运算符定义时带有一 个整型参数，而前缀自增自减运算符时不带 参数，这样在编译时，系统就知道所重载的 是前缀还是后缀运算符了。
7.3 运算符重载
运算符的重载形式有两种，一种是重载为类 的成员函数，另一种是重载为独立的运算符 函数，一般是作为类的友元函数。运算符重 载的语法形式如下： <函数类型> operator <运算符> (<形参表>) { <函数体> }

};
void main()
{
Point p;
p.display();
}
答：
2.指出下面程序中的1处错误，并说明原因。
#include<iostream.h>
class CTest{
public:
CTest(){ x=20; }
private:
int x;
friend void friend_f(CTest fri);
3.构造函数是可以被派生类继承的。（）
4.构造函数和析构函数都可以是虚函数。（）
5.只有类中全部函数都为纯虚函数时，该类才被称为抽象类。（）
二、简答题（每小题5分，共20分。）
1.什么是封装性？请举例说明。
2.什么是函数重载和运算符重载？为什么要使用重载？
3.拷贝构造函数在哪几种情况下被调用？
4.什么是类？什么是对象？对象与类的关系是什么？
三、程序分析题（每小题10分，共40分。）
1.指出下面程序中的1处错误，并说明原因。
#include<iostream.h>
class Point
{
int X,Y;
public:
Point( ){X=0;Y=0;}
Point(int x=0,int y=0){X=x;Y=y;}
void display( ){cout<<X<<","<<Y<<endl;}
2.什么是函数重载和运算符重载？为什么要使用重载？
(1) 函数重载是指一个标识符可同时用于为多个函数命名；
(2) 运算符重载是指一个运算符可同时用于多种运算。也就是说，相同名字的函数或运算符在不同的场合可以表现出不同的行为。

4.3重载运算符的规则
（1）C++只允许已有的部分运算符实施重载。 （2）不能重载的运算符有五个。 （3）重载不改变操作数的个数。 （4）重载不改变运算符的优先级。 （5）运算符重载函数不能带默认值参数。 （6）运算符重载函数必须与自定义类型的对象联 合使用，其参数至少有一个类对象或类对象引用。 （7）C++默认提供 = 和 & 运算符重载。
例4.1 通过成员函数实现复数的加法。 class Complex { private: double real; double imag; public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} Complex complex_add(Complex &c2); void display(); };
int main() {Complex c1(3,4),c2(5,-10),c3; c3=c1+c2; cout<<"c1=";c1.display(); cout<<"c2=";c2.display(); cout<<"c1+c2=";c3.display(); return 0; }
说明： （1）用运算符重载函数取代了例 4.1中的加法成 员函数，从外观上看函数体和函数返回值都是相 同的。 （2）在主函数中的表达式c3=c2+c1 取代了例4.1 中的c3=plex_add(c2) ，编译系统将表达 式c3=c1+c2 解释为 c1.operator + ( c2 ) 对象c1调用的重载函数operator + ，以c2为实参 计算两个复数之和。

实验四函数重载和运算符重载(2学时)一、实验目的1．掌握函数的定义和调用方法。

2．练习重载函数的使用，注意与缺省参数的区别。

3．练习函数模板的使用。

4.练习运算符重载。

5．练习使用系统函数。

6．学习使用VC++的debug调试功能，使用step into追踪到函数内部。

二、实验任务1．定义一个简单的菜单类，运行时显示主菜单，可通过选择进入子菜单（可模仿ATM柜员机的模式，菜单内容可自行设定，相关功能函数可不用实现）：主菜单：取现的子菜单1.转账 1.5002.余额查询 2.10003.取现 3.1500Q(退出) 4.返回主菜单请选择(A/S/F/Q)?选择相应的选项后悔执行相应模块并回到主菜单，选择Q则退出。

2．编写重载函数Maxl可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。

3．使用重载函数模板重新实现上小题中的函数Maxl。

4．使用系统函数pow(X，y)计算X y的值，注意包含头文件math.h。

5．用递归的方法编写函数求Fibonacci级数，观察递归调用的过程。

6.写一个点point的类,并重载+实现两个点的坐标相加，和-实现求两点间的距离， >>、<<输入输出点的信息，（1）和（2）分别取点的x和y轴坐标。

三、实验步骤1．考虑抽取菜单的数据和相关操作。

2．分别编写四个同名函数maxl，实现函数重载，在main()函数中测试函数功能。

程序名：lab3_2．cpp。

3．使用函数模板实现求任意类型数的最大值，针对不同的参数个数，编写两个同名函数模板maxl，其参数个数不同，实现函数重载，在main()函数中测试函数功能。

程序名：lab3_3．cpp。

4．在main()函数中提示输入两个整数x、y，使用cin语句得到x、y的值，调用pow(x，y)函数计算x的Y次幂的结果，再显示出来。

程序名．1ab3_4.cpp。

5．编写递归函数int fib(int n)，在主程序中输入n的值，调用fib函数计算Fibonacci级数。

运算符重载的方法
运算符重载是指在类中重新定义某个运算符，使其能够用于类的实例。

重载运算符可以方便地对类对象进行加、减、乘、除等基本运算，也可以定义自定义运算符，以实现类特定的功能。

运算符重载的方法如下：
1.编写运算符重载函数：将要重载的运算符的符号作为函数名，如“+”、“-”、“*”、“/”等，对于自定义运算符可以自己命名。

2.指定参数个数和类型：重载函数需要参数，这些参数有不同的类型，可以是类的成员变量或其他类型的变量。

3.重载运算符要求：
（1）操作数至少有一个是类的实例，重载函数可以定义为类的成员函数或全局函数。

（2）运算符重载不能改变原有操作数的类型或个数。

（3）运算符重载函数可以返回任何类型的值，甚至可以是类的实例。

4.使用运算符：一旦重载运算符函数定义好之后，就可以像使用普通的运算符一样使用它。

需要注意的是，运算符重载不是万能的，对于某些运算符，如“&&”、“”等，是不能够重载的。

此外，在使用运算符重载时应该避免过于复杂的实现方式，以防止代码难以理解和维护。

{
rpart=rp;
ipart=ip;
}
Complex add( const Complex & com )
{
Complex temp ;
temp .rpart= com .rpart+rpart;
temp .ipart= com .ip+ipart;
return temp ;
}
2020/7/2
பைடு நூலகம்};
★单目运算符重载 ：
Complex Complex:: operator {
Complex temp;
( 单) 目无参数 双目一个参数
temp.rpart=-rpart;
temp.ipart)=-ipart;
return temp;
}
Complex c=-a+b;
(a.operator-( )).operator+(b)
};
point point::operator+ (point p1)
{ point p; p.x=x+p1.x; p.y=y+p1.y; return p; }
void main()
{ point p1(10,10),p2(20,20); p1=p1+p2 ;
p1.print(); ++p1; p1.print();
}
//(╳)
运算符成员函数——调用成员函数的对象隐式成为表达式的第一个运算数 外部运算符函数——其第一个参数直接对应表达式的第一个运算数；
x1=x2+x3;
operator+(x2, x3);
2020/7/2
6 6

简述运算符重载的规则。

篇一：运算符重载是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. 逻辑运算符重载逻辑运算符包括条件运算符和逻辑非运算符。

每个逻辑运算符都有一组默认的行为,可以通过运算符重载来自定义它们的行为。

2、对于任意一元运算符α：
(1)成员函数重载运算符
定义
type x::operator α( )
{…}
显式调用
objX.operator α( )
隐式调用
αobjX 或：ojbXα
(2)友元函数重载运算符
定义
type operator α(Xobj)
{…}
显式调用
operatorα(obj X)
隐式调用
友元函数重载运算符时，需要明确给出参数，不会出错。 3、不能用友元函数重载的运算符：
= 、 ( )、［］、- > 4、注意： (1)对THIS所指向的数据的任何改变都会影响到激活运算数函数的对象。 (2)可使用引用参数(指针)来解决重载时的二义性。
4.1.5 重载++和--
一、关于++和- 1、C中的++和- -的两种形式： 前缀：++i； 后缀：i--； 2、在C++中的约定 (显式地区分前缀和后缀) (1)对于前缀方式++i:
例4-1 1、重载“+”、“=”、“++”；读懂几个成员函数； 2、成员函数重载运算符，激活运算符的对象都是由THIS指针隐含传递的。
4.1.4 用友元函数重载运算符
1、成员函数重载可能造成的麻烦：成员函数重载的运算符不具有交换性。 原因：成员函数仅能被一个“实际对象”所调用，如果引起成员函数
调用的是一个值(非一个对象)，成员函数将不能正确工作。 2、可用友元函数解决这一问题：
5、除“=”以外，重载的运算符可以被任何派生类所继承， “=”需要每个类明确定义自己的解释；
6、 重载可能让程序的可读性下降，在使用时应模仿运算符的 习惯用法 。

第八章操作符重载重载是C++多态性的体现之一。

当定义新的数据类型之后，C++原有操作符提供的操作在语义往往不能满足对新的数据类型的对象进行操作，因此必须对C++原有操作符的操作语义进行扩充，这就是重载的应用需求背景。

8.1操作符重载概述当在同一作用域内声明两个或多个相同的名字(即标识符)时，称该名字被重载。

在同一作用域内的两个声明，如果声明的名字相同但是数据类型不同，则称这两个声明为重载声明。

C++规定，只有函数声明可以被重载，对象声明或类型声明不允许重载。

换言之，C++的这一规定将重载严格限制在函数范畴。

当重载的函数被调用时，从诸个可调用的重载函数( viable fu nctio ns )中究竟调用那一个函数则由调用时实参的类型与函数声明时形参的类型相比较结果的一致性决定。

这个选择与决定的过程称为重载解析。

在C++中,根据函数的定义者是谁可以将函数分为两类。

一类是由程序员定义的函数，它们往往被称为用户自定义函数，另一类则是系统提供的函数。

就系统提供的函数而言，根据它们的调用方式，又可以进一步分为两类。

一类是与用户自定义函数调用方式相同的系统函数，它们往往称为库函数或类库中的成员函数；另一类则沿用自然语言和数学语言的使用习惯，在各类表达式中完成相应的运算，它们往往称为操作符或运算符，但实际上是系统的预定义函数或操作符函数。

例如对整型对象x、y，x+y 实际表示对预定义函数’+'的调用。

x和y是预定义函数’+'的参数，但一般习惯上称为‘ + '的左操作数和右操作数。

由于操作符实际上也是函数，不同的只在于操作符是系统的预定义函数，因此操作符和用户自定义函数一样也可以重载。

以加法操作‘ +'为例，C++提供的‘ +'操作如果不考虑类库支持，则只能进行整数或实数的加法运算，若考虑类库支持则能够进行一般复数的运算。

如果用复数来表示电路中的电流和电压，根据电路理论，只有电流和电流才能进行相加减的运算；同理，只有电压和电压才能进行相加减的运算。

C++学习之路—运算符重载（⼆）运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式：（1）把运算符重载的函数作为类的成员函数；（2）运算符重载的函数不是类的成员函数，在类中把它声明为友元函数。

1 把运算符重载函数作为类的成员函数例1：为了便于说明问题，将重载函数的定义重写如下：1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问：“+”是双⽬运算符，为什么重载函数只有⼀个参数呢？实际上，运算符重载函数应当有两个参数，但是，由于重载函数是Complex类中的成员函数，因此有⼀个参数是隐含的，运算符函数是⽤this指针隐式的访问类对象的成员。

可以看到operator+访问了两个对象中的成员，⼀个是this指针指向的对象中的成员，⼀个是形参对象中的成员。

2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外，还可以是⾮成员函数。

在有关的类中把它声明为友元函数，即友元运算符重载函数。

例2：将运算符+重载为适⽤于复数加法，重载函数不作为成员函数，⽽放在类外，作为Complex类的友元函数。

1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐，只做了⼀处改动，就是将运算符重载函数作为类外的普通函数，并在Complex类中声明它为友元函数。

7
实现函数重载
函数重载是通过在类中定义两个或更多的同名的函 数来实现函数重载。 数来实现函数重载。 在函数重载中， 在函数重载中，函数的每个定义必须在函数签名中 不同。 不同。
8
函数签名
函数的签名被下面的部分定义： 函数的签名被下面的部分定义：
参数的数量 参数的类型 参数的顺序 返回类型不是函数签名的一部分
public class DaysInYear { private int days; public DaysInYear(int days) 1.DaysInYear DIY = new DaysInYear(); { 2.DaysInYear DIY = new DaysInYear(5); this.days = days; 3.DaysInYear DIY = new DaysInYear("5"); } public DaysInYear(String dayOne) 4.DaysInYear DIY = new DaysInYear(‘5’); 5.DaysInYear DIY； { days =Convert.ToInt32(dayOne); } 1.错误 错误 public void setDay(int newDays) 2.调用int构造函数 调 构造函数 { 3.调用string构造函数 调 构造函数 days = newDays; 4.调用int构造函数 调 构造函数 } 5.没有对象生成，需要 没有对 或者让 没有 象生成，需要new或者让它指向一 或者 … 个DaysInYear对象 对 }
函数重载： 函数重载：这个方法允许为两个或更多函数使用同样 的名字。 的名字。函数的每个重新定义必须使用不同的参数类 参数顺序或多个参数。 型、参数顺序或多个参数。 操作符重载： 操作符重载：这个方法允许用户定义的类型例如结构 和类，为使它们的对象易于操作而使用重载操作符。 和类，为使它们的对象易于操作而使用重载操作符。

使用“类名::”加以区分。 根据调用函数对象加以区分。
函数重载
范例 #include <iostream.h> class point { int x,y; public: point(int x,int y) { point::x=x; point::y=y; } float area() {return 0.0;} }; class circle:public point { int r; public: circle(int x,int y,int r1):point(x,y) { r=r1;} float area(){ return 3.14*r*r;} };
多态性概念

因此:

封装性是基础，用于实现类的定义； 继承性是关键，实现代码与数据的重用； 而多态性是补充，实现不同的行为表现，解决 程序的复杂性和易用性。 函数重载 运算符重载 动态联编

多态性的表现形式：

函数重载

C++中，当有一组函数完成相似功能时，函数名 允许重复使用，编译器根据参数表中参数的个数 或类型（不能根据形参变量名）来判断调用哪一 个函数，这就是函数的重载，且可以是成员函数 也可以是非成员函数。 重载函数仅仅靠函数的参数表，即参数的个数或 参数的类型进行区别。仅仅返回值不同的重载函 数是非法的。
高级语言（C++）程序设计
第15讲 函数与运算符重载
主要内容（2学时）

多态性概念 函数重载 运算符重载
多态性概念

面向对象中的多态性指系统发出同样的消 息被不同类型的对象接受时导致不同的行 为。这里的消息可理解为成员函数的调用， 而不同行为是指不同的函数实现。