Иногда было бы хорошо иметь перегрузку оператора, друг классы и множественное наследование.

Однако я все еще думаю, что это было хорошее решение. Если Java имел бы оператор, перегружающийся затем, мы никогда не могли бы быть уверены в значениях оператора, не просматривая исходный код. В настоящее время это не необходимо. И я думаю, что Ваш пример использования методов вместо перегрузки оператора также довольно читаем. Если Вы хотите сделать вещи более ясными, Вы могли бы всегда добавлять комментарий выше волосатых операторов.

// a = b + c
Complex a, b, c; a = b.add(c);

Я думаю, что это, возможно, было сознательным проектным решением, чтобы вынудить разработчиков создать функции, имена которых ясно передают свои намерения. В C++ разработчики перегрузили бы операторы с функциональностью, которая не будет часто иметь никакого отношения к обычно принимаемой природе данного оператора, делая почти невозможным определить то, что часть кода обходится без рассмотрения определения оператора.

James Gosling уподобил Java разработки следующему:

"существует этот принцип о перемещении, когда Вы перемещаетесь от одной квартиры до другой квартиры. Интересный эксперимент должен собрать Вашу квартиру и поместить все в поля, затем переместиться в следующую квартиру и не распаковать что-либо, пока Вам не нужен он. Таким образом, Вы готовите свое первое блюдо, и Вы вытаскиваете что-то из поля. Затем приблизительно после одного месяца Вы использовали это, чтобы в значительной степени выяснить, в каких вещах в Вашей жизни Вы на самом деле нуждаетесь, и затем Вы берете остальную часть материала - забывают, насколько Вам нравится он или насколько прохладный это - и Вы просто выбрасываете его. Удивительно, как это упрощает Вашу жизнь, и можно использовать тот принцип во всех видах вопросов проектирования: не делают вещи просто, потому что они прохладны или просто потому что они интересны".

можно читать контекст кавычки здесь

, перегрузка оператора Basically является большой для класса что модели некоторая точка, валюта или комплексное число. Но после этого Вы начинаете заканчиваться примеры быстро.

Другим фактором было злоупотребление функцией в C++ операторами перегрузки разработчиков как '& &'; '||', операторы броска и конечно 'новый'. Сложность, следующая из объединения этого с передачей значением и исключениями, хорошо покрыта в Исключительный C++ книга.

Groovy имеет перегрузку оператора и работает в JVM. Если Вы не возражаете против хита производительности (который становится меньшим повседневный). Это автоматически на основе имен методов. например, '+' звонит 'плюс (аргумент)' метод.

Повышение выезда. Единицы: текст ссылки

Это обеспечивает служебный нулем Размерный анализ посредством перегрузки оператора. Насколько более ясный это может добраться?

quantity<force>     F = 2.0*newton;
quantity<length>    dx = 2.0*meter;
quantity<energy>    E = F * dx;
std::cout << "Energy = " << E << endl;

на самом деле произвел бы "энергию = 4 Дж", который корректен.

Разработчики Java решили, что перегрузка оператора была большей проблемой, чем это стоило. Простой как это.

На языке, где каждая переменная объекта является на самом деле ссылкой, перегрузка оператора получает дополнительную опасность того, чтобы быть довольно нелогичным - программисту на C++, по крайней мере. Сравните ситуацию с C# == перегрузка оператора и Object.Equals и Object.ReferenceEquals (или независимо от того, что это называют).

Принимая Java как язык реализации затем a, b, и c все был бы ссылками для ввода Комплекса с начальными значениями пустого указателя. Также предполагая, что Комплекс неизменен как упомянутый BigInteger и подобный неизменный BigDecimal, я был бы я думать, что Вы имеете в виду следующее, поскольку Вы присваиваете ссылку на Комплекс, возвращенный из добавления b и c и не сравнения этой ссылки на a.

Не:

Complex a, b, c; a = b + c;

очень более простой, чем:

Complex a, b, c; a = b.add(c);

Хорошо можно действительно выстрелить себе в ногу с перегрузкой оператора. Это похоже с людьми указателей, делают глупые ошибки с ними и таким образом, было решено убрать ножницы.

, По крайней мере, я думаю, что это - причина. Я нахожусь на Вашей стороне так или иначе. :)

Существует много сообщений, жалующихся на перегрузку оператора.

я чувствовал, что должен был разъяснить "оператор, перегружающий" понятия, предложив альтернативную точку зрения на это понятие.

запутывание Кода?

Этим аргументом является ошибка.

Запутывание возможно на всех языках...

столь же легко запутать код в 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

Для другого примера, давайте посмотрим Cloneable интерфейс в Java:

Вы, как предполагается, клонируете объект, реализовывая этот интерфейс. Но Вы могли лгать. И создайте другой объект. На самом деле этот интерфейс так слаб, Вы могли возвратить другой тип объекта в целом, просто ради удовольствия:

class MySincereHandShake implements Cloneable
{
    public Object clone()
    {
       return new MyVengefulKickInYourHead() ;
    }
}

Как эти Cloneable интерфейс может быть оскорблен/запутан, он должен быть запрещен на том же основании, перегрузка оператора C++, как предполагается?

Мы могли перегрузиться toString() метод MyComplexNumber, класс, чтобы иметь его возвращает stringified час дня. 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 " и" объект Матрицы C++ ":

// 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

И это не ограничено матрицами. BigInteger и BigDecimal классы Java страдают от того же запутывающего многословия, тогда как их эквиваленты в 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

Общий код?

тот же общий код, изменяющий операнды, должен быть применимым оба для built-ins/primitives (которые не имеют никаких интерфейсов в 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.

оператор Discussing, перегружающийся

Теперь, когда мы видели справедливые сравнения между перегрузкой оператора использования кода C++ и тем же кодом в Java, мы можем теперь обсудить "оператор, перегружающийся" как понятие.

перегрузка Оператора существовала еще до компьютеров

Даже за пределами информатики, существует перегрузка оператора: Например, в математике, операторы как [1 122], -, *, и т.д. перегружаются.

Действительно, значение [1 125], -, *, и т.д. изменяется в зависимости от типов операндов (численные данные, векторы, квантовые волновые функции, матрицы, и т.д.).

Большинство из нас, как часть наших научных курсов, изучило несколько значений для операторов, в зависимости от типов операндов. Мы находили их сбивающими с толку, их?

перегрузка Оператора зависит от своих операндов

, Это - самая важная часть перегрузки оператора: Как в математике, или в физике, операция зависит от типов своих операндов.

Так, знайте тип операнда, и Вы будете знать эффект операции.

Даже C и Java (трудно кодировали) оператор, перегружающийся

В C, реальное поведение оператора изменится согласно его операндам. Например, добавление двух целых чисел отличается, чем добавление два удваивается, или даже одно целое число и одно двойное. Существует даже целый домен адресной арифметики с указателями (без кастинга, можно добавить к указателю целое число, но Вы не можете добавить два указателя...).

В Java, нет никакой адресной арифметики с указателями, но кто-то все еще нашел конкатенацию строк без +, оператор будет достаточно смешон выровнять по ширине исключение в "перегрузке оператора, злое" кредо.

Это просто, что Вы, как C (по историческим причинам) или Java (для [1 195] личные мотивы , видят ниже), кодер, Вы не можете обеспечить свое собственное.