1． *** 作符重载就是把 *** 作符比如=，+，-，，/这些运算符赋于新的意义。 2． *** 作符重载的目的： C++有许多内置的数据类型，包括int，char，double等，每一种类型都有许多运算符，例如加+，减，乘，除等。当用户定义了类的对象时，两个对象之间是不能进行这些 *** 作的，比如hyong类的对象a+b，这样的语句如果没有重载+运算符就会出错。但C++允许用户把这些运算符添加到自已的类中以方便类对象之间的运算就像内置类型的运算一样方便，比如对象a+b这样就很明白更容易懂，当然也可以在类中定义一个对象间相加的函数，比如aadd(b)调用函数add()以实现两个对象a和b相加，但是这条语句没有比a+b更容易让人理解。 3．怎样实现 *** 作符重载： 要实现 *** 作符重载就要使用 *** 作符重载函数， *** 作符重载函数用关键字operator实现，其形式为：返回类型 operator *** 作符 (参数列表){}。 *** 作符重载函数是一个函数，只不过这个函数的函数名为operator再加上后面要重载的 *** 作符而已，比如要重载+号，则： hyong operator +(hyong m){}这就声明了一个返回类型为hyong的 *** 作符函数，其函数名为operator + 4．作为类的成员和友元或者独立于类的区别 当 *** 作符重载函数作为类的成员函数时， *** 作符重载函数的参数会比作为友元或者独立于类的 *** 作符重载函数少一个参数，因为 *** 作符重载类成员函数把调用该函数的第一个类的对象作为函数的第一个参数，也就是隐含的this指针指向调用该函数的第一个对象，所以会少一个参数。 5．调用 *** 作符重载函数的方式：51调用类中的 *** 作符重载函数的方法：当调用类中定义的 *** 作符重载函数时最左边的对象是调用 *** 作符重载函数的对象。比如在类hyong中重定义的+ *** 作符 hyong operator +(hyong m){}，有类hyong的对象m和n则调用 *** 作符重载函数的方法有m+n和moperator +(n)，前一条语句会自动转换为后面这条语句，且m+n的表达式中最左边的对象是调用 *** 作符重载函数的对象，而最右边的那个将被作为参数传送。也就是说n+m会转换成noperator +(m)。要记住当调用类中定义的 *** 作符重载函数时最左边的对象是调用 *** 作符重载函数的对象。52 调用友元或独立的 *** 作符重载函数的方法：当调用类的友元 *** 作符重载函数或独立的 *** 作符函数时语句m+n会转换为显示的调用方式，比如有友元或独立 *** 作符重载函数hyong operator +(hyong a, hyong b){}则当出现m+n时会转换成语句operator +(m, n)表达式的第一个对象传给第一个参数，第二个对象传给第二个参数。 6．需把其作为类的友元或者类的成员一般来说 *** 作符重载函数一般不要求作为类的成员函数或者是友元函数，一般情况下可以将 *** 作符重载函数作为类的成员函数。但是有一种情况必须要求 *** 作符函数作为类的友元函数或者是独立的函数，就是一个内置类型和对象相加的情况。比如有语句m+1和1+m第一条可以在类中定义 *** 作符函数的形式为hyong operator +(int i){}，语句m+1可以调用这个函数是正确的，但对于1+m就不能调用这个函数了，因为类中的 *** 作符重载函数是最左边的对象是调用该函数的对象，但1+m最左边的是一个内置整型类型1，所以不会调用这条语句，对于这种语句就只能把 *** 作符重载函数定义为独立的函数或类的友元函数即形如hyong operator +(int i , hyong a){}这样1+m就会转换成operator +(1, m)这样就是正确的。当然如果这个 *** 作符重载函数需要访问类中的私有成员时，就应把该函数定义为类的友元函数，如果不需要访问类中的私有成员，则可以定义为友元也可以定义为独立函数。 7．必须把它作为类成员函数的运算符有：()，[]，->和任何赋值运算符，重载这些运算符时必须把 *** 作符函数声明为类的成员函数。 8．重载 *** 作符的限制：81 并不是所有的 *** 作符都能被重载。除了 ， ，:: ， : ，sizeof，typeid这几个运算符不能被重载，其他运算符都能被重载82 重载不能改变该运算符用于内置类型时的函义，程序员不能改变运算符+用于两个int型时的含义。83 运算符函数的参数至少有一个必须是类的对象或者类的对象的引用。这种规定可以防止程序员运用运算符改变内置类型的函义。84 重载不能改变运算符的优先级。85 重载不能改变运算符的结合律。86 重载不能改变运算符 *** 作数的个数。比如+需要两个 *** 作数，则重载的+也必须要有两个 *** 作数。 9．返回类型问题 在某些情况下 *** 作符函数必须返回一个对象类型作为返回值，比如有hyong的对象a,b,c则语句a=b+c其中重载的+ *** 作符就必须返回一个hyong类型的一个对象，以便赋给对象a，不然该语句就会出错。当然你可以在语句中返回一个临时对象，也可以返回一个对象的引用，或者返回this指针，不过返回临时对象会浪费内存开销，所以最好返回类对象的一个引用。 10．参数传递问题 *** 作符函数可以按值传递也可以按引用传递，这根据 *** 作符而定，比如对于+运算符既可以把对象按值传递给 *** 作符函数也可以按引用传递给 *** 作符函数，而且+ *** 作符不会改变原 *** 作数的值，所以应把传递类型声明为const，比如hyong operator +(const hyong &a, const hyong &b){}。
在Java 中，同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。在这种情况下，该方法就被称为重载（overloaded ），这个过程称为方法重载（method overloading ）。方法重载是Java 实现多态性的一种方式。如果你以前从来没有使用过一种允许方法重载的语言，这个概念最初可能有点奇怪。但是你将看到，方法重载是Java 最激动人心和最有用的特性之一。
当一个重载方法被调用时，Java 用参数的类型和（或）数量来表明实际调用的重载方法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java 调用一个重载方法时，参数与调用参数匹配的方法被执行。
下面是一个说明方法重载的简单例子：
// Demonstrate method overloading
class OverloadDemo {
void test() {
Systemoutprintln("No parameters");
}
// Overload test for one integer parameter
void test(int a) {
Systemoutprintln("a: " + a);
}
// Overload test for two integer parameters void test(int a，int b) { Systemoutprintln("a and b: " + a + " " + b);}
// overload test for a double parameter
double test(double a) {
Systemoutprintln("double a: " + a);
return aa; }}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()obtest();obtest(10);obtest(10，20);result = obtest(12325);Systemoutprintln("Result of obtest(12325): " + result);
}
}
该程序产生如下输出：
No parameters
a: 10
a and b: 10 20
double a: 12325
Result of obtest(12325): 151905625
从上述程序可见，test()被重载了四次。第一个版本没有参数，第二个版本有一个整型参数，第三个版本有两个整型参数，第四个版本有一个double 型参数。由于重载不受方法的返回类型的影响，test()第四个版本也返回了一个和重载没有因果关系的值。
当一个重载的方法被调用时，Java 在调用方法的参数和方法的自变量之间寻找匹配。但是，这种匹配并不总是精确的。在一些情况下，Java 的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：
// Automatic type conversions apply to overloading
class OverloadDemo {
void test() {
Systemoutprintln("No parameters");
}
// Overload test for two integer parameters void test(int a，int b) { Systemoutprintln("a and b: " + a + " " + b);}
// overload test for a double parameter
void test(double a) {
Systemoutprintln("Inside test(double) a: " + a);
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
int i = 88;
obtest();obtest(10，20);
obtest(i); // this will invoke test(double)
obtest(1232); // this will invoke test(double)
}
}
该程序产生如下输出：
No parameters
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 1232
在本例中，OverloadDemo 的这个版本没有定义test(int) 。因此当在Overload 内带整数参数调用test()时，找不到和它匹配的方法。但是，Java 可以自动地将整数转换为double 型，这种转换就可以解决这个问题。因此，在test(int) 找不到以后，Java 将i扩大到double 型，然后调用test(double) 。当然，如果定义了test(int) ，当然先调用test(int) 而不会调用test(double) 。只有在找不到精确匹配时，Java 的自动转换才会起作用。
方法重载支持多态性，因为它是Java 实现“一个接口，多个方法”范型的一种方式。要理解这一点，考虑下面这段话：在不支持方法重载的语言中，每个方法必须有一个惟一的名字。但是，你经常希望实现数据类型不同但本质上相同的方法。可以参考绝对值函数的例子。在不支持重载的语言中，通常会含有这个函数的三个及三个以上的版本，每个版本都有一个差别甚微的名字。例如，在C语言中，函数abs( )返回整数的绝对值，labs( ) 返回long 型整数的绝对值( )，而fabs( )返回浮点值的绝对值。尽管这三个函数的功能实质上是一样的，但是因为C语言不支持重载，每个函数都要有它自己的名字。这样就使得概念情况复杂许多。尽管每一个函数潜在的概念是相同的，你仍然不得不记住这三个名字。在Java 中就不会发生这种情况，因为所有的绝对值函数可以使用同一个名字。确实,Java 的标准的类库包含一个绝对值方法，叫做abs ( )。这个方法被Java 的math 类重载，用于处理数字类型。Java 根据参数类型决定调用的abs()的版本。
重载的价值在于它允许相关的方法可以使用同一个名字来访问。因此，abs这个名字代表了它执行的通用动作（general action ）。为特定环境选择正确的指定（specific ）版本是编译器要做的事情。作为程序员的你，只需要记住执行的通用 *** 作就行了。通过多态性的应用，几个名字减少为一个。尽管这个例子相当简单，但如果你将这个概念扩展一下，你就会理解重载能够帮助你解决更复杂的问题。
当你重载一个方法时,该方法的每个版本都能够执行你想要的任何动作。没有什么规定要求重载方法之间必须互相关联。但是，从风格上来说，方法重载还是暗示了一种关系。这就是当你能够使用同一个名字重载无关的方法时，你不应该这么做。例如，你可以使用sqr这个名字来创建一种方法，该方法返回一个整数的平方和一个浮点数值的平方根。但是这两种 *** 作在功能上是不同的。按照这种方式应用方法就违背了它的初衷。在实际的编程中，你应该只重载相互之间关系紧密的 *** 作。
711 构造函数重载
除了重载正常的方法外，构造函数也能够重载。实际上，对于大多数你创建的现实的
类，重载构造函数是很常见的，并不是什么例外。为了理解为什么会这样，让我们回想上一章中举过的Box类例子。下面是最新版本的Box类的例子：
class Box { double width; double height; double depth;
// This is the constructor for Box
Box(double w，double h，double d) {width = w; height = h;depth = d;
}
// compute and return volume double volume() { return width height depth;}}
在本例中，Box() 构造函数需要三个自变量，这意味着定义的所有Box对象必须给Box() 构造函数传递三个参数。例如，下面的语句在当前情况下是无效的：
Box ob = new Box();
因为Box( )要求有三个参数，因此如果不带参数的调用它则是一个错误。这会引起一些重要的问题。如果你只想要一个盒子而不在乎 (或知道)它的原始的尺寸该怎么办？或，如果你想用仅仅一个值来初始化一个立方体，而该值可以被用作它的所有的三个尺寸又该怎么办？如果Box 类是像现在这样写的，与此类似的其他问题你都没有办法解决，因为你只能带三个参数而没有别的选择权。
幸好，解决这些问题的方案是相当容易的：重载Box 构造函数，使它能处理刚才描述的情况。下面程序是Box 的一个改进版本，它就是运用对Box构造函数的重载来解决这些问题的：
/ Here，Box defines three constructors to initialize
the dimensions of a box various ways
/
class Box {
double width; double height; double depth; // constructor used when all dimensions specified Box(double w，double h，double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified Box() { width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created Box(double len) { width = height = depth = len;}
// compute and return volume double volume() { return width height depth;}}
class OverloadCons {
public static void main(String args[]) { // create boxes using the various constructorsBox mybox1 = new Box(10，20，15);Box mybox2 = new Box();Box mycube = new Box(7);
double vol;
// get volume of first box
vol = mybox1volume();
Systemoutprintln("Volume of mybox1 is " + vol);
// get volume of second box
vol = mybox2volume();
Systemoutprintln("Volume of mybox2 is " + vol);
// get volume of cube
vol = mycubevolume();
Systemoutprintln("Volume of mycube is " + vol);
}
}
该程序产生的输出如下所示：
Volume of mybox1 is 30000
Volume of mybox2 is -10
Volume of mycube is 3430
在本例中，当new执行时，根据指定的自变量调用适当的构造函数。
继承就是说嘛。这个方法来自于父类的。。只要继承了就可以得到父类的方法，想想哦。如果是说有一个人类。是父类。但。人类里面又有。老师 和学习子类。而老师和学生都要吃饭是吧。这个。方法是一样就可以写在父类里，一但继承就可以得到吃饭这个功能，但是。他们确来自于不同的子类，重写嘛。就是说。你有吃饭的功能嘛。但两个吃法不一样，这时就要重新写方法虽然父类里面有这个方法但是哦。我可以把名字参数一样，就可以用新方法把原方法进行重写，重而放弃了旧方法而使用新方法但不影响其它类调用 原来的老方法，，重载就是说你方法名字可以一样，但是参数不一样，就是说，同为吃饭这个方法，一个传入了筷子一个传入了。刀和差。重而吃饭的方法不一样了。。但方法名同为吃饭。 多态好像是。一个接口里面提供了方法，实现后实现里面的方法，从而达到一个事件的多种形态，接口好像就是。提供一个标准，让别个去实现。。只要对得上。你就接上哒。对不上。你就接不上。就像USB，你必须拿USB的接口才可以弄进去 。如果拿串口，就不行哒。
所谓函数重载是指同一个函数名可以对应着多个函数的实现。例如，可以给函数名add()定义多个函数实现，该函数的功能是求和，即求两个 *** 作数的和。其中，一个函数实现是求两个int型数之和，另一个实现是求两个浮点型数之和，再一个实现是求两个复数的和。每种实现对应着一个函数体，这些函数的名字相同，但是函数的参数的类型不同。这就是函数重载的概念。函数重载在类和对象的应用尤其重要。
函数重载要求编译器能够唯一地确定调用一个函数时应执行哪个函数代码，即采用哪个函数实现。确定函数实现时，要求从函数参数的个数和类型上来区分。这就是说，进行函数重载时，要求同名函数在参数个数上不同，或者参数类型上不同。否则，将无法实现重载。
参数类型上不同的重载函数
下面举一个在参数类型不同的重载函数的例子：
#include <iostreamh>
int add(int, int);
double add(double, double);
void main()
{
cout<<add(5, 10)<<endl;
cout<<add(50, 105)endl;
}
int add(int x, int y)
{
return x+y;
}
double add(double a, double b)
{
return a+b;
}
该程序中，main()函数中调用相同名字add的两个函数，前边一个add()函数对应的是两个int型数求和的函数实现，而后边一个add()函数对应的是两个double型数求和的函数实现。这便是函数的重载。
以上程序输出结果为：
15
155
参数个数上不同的重载函数
下面举一个在参数个数上不相同的重载函数的例子：
#include <iostreamh>
int min(int a, int b);
int min(int a, int b, int c);
int min(int a, int b, int c, int d);
void main()
{
cout<<min(13, 5, 4, 9)<<endl;
cout<<min(-2, 8, 0)<<endl;
}
int min(int a, int b)
{
return a<ba:b;
}
int min(int a, int b, int c)
{
int t = min(a, b);
return min(t,c);
}
int min(int a, int b, int c, int d)
{
int t1 = min(a, b);
int t2 = min(c, d);
return min(t1, t2);
}
该程序中出现了函数重载，函数名min对应有三个不同的实现，函数的区分依据参数个数不同，这里的三个函数实现中，参数个数分别为2,3和4，在调用函数时根据实参的个数来选取不同的函数实现。
构造函数的作用就是实例化一个对象。 当你new 了一个对象，会调用它的构造函数。
构造函数重载就是可以写多个构造函数，参数类型、个数不同。和普通函数重载是一样的。
class Person{
private String id;
private String name;
public Person(){
//default
}
public Person(String id, String name){
thisid=id;
thisname=name;
//default
}
}
不是很明白“函数出现两次”的意思，以下就实现说下看法：
template <class T> class LeftistHeap中：
（1）void destroy(LeftistNode<T> &heap)是其私有函数，因为该类的使用者不应该持有LeftistNode<T>指针；
（2）template <class T> void LeftistHeap<T>::destroy()是其公有函数，如果没有void destroy(LeftistNode<T> &heap)，其中的所有实现都需要在这个公有函数中出现。如果还需要删除其他节点而不只是根节点，那么这些实现代码又得再写一遍。减少重复代码，是void destroy(LeftistNode<T> &heap)存在的意义。
（3）void destroy(LeftistNode<T> &heap)采用递归方式实现，使得代码最简，如果不用递归，我所想到的方式是用循环。如此就会增加很多代码，因为需要确定一个节点左右孩子节点指针都为NULL时，才能删除该节点。这样就需要保存从根节点到可以删除的第一个节点之间的所有节点，然后逆向逐一删除。
D可以。
重载需要满足一定的条件，但不管怎样，目的就一个，编译器需要能够区分各个同名函数，即在考虑默认参数的基础上，编译器需要在各种情况下都能够根据具体调用时使用的参数选出唯一一个函数原型。
上面的例子中，对于给定的调用语句f(0)和f(0,0)和f(0,0,00)：
A）f(int)无法区分；
B）f(int,int)无法区分；
C）f(int,int,double)无法区分；
D）f(double）可以区分；
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）