Войти
В компьютерном программировании, перегрузка оператора, иногда называемый оператором нерегламентированным полиморфизмом, является частным случаем полиморфизма, где разные операторы имеют разные реализации в зависимости от их аргументов. Перегрузка оператора обычно определяется языком программирования, программистом или обоими.
Перегрузка оператора - это синтаксический сахар, и он используется, потому что он позволяет программировать с использованием нотации, более близкой к целевой области и предоставляет определяемым пользователем типам такой же уровень синтаксической поддержки, что и типы, встроенные в язык. Это распространено, например, в научных вычислениях, где позволяет манипулировать вычислительными представлениями математических объектов с тем же синтаксисом, что и на бумаге.
Перегрузка оператора не изменяет выразительную силу языка (с функциями), так как ее можно эмулировать с помощью вызовов функций. Например, рассмотрим переменные a, bи cопределенного пользователем типа, например, matrices :
a + b * c
На языке, поддерживающем перегрузку операторов, и с обычное предположение, что оператор '*' имеет более высокий приоритет , чем оператор '+', это краткий способ записи:
Add (a, Multiply (b, c))
Однако первый синтаксис отражает обычное математическое использование.
В этом случае оператор сложения перегружен, чтобы разрешить сложение для определенного пользователем типа Timeв C ++ :
Оператор времени + (const Time lhs, const Time rhs) {Time temp = lhs; темп.секунды + = относительные секунды; темп. минуты + = темп. секунды / 60; temp.seconds% = 60; темп. минуты + = относительная влажность минут; темп. часы + = темп. минуты / 60; темп. минут% = 60; темп. часы + = относительные часы; возвратная температура; }Сложение - это двоичная операция, что означает, что она имеет два операнда . В C ++ передаваемые аргументы - это операнды, а объект temp- это возвращаемое значение.
Операция также может быть определена как метод класса, заменив lhsскрытым аргументом this; Однако это заставляет левый операнд иметь тип Time:
// Эта «константа» означает, что | this | не модифицируется. // \ // ------------------------------------ \ // | // V Time Time :: operator + (const Time rhs) const {Time temp = * this; // | это | не должны быть изменены, поэтому сделайте копию. темп.секунды + = относительные секунды; темп. минуты + = темп. секунды / 60; temp.seconds% = 60; темп. минуты + = относительная влажность минут; темп. часы + = темп. минуты / 60; темп. минут% = 60; темп. часы + = относительные часы; возвратная температура; }Обратите внимание, что унарный оператор , определенный как метод класса, не получит явного аргумента (он работает только с this):
bool Time :: operator! () const {часы возврата == 0 минут == 0 секунд == 0; }Меньше (<) operator is often overloaded to sort a structure or class:
class Pair {public: bool operator <(const Pairp) const { if (x_ == p.x_) { return y_ < p.y_; } return x_ < p.x_; } private: int x_; int y_; };Как и в предыдущих примерах, в последнем примере перегрузка оператора выполняется внутри класса. В C ++ после перегрузки оператора меньше чем (<), стандартные функции сортировки могут использоваться для сортировки некоторых классов.
Перегрузка операторов часто подвергается критике, поскольку она позволяет программистам переназначать семантику операторов в зависимости от типы их операндов. Например, использование оператора <<в C ++ :
a << b
сдвигает биты в переменной aвлево на bбит, если aи bотносятся к целочисленному типу, но если aявляется выходным потоком, то приведенный выше код попытается записать bв stream.Поскольку перегрузка оператора позволяет исходному программисту изменить обычную семантику оператора и застать всех последующих программистов врасплох, считается хорошей практикой осторожно использовать перегрузку операторов (создатели Java решил не использовать эту функцию, хотя не обязательно по этой причине).
Другая, более тонкая проблема с операторами заключается в том, что некоторые математические правила могут быть неверно ожидаемыми или непреднамеренно принятыми. Например, коммутативность + (т.е. {{{1}}}) не всегда применяется; пример этого происходит, когда операнды являются строками, поскольку + обычно перегружается для выполнения конкатенации строк (например, "bird" + "song"дает "birdsong", а «песня» + «птица»дает «певчая птица»). Типичное противодействие этому аргументу исходит непосредственно из математики: хотя + коммутативен для целых чисел (и, в более общем смысле, для любого комплексного числа), он не коммутативен для других «типов» переменных. На практике + даже не всегда ассоциативно, например, со значениями с плавающей запятой из-за ошибок округления. Другой пример: в математике умножение коммутативно для действительных и комплексных чисел, но не коммутативно в матричном умножении.
Классификация некоторых распространенных языков программирования производится в зависимости от того, перегружаемы ли их операторы программист и ограничены ли операторы предопределенным набором.
| Операторы | Без перегрузки | Перегрузка |
|---|---|---|
| Новый определяемый | ||
| Limited set |
Спецификация ALGOL 68 допускает перегрузку операторов.
Выдержка из спецификации языка ALGOL 68 (стр. 177), где перегружены операторы ¬, =, ≠ и abs определены:
10.2.2. Операции с логическими операндами a) op ∨ = (bool a, b) bool :( a | true | b); б) op ∧ = (bool a, b) bool : (a | b | false ); c) op ¬ = (bool a) bool : (a | false | true ); г) op = = (bool a, b) bool :( a∧b) ∨ (¬b∧¬a); д) op ≠ = (bool a, b) bool : ¬ (a = b); е) opabs = (bool a) int : (a | 1 | 0);
Обратите внимание, что для перегрузки оператора не требуется специального объявления, и программист может создавать новые операторы.
Ada поддерживает перегрузку операторов с самого начала, с публикацией языкового стандарта Ada 83. Однако разработчики языка предпочли исключить определение новых операторов. Только существующие операторы в языке могут быть перегружены путем определения новых функций с такими идентификаторами, как «+», «*», «» и т. Д. Последующие версии языка (в 1995 и 2005 гг.) Сохраняют ограничение на перегрузку существующих операторов..
В C ++ перегрузка операторов более тонкая, чем в ALGOL 68.
Java, разработчики языка в Sun Microsystems выбрали чтобы исключить перегрузку.
Ruby допускает перегрузку операторов как синтаксический сахар для простых вызовов методов.
Lua разрешает перегрузку операторов в качестве синтаксического сахара для вызовов методов с добавленной функцией, согласно которой, если первый операнд не определяет этот оператор, будет использоваться метод для второго операнда.
Microsoft добавила перегрузку операторов в C # в 2001 году и в Visual Basic.NET в 2003 году.
Scala обрабатывает все операторы как методы и, таким образом, допускают перегрузку операторов через прокси.
В Raku определение всех операторов делегировано лексическим функциям, и поэтому, используя определения функций, операторы могут быть перегружены или добавлены новые операторы. Например, функция, определенная в источнике Rakudo для увеличения объекта Date со знаком «+»:
мульти-инфикс: <+>(Date: D $ d, Int: D $ x) { Date.new-from-daycount ($ d.daycount + $ x)}Поскольку использовалось "multi", функция добавляется в список кандидатов multidispatch, а "+" только перегружен для случая, когда выполняются ограничения типа в сигнатуре функции. Хотя возможность перегрузки включает +, *,>=, постфикс , термин i и т. Д., Он также позволяет перегрузить различные операторы фигурных скобок: "[x, y ] "," x [y ]"," x {y }"и" x (y )".
Kotlin поддерживает перегрузку операторов с момента его создания.
