有很多帖子抱怨操作员超载。
我觉得我必须澄清“操作员超载”的概念，对此概念提供另一种观点。
代码混淆？
这种说法是谬论。
可以用所有语言进行混淆...
通过函数/方法对C或Java中的代码进行混淆与通过操作符重载在C ++中进行处理一样容易：
// C++
T operator + (const T & a, const T & b) // add ?
{
T c ;
c.value = a.value - b.value ; // subtract !!!
return c ;
}
// Java
static T add (T a, T b) // add ?
{
T c = new T() ;
c.value = a.value - b.value ; // subtract !!!
return c ;
}
/* C */
T add (T a, T b) /* add ? */
{
T c ;
c.value = a.value - b.value ; /* subtract !!! */
return c ;
}
...即使在Java的标准界面中
再举一个例子，让我们看一下Java 的Cloneable接口：
您应该克隆实现此接口的对象。但是你可以撒谎。并创建一个不同的对象。实际上，这个接口太弱了，以至于它很有趣，您可以完全返回另一种对象：
class MySincereHandShake implements Cloneable
{
public Object clone()
{
return new MyVengefulKickInYourHead() ;
}
}
由于Cloneable接口可能会被滥用/混淆，是否应该出于相同的理由禁止使用C ++运算符重载？
我们可以重载类的toString()方法MyComplexNumber以使其返回一天中的字符串化时间。是否也应toString()禁止超载？我们可以破坏MyComplexNumber.equals使其返回一个随机值，修改操作数...等，等等，等等。
在Java，C ++或任何语言中，程序员在编写代码时必须尊重最少的语义。这意味着要实现一个add添加函数，一个Cloneable克隆实现方法以及一个++运算符。
到底是什么使人迷惑？
现在我们知道甚至可以通过原始的Java方法破坏代码，现在我们可以问问自己有关C ++中运算符重载的真正用法吗？
清晰自然的符号：方法与运算符重载？
下面，针对不同情况，我们将比较Java和C ++中的“相同”代码，以了解哪种编码风格更清晰。
自然比较：
// C++ comparison for built-ins and user-defined types
bool isEqual = A == B ;
bool isNotEqual = A != B ;
bool isLesser = A < B ;
bool isLesserOrEqual = A <= B ;
// Java comparison for user-defined types
boolean isEqual = A.equals(B) ;
boolean isNotEqual = ! A.equals(B) ;
boolean isLesser = A.comparesTo(B) < 0 ;
boolean isLesserOrEqual = A.comparesTo(B) <= 0 ;
请注意，只要提供了运算符重载，A和B在C ++中可以是任何类型。在Java中，当A和B不是基元时，即使对于类似于基元的对象（BigInteger等），代码也会变得非常混乱。
自然数组/容器访问器和下标：
// C++ container accessors, more natural
value = myArray[25] ; // subscript operator
value = myVector[25] ; // subscript operator
value = myString[25] ; // subscript operator
value = myMap["25"] ; // subscript operator
myArray[25] = value ; // subscript operator
myVector[25] = value ; // subscript operator
myString[25] = value ; // subscript operator
myMap["25"] = value ; // subscript operator
// Java container accessors, each one has its special notation
value = myArray[25] ; // subscript operator
value = myVector.get(25) ; // method get
value = myString.charAt(25) ; // method charAt
value = myMap.get("25") ; // method get
myArray[25] = value ; // subscript operator
myVector.set(25, value) ; // method set
myMap.put("25", value) ; // method put
在Java中，我们看到对于每个容器执行相同的操作（通过索引或标识符访问其内容），我们有不同的方法来执行操作，这令人困惑。
在C ++中，由于操作符重载，每个容器使用相同的方式访问其内容。
自然高级类型操作
下面的示例使用一个Matrix对象，该对象使用在Google上找到的“ Java Matrix对象 ”和“ C ++ Matrix对象 ” 的第一个链接找到：
// C++ YMatrix matrix implementation on CodeProject
// http://www.codeproject.com/KB/architecture/ymatrix.aspx
// A, B, C, D, E, F are Matrix objects;
E = A * (B / 2) ;
E += (A - B) * (C + D) ;
F = E ; // deep copy of the matrix
// Java JAMA matrix implementation (seriously...)
// http://math.nist.gov/javanumerics/jama/doc/
// A, B, C, D, E, F are Matrix objects;
E = A.times(B.times(0.5)) ;
E.plusEquals(A.minus(B).times(C.plus(D))) ;
F = E.copy() ; // deep copy of the matrix
并且这不限于矩阵。Java 的BigInteger和BigDecimal类具有相同的混淆性冗长的术语，而C ++中的等效类与内置类型一样清晰。
自然迭代器：
// C++ Random Access iterators
++it ; // move to the next item
--it ; // move to the previous item
it += 5 ; // move to the next 5th item (random access)
value = *it ; // gets the value of the current item
*it = 3.1415 ; // sets the value 3.1415 to the current item
(*it).foo() ; // call method foo() of the current item
// Java ListIterator<E> "bi-directional" iterators
value = it.next() ; // move to the next item & return the value
value = it.previous() ; // move to the previous item & return the value
it.set(3.1415) ; // sets the value 3.1415 to the current item
自然函子：
// C++ Functors
myFunctorObject("Hello World", 42) ;
// Java Functors ???
myFunctorObject.execute("Hello World", 42) ;
文字串联：
// C++ stream handling (with the << operator)
stringStream << "Hello " << 25 << " World" ;
fileStream << "Hello " << 25 << " World" ;
outputStream << "Hello " << 25 << " World" ;
networkStream << "Hello " << 25 << " World" ;
anythingThatOverloadsShiftOperator << "Hello " << 25 << " World" ;
// Java concatenation
myStringBuffer.append("Hello ").append(25).append(" World") ;
好的，在Java中您也可以使用MyString = "Hello " + 25 + " World" ;...但是，请稍等：这是运算符重载，不是吗？是不是作弊？？？
:-D
通用代码？
相同的通用代码修改操作数应可用于内置程序/基元（在Java中没有接口），标准对象（可能没有正确的接口）和用户定义的对象。
例如，计算任意类型的两个值的平均值：
// C++ primitive/advanced types
template<typename T>
T getAverage(const T & p_lhs, const T & p_rhs)
{
return (p_lhs + p_rhs) / 2 ;
}
int intValue = getAverage(25, 42) ;
double doubleValue = getAverage(25.25, 42.42) ;
complex complexValue = getAverage(cA, cB) ; // cA, cB are complex
Matrix matrixValue = getAverage(mA, mB) ; // mA, mB are Matrix
// Java primitive/advanced types
// It won't really work in Java, even with generics. Sorry.
讨论操作员超载
现在我们已经看到了使用运算符重载的C ++代码与Java中相同代码之间的公平比较，现在我们可以将“运算符重载”作为一个概念进行讨论。
从计算机问世以来就存在操作员超载
甚至外部计算机科学的，存在操作者重载：例如，在数学，操作者喜欢+，-，*等被过载。
实际上，的意义+，-，*等的变化取决于类型的操作数（数字，载体，量子波函数，矩阵等）。
我们大多数人作为科学课程的一部分，根据操作数的类型，对操作符学习了多种含义。我们发现他们感到困惑了吗？
运算符重载取决于其操作数
这是运算符重载的最重要部分：与数学或物理一样，运算取决于运算对象的类型。
因此，知道操作数的类型，就可以知道操作的效果。
甚至C和Java都有（硬编码）运算符重载
在C语言中，运算符的实际行为将根据其操作数而变化。例如，相加两个整数与相加两个双精度数甚至一个整数与一个双精度数都不相同。甚至还有整个指针的算术域（没有强制转换，您可以向指针添加整数，但是不能添加两个指针...）。
在Java中，没有指针算术，但是仍然有人发现没有+操作符的字符串连接将很荒谬，无法证明“操作符重载是邪恶的”异常。
只是您作为C（出于历史原因）或Java（出于个人原因，请参见下文）编码器，无法提供自己的编码器。
在C ++中，运算符重载不是可选的...
在C ++中，不可能对内置类型进行运算符重载（这是一件好事），但是用户定义的类型可以具有用户定义的运算符重载。
如前所述，在C ++中（与Java相反），与内置类型相比，用户类型不被视为该语言的二等公民。因此，如果内置类型具有运算符，则用户类型也应具有它们。
事实是，像toString()，clone()，equals()方法是对Java（即准标准样），C ++运算符重载是C的这么多的部分++，它变得一样自然原来的C运营商，或所提及的Java方法之前。
结合模板编程，操作员重载已成为众所周知的设计模式。实际上，如果不使用重载运算符，并且不为自己的类重载运算符，就无法在STL中走得太远。
...但不应滥用
运算符重载应努力尊重运算符的语义。不要在+运算符中进行减法（如“在add函数中不减法”或“在clone方法中返回废话”中所述）。
转换过载可能非常危险，因为它们可能导致歧义。因此，应将它们确实保留用于定义明确的案例。至于&&和||，永远不要超载它们，除非你真的知道自己在做什么，因为你会失去短路评价的本土运营商&&和||享受。
所以...好吧...那为什么在Java中不可能呢？
因为詹姆斯·高斯林（James Gosling）这样说：
我没有将运算符重载作为个人选择，因为我看到太多人在C ++中滥用它。
詹姆斯·高斯林。资料来源：http：//www.gotw.ca/publications/c_family_interview.htm
请比较上面的高斯林的文字和下面的Stroustrup的文字：
许多C ++的设计决策有他们在我的厌恶根迫使人们做的事情在一些特殊的方式[...]通常情况下，我很想取缔一个功能，我个人不喜欢，我没有这样做，因为我不认为我有将我的观点强加给他人的权利。
Bjarne Stroustrup。资料来源：C ++的设计和演变（1.3总体背景）
操作符重载对Java有好处吗？
某些对象将从运算符重载（诸如BigDecimal，复数，矩阵，容器，迭代器，比较器，解析器等具体或数字类型）中受益匪浅。
在C ++中，由于Stroustrup的谦逊，您可以从中受益。在Java中，由于Gosling的个人选择，您只会被搞砸。
可以将其添加到Java吗？
现在在Java中不添加运算符重载的原因可能是内部政治，对功能的过敏，对开发人员的不信任（您似乎破坏了Java团队的破坏者...），与以前的JVM的兼容性，是时候编写正确的规范等了。
因此，不要屏住呼吸等待此功能...
但是他们在C＃中做到了！！！
是的
虽然这远不是两种语言之间的唯一区别，但是这从未使我感到高兴。
显然，C＃人员以“每个原语都是a struct，并且是struct从Object派生的”，在第一次尝试时就正确了。
尽管所有针对使用已定义的运算符重载的FUD，以下语言都支持它：Scala，Dart，Python，F＃，C＃，D，Algol 68，Smalltalk，Groovy，Perl 6，C ++，Ruby，Haskell，MATLAB，Eiffel，Lua，Clojure，Fortran 90，Swift，Ada，Delphi 2005 ...
如此之多的语言，有着如此之多的（有时是相反的）哲学，但他们都同意这一点。
令人回味的食物...