Усовершенствованные операторы
В дополнение к операторам, описанным в Основных Операторах, Swift предоставляет нескольким усовершенствованным операторам, выполняющим более сложное манипулирование значением. Они включают всех поразрядных и разрядных операторов смещения, с которыми Вы будете знакомы от C и Objective C.
В отличие от арифметических операторов в C, арифметические операторы в Swift не переполняются по умолчанию. Поведение переполнения захватывают и сообщают как ошибка. Для выбора в переполнить поведения используйте второй набор Swift арифметических операторов, переполняющихся по умолчанию, такие как оператор сложения переполнения (&+). Все эти операторы переполнения начинают с амперсанда (&).
При определении собственных структур, классов и перечислений, может быть полезно обеспечить собственные реализации типичных операторов Swift для этих пользовательских типов. Swift упрощает обеспечивать адаптированные реализации этих операторов и определять точно, чем их поведение должно быть для каждого типа, который Вы создаете.
Вы не ограничиваетесь предопределенными операторами. Swift дает Вам свободу определить Ваш собственный инфикс, префикс, постфикс и операторы присваивания, с пользовательским приоритетом и значениями ассоциативности. Эти операторы могут использоваться и приниматься в Вашем коде как любой из предопределенных операторов, и можно даже расширить существующие типы для поддержки пользовательских операторов, которые Вы определяете.
Побитовые операторы
Побитовые операторы позволяют Вам управлять отдельными битами необработанных данных в структуре данных. Они часто используются в низкоуровневом программировании, таком как программирование графики и создание драйвера устройства. Когда Вы работаете с необработанными данными из внешних источников, таких как кодирование и декодирование данных для коммуникации по пользовательскому протоколу, побитовые операторы могут также быть полезными.
Swift поддерживает все побитовые операторы, найденные в C, как описано ниже.
Оператор битового «НЕ»
Оператор битового «НЕ» (~) инвертирование все биты в числе:
Оператор битового «НЕ» является префиксным оператором и сразу появляется перед значением он воздействует на без любого пробела:
let initialBits: UInt8 = 0b00001111let invertedBits = ~initialBits // equals 11110000
UInt8 целые числа имеют восемь битов и могут сохранить любое значение между 0 и 255. Этот пример инициализирует a UInt8 целое число с двоичным значением 00001111, который имеет его первый набор на четыре бита к 0, и его второй набор на четыре бита к 1. Это эквивалентно десятичному значению 15.
Оператор битового «НЕ» тогда используется для создания новой вызванной константы invertedBits, который равен initialBits, но со всеми битами инвертируется. Обнуляет становятся, и становятся, обнуляет. Значение invertedBits 11110000, который равен десятичному значению без знака 240.
Поразрядная операция И
Поразрядная операция И (&) комбинирует биты двух чисел. Это возвращает новое число, биты которого установлены в 1 только если биты были равны 1 в обоих входных числах:
В примере ниже, значения firstSixBits и lastSixBits у обоих есть четыре средних бита, равные 1. Поразрядная операция И комбинирует их для создания числа 00111100, который равен десятичному значению без знака 60:
let firstSixBits: UInt8 = 0b11111100let lastSixBits: UInt8 = 0b00111111let middleFourBits = firstSixBits & lastSixBits // equals 00111100
Оператор битового «ИЛИ»
Оператор битового «ИЛИ» (|) сравнивает биты двух чисел. Оператор возвращает новое число, биты которого установлены в 1 если биты равны 1 в любом входном числе:
В примере ниже, значения someBits и moreBits установите различные биты в 1. Оператор битового «ИЛИ» комбинирует их для создания числа 11111110, который равняется десятичному числу без знака 254:
let someBits: UInt8 = 0b10110010let moreBits: UInt8 = 0b01011110let combinedbits = someBits | moreBits // equals 11111110
Поразрядный оператор XOR
Поразрядный оператор XOR, или “монопольная операция ИЛИ” (^), сравнивает биты двух чисел. Оператор возвращает новое число, биты которого установлены в 1 где входные биты отличаются и установлены в 0 где входные биты являются тем же:
В примере ниже, значения firstBits и otherBits каждый немного установил в 1 в расположении, что другой не делает. Поразрядный оператор XOR устанавливает оба из этих битов к 1 в его выходном значении. Все другие биты в firstBits и otherBits соответствуйте и будьте установлены в 0 в выходном значении:
let firstBits: UInt8 = 0b00010100let otherBits: UInt8 = 0b00000101let outputBits = firstBits ^ otherBits // equals 00010001
Поразрядные левые и правые операторы сдвига
Поразрядный левый оператор смещения (<<) и поразрядный оператор сдвига вправо (>>) переместите все биты в число налево или право определенным числом мест, согласно правилам, определенным ниже.
Поразрядные левые и правые сдвиги имеют эффект умножения или деления целого числа фактором два. Смещение битов целого числа налево одной позицией удваивает свое значение, тогда как, смещая его вправо на половины позиции ее значение.
Смещение поведения для целых без знака
Смещающее бит поведение для целых без знака следующие:
Существующие биты перемещены налево или прямо требуемым числом мест.
Отбрасываются любые биты, перемещенные вне границ хранения целого числа.
Обнуляет вставляются в пробелы, оставленные позади после того, как исходные биты перемещены налево или право.
Этот подход известен как логический сдвиг.
Иллюстрация ниже шоу результаты 11111111 << 1 (который является 11111111 смещенный налево на 1 место), и 11111111 >> 1 (который является 11111111 смещенный вправо на 1 место). Синие числа смещаются, серые числа отбрасываются, и оранжевый обнуляет, вставляются:
Вот то, как смещение бита смотрит в Коде SWIFT:
let shiftBits: UInt8 = 4 // 00000100 in binaryshiftBits << 1 // 00001000shiftBits << 2 // 00010000shiftBits << 5 // 10000000shiftBits << 6 // 00000000shiftBits >> 2 // 00000001
Можно использовать бит, смещающийся, чтобы закодировать и декодировать значения в других типах данных:
let pink: UInt32 = 0xCC6699let redComponent = (pink & 0xFF0000) >> 16 // redComponent is 0xCC, or 204let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent is 0x66, or 102let blueComponent = pink & 0x0000FF // blueComponent is 0x99, or 153
Этот пример использует a UInt32 постоянный вызванный pink сохранить значение цвета Каскадных таблиц стилей для цветного розового. Значение цвета CSS #CC6699 записан как 0xCC6699 в шестнадцатеричном представлении числа Swift. Этот цвет тогда анализируется в его красный (CC), зеленый (66), и синий (99) компоненты поразрядной операцией И (&) и поразрядный оператор сдвига вправо (>>).
Красный компонент получен путем выполнения поразрядного AND между числами 0xCC6699 и 0xFF0000. Обнуление в 0xFF0000 эффективно «замаскируйте» вторые и третьи байты 0xCC6699, порождение 6699 быть проигнорированным и отъезд 0xCC0000 как результат.
Это число тогда смещается 16 мест вправо (>> 16). Каждая пара символов в шестнадцатеричном числе использует 8 битов, таким образом, перемещение 16 мест вправо преобразует 0xCC0000 в 0x0000CC. Это совпадает с 0xCC, который имеет десятичное значение 204.
Точно так же зеленый компонент получен путем выполнения поразрядного AND между числами 0xCC6699 и 0x00FF00, который дает выходное значение 0x006600. Это выходное значение тогда смещается восемь мест вправо, давая значение 0x66, который имеет десятичное значение 102.
Наконец, синий компонент получен путем выполнения поразрядного AND между числами 0xCC6699 и 0x0000FF, который дает выходное значение 0x000099. Нет никакой потребности сместить это вправо, как 0x000099 уже равняется 0x99, который имеет десятичное значение 153.
Смещение поведения для целых чисел со знаком
Смещающееся поведение более сложно для целых чисел со знаком, чем для целых без знака из-за способа, которым целые числа со знаком представлены в двоичном файле. (Примеры ниже основываются на 8-разрядных целых числах со знаком для простоты, но те же принципы запрашивают целые числа со знаком любого размера.)
Целые числа со знаком используют свой первый бит (известный как знаковый бит), чтобы указать, положительно ли целое число или отрицательно. Знаковый бит 0 положительные средние значения, и знаковый бит 1 отрицательные средние значения.
Остающиеся биты (известный как биты значения) хранят фактическое значение. Положительные числа сохранены точно таким же образом что касается целых без знака, рассчитывая вверх от 0. Вот то, как биты в Int8 ищите число 4:
Знаковый бит 0 (значение «положительного»), и семь битов значения просто число 4, записанный в двоичной записи.
Отрицательные числа, однако, сохранены по-другому. Они сохранены путем вычитания их абсолютного значения из 2 к питанию n, где n число битов значения. Восьмиразрядное число имеет семь битов значения, таким образом, это означает 2 к питанию 7, или 128.
Вот то, как биты в Int8 ищите число -4:
На сей раз знаковый бит 1 (значение «отрицательного»), и семь битов значения имеют двоичное значение 124 (который является 128 - 4):
Кодирование для отрицательных чисел известно как дополнительное представление two. Это может казаться необычным способом представлять отрицательные числа, но это имеет несколько преимуществ.
Во-первых, можно добавить -1 к -4, просто путем выполнения стандартного сложения в двоичной системе всех восьми битов (включая знаковый бит) и отбрасывания чего-либо, что не помещается в восемь битов, как только Вы сделаны:
Во-вторых, дополнительное представление two также позволяет Вам сместить биты отрицательных чисел налево и права как положительные числа, и все еще закончить тем, что удвоили их для каждого сдвига, который Вы делаете налево, или сокращение вдвое их для каждого сдвига, который Вы делаете вправо. Когда целые числа со знаком смещаются вправо, для достижения этого дополнительное правило используется:
Когда Вы смещаете целые числа со знаком вправо, применяете те же правила что касается целых без знака, но заполняете любые пустые биты слева знаковым битом, а не нулем.
Это действие гарантирует, чтобы целые числа со знаком имели тот же знак после того, как они смещаются вправо, и известен как арифметический сдвиг.
Из-за специального способа, которым положительные и отрицательные числа сохранены, смещая любого из них к праву, двигает поближе их для обнуления. При хранении знакового бита, то же во время этого сдвига означает, что отрицательные целые числа остаются отрицательными, поскольку их значение придвигается поближе к нулю.
Операторы переполнения
При попытке вставить число в целочисленную константу или переменный, который не может содержать то значение, Swift по умолчанию сообщает об ошибке вместо того, чтобы позволить недопустимому значению создаваться. Это поведение дает дополнительную безопасность, когда Вы работаете с числами, которые являются слишком большими или слишком маленькими.
Например, Int16 целый тип может содержать любое целое число со знаком между -32768 и 32767. Попытка установить Int16 постоянный или переменный к числу за пределами этого диапазона вызывает ошибку:
var potentialOverflow = Int16.max// potentialOverflow equals 32767, which is the maximum value an Int16 can holdpotentialOverflow += 1// this causes an error
Обеспечение обработки ошибок, когда значения становятся слишком большими или слишком маленькими, дает Вам намного больше гибкости при кодировании для условий граничного значения.
Однако, когда Вы в частности хотите условие переполнения усечь число доступных битов, можно выбрать в к этому поведению вместо того, чтобы инициировать ошибку. Swift предоставляет трем операторам арифметического переполнения, выбирающим в к поведению переполнения для целочисленных вычислений. Эти операторы все начинают с амперсанда (&):
Дополнение переполнения (
&+)Вычитание переполнения (
&-)Умножение переполнения (
&*)
Переполнение значения
Числа могут переполниться и в положительном и в отрицательном направлении.
Вот пример того, что происходит, когда целому без знака позволяют переполниться в положительном направлении, с помощью оператора сложения переполнения (&+):
var unsignedOverflow = UInt8.max// unsignedOverflow equals 255, which is the maximum value a UInt8 can holdunsignedOverflow = unsignedOverflow &+ 1// unsignedOverflow is now equal to 0
Переменная unsignedOverflow инициализируется с максимальным значением a UInt8 может содержать (255, или 11111111 в двоичном файле). Это тогда постепенно увеличивается 1 использование оператора сложения переполнения (&+). Это продвигает его двоичное представление только свыше размера это a UInt8 может содержать, заставляя его переполниться вне его границ, как показано в схеме ниже. Значение, остающееся в границах UInt8 после того, как дополнение переполнения 00000000, или нуль.
Когда целому без знака позволяют переполниться в отрицательном направлении, что-то подобное происходит. Вот пример с помощью оператора вычитания переполнения (&-):
var unsignedOverflow = UInt8.min// unsignedOverflow equals 0, which is the minimum value a UInt8 can holdunsignedOverflow = unsignedOverflow &- 1// unsignedOverflow is now equal to 255
Минимальное значение это a UInt8 может содержать нуль, или 00000000 в двоичном файле. Если Вы вычитаете 1 от 00000000 использование оператора вычитания переполнения (&-), число переполнится и повторится к 11111111, или 255 в десятичном числе.
Переполнение также происходит для целых чисел со знаком. Все дополнение и вычитание для целых чисел со знаком выполняются поразрядным способом, со знаковым битом, включенным как часть чисел, добавляемых или вычтенных, как описано в Поразрядных Левых и правых Операторах сдвига.
var signedOverflow = Int8.min// signedOverflow equals -128, which is the minimum value an Int8 can holdsignedOverflow = signedOverflow &- 1// signedOverflow is now equal to 127
Минимальное значение, что Int8 может содержать -128, или 10000000 в двоичном файле. Вычитание 1 от этого двоичного числа с переполнением оператор дает двоичное значение 01111111, который переключает знаковый бит и дает положительный 127, максимальное положительное значение, что Int8 может содержать.
И для целых чисел со знаком и для целых без знака, переполнение в положительном направлении повторяется от максимального допустимого целочисленного значения назад к минимуму, и переполнение в отрицательном направлении повторяется от минимального значения до максимума.
Приоритет и ассоциативность
Приоритет оператора отдает некоторым операторам более высокий приоритет, чем другие; эти операторы применяются сначала.
Ассоциативность оператора определяет, как операторы того же приоритета группируются (или связываются) — или сгруппированный слева или сгруппированный от права. Думайте о нем как о значении, “они связываются с выражением с левой стороны от них”, или “они связываются с выражением с правой стороны от них”.
Важно рассмотреть приоритет каждого оператора и ассоциативность при разработке порядка, в котором будет вычислено составное выражение. Вот пример. Почему делает следующее равное выражение 4?
2 + 3 * 4 % 5// this equals 4
Взятый строго слева направо, Вы могли бы ожидать, что это будет читать следующим образом:
2 плюс 3 равняется 5;
5 раз 4 равняется 20;
20 остатков 5 равняются 0
Однако фактический ответ 4, нет 0. Операторы более высокого приоритета оценены перед более низкого приоритета. В Swift, как в C, оператор умножения (*) и оператор остатка (%) имейте более высокий приоритет, чем оператор сложения (+). В результате они оба оценены, прежде чем дополнение рассматривают.
Однако умножение и остаток имеют тот же приоритет друг как друг. Для разработки точного порядка оценки использовать также необходимо рассмотреть их ассоциативность. Умножение и остаток оба партнера выражения с левой стороны от них. Думайте об этом как о добавлении неявных круглых скобок вокруг этих частей выражения, запускающегося с их левого:
2 + ((3 * 4) % 5)
(3 * 4) 12, таким образом, это эквивалентно:
2 + (12 % 5)
(12 % 5) 2, таким образом, это эквивалентно:
2 + 2
Это вычисление приводит к окончательному ответу 4.
Для полного списка приоритетов оператора Swift и правил ассоциативности, посмотрите Выражения.
Функции оператора
Классы и структуры могут обеспечить свои собственные реализации существующих операторов. Это известно как перегрузка существующих операторов.
Пример ниже шоу, как реализовать арифметический оператор сложения (+) для пользовательской структуры. Арифметический оператор сложения является бинарным оператором, потому что он воздействует на две цели и, как говорят, инфикс, потому что это кажется промежуточным те две цели.
Пример определяет a Vector2D структура для двумерного радиус-вектора (x, y), сопровождаемый определением оператора функционируют для добавления вместе экземпляров Vector2D структура:
struct Vector2D {var x = 0.0, y = 0.0}func + (left: Vector2D, right: Vector2D) -> Vector2D {return Vector2D(x: left.x + right.x, y: left.y + right.y)}
Функция оператора определяется как глобальная функция с именем функции, соответствующим оператору, чтобы быть перегруженным (+). Поскольку арифметический оператор сложения является бинарным оператором, эта функция оператора берет два входных параметра типа Vector2D и возвращает единственное выходное значение, также типа Vector2D.
В этой реализации называют входные параметры left и right представлять Vector2D экземпляры, которые будут на левой стороне и правой стороне + оператор. Функция возвращает новое Vector2D экземпляр, чей x и y свойства инициализируются с суммой x и y свойства от двух Vector2D экземпляры, добавляющиеся вместе.
Функция определяется глобально, а не как метод на Vector2D структура, так, чтобы это могло использоваться в качестве инфиксного оператора между существующим Vector2D экземпляры:
let vector = Vector2D(x: 3.0, y: 1.0)let anotherVector = Vector2D(x: 2.0, y: 4.0)let combinedVector = vector + anotherVector// combinedVector is a Vector2D instance with values of (5.0, 5.0)
Этот пример добавляет вместе векторы (3.0, 1.0) и (2.0, 4.0) сделать вектор (5.0, 5.0), как проиллюстрировано ниже.
Префиксные и постфиксные операторы
Пример, показанный выше, демонстрирует пользовательскую реализацию двоичного инфиксного оператора. Классы и структуры могут также обеспечить реализации стандартных унарных операторов. Унарные операторы воздействуют на единую цель. Они - префикс, если они предшествуют своей цели (такой как -a) и постфиксные операторы, если они следуют за своей целью (такой как i++).
Вы реализуете префиксный или постфиксный унарный оператор путем записи prefix или postfix модификатор перед func ключевое слово при объявлении функции оператора:
prefix func - (vector: Vector2D) -> Vector2D {return Vector2D(x: -vector.x, y: -vector.y)}
Пример выше реализует оператор унарный минус (-a) для Vector2D экземпляры. Оператор унарный минус является префиксным оператором, и таким образом, эта функция должна быть квалифицирована с prefix модификатор.
Для простых числовых значений оператор унарный минус преобразовывает положительные числа в их отрицательный эквивалент и наоборот. Соответствующая реализация для Vector2D экземпляры выполняют эту работу на обоих x и y свойства:
let positive = Vector2D(x: 3.0, y: 4.0)let negative = -positive// negative is a Vector2D instance with values of (-3.0, -4.0)let alsoPositive = -negative// alsoPositive is a Vector2D instance with values of (3.0, 4.0)
Составные операторы присваивания
Составные операторы присваивания комбинируют присвоение (=) с другой работой. Например, дополнительный оператор присваивания (+=) дополнение объединений и присвоение в единственную работу. Вы отмечаете оставленный входной параметр составного оператора присваивания как inout, потому что значение параметра будет изменено непосредственно из функции оператора.
Пример ниже реализует дополнительную функцию оператора присваивания для Vector2D экземпляры:
func += (inout left: Vector2D, right: Vector2D) {left = left + right}
Поскольку оператор сложения был определен ранее, Вы не должны повторно реализовывать дополнительный процесс здесь. Вместо этого дополнительная функция оператора присваивания использует в своих интересах существующую функцию оператора сложения и использует ее для установки левого значения, чтобы быть левым значением плюс правильное значение:
var original = Vector2D(x: 1.0, y: 2.0)let vectorToAdd = Vector2D(x: 3.0, y: 4.0)original += vectorToAdd// original now has values of (4.0, 6.0)
Можно объединить присвоение с любым prefix или postfix модификатор, как в этой реализации префиксного инкрементного оператора (++a) для Vector2D экземпляры:
prefix func ++ (inout vector: Vector2D) -> Vector2D {vector += Vector2D(x: 1.0, y: 1.0)return vector}
Префиксная инкрементная функция оператора выше использует в своих интересах дополнительный оператор присваивания, определенный ранее. Это добавляет a Vector2D с x и y значения 1.0 к Vector2D на котором это вызывают и возвращает результат:
var toIncrement = Vector2D(x: 3.0, y: 4.0)let afterIncrement = ++toIncrement// toIncrement now has values of (4.0, 5.0)// afterIncrement also has values of (4.0, 5.0)
Эквивалентные операторы
Пользовательские классы и структуры не получают реализацию по умолчанию эквивалентных операторов, известных как “равный” оператору (==) и “не равняются” оператору (!=). Для Swift не возможно предположить то, что квалифицировало бы как «равное» к Вашим собственным типам, потому что значение «равных» зависит от ролей, которые те типы играют в Вашем коде.
Для использования эквивалентных операторов для проверки на эквивалентность собственного типа обеспечьте реализацию операторов таким же образом что касается других инфиксных операторов:
func == (left: Vector2D, right: Vector2D) -> Bool {return (left.x == right.x) && (left.y == right.y)}func != (left: Vector2D, right: Vector2D) -> Bool {return !(left == right)}
Вышеупомянутый пример реализует “равный” оператору (==) проверять если два Vector2D экземпляры имеют эквивалентные стоимости. В контексте Vector2D, это целесообразно считать «равным», поскольку значение “обоих экземпляров имеет то же x значения и y значения”, и таким образом, это - логика, используемая реализацией оператора. Пример также реализует “не равный” оператору (!=), который просто возвращает инверсию результата “равный” оператору.
Можно теперь использовать этих операторов, чтобы проверить ли два Vector2D экземпляры эквивалентны:
let twoThree = Vector2D(x: 2.0, y: 3.0)let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)if twoThree == anotherTwoThree {println("These two vectors are equivalent.")}// prints "These two vectors are equivalent."
Пользовательские операторы
Можно объявить и реализовать собственных операторов в дополнение к типичным операторам, предоставленным Swift. Для списка символов, которые могут использоваться для определения пользовательских операторов, посмотрите Операторов.
Новые операторы объявляются на глобальном уровне с помощью operator ключевое слово, и отмечено с prefix, infix или postfix модификаторы:
prefix operator +++ {}
Пример выше определяет новый вызванный префиксный оператор +++. У этого оператора нет существующего значения в Swift, и таким образом, ему дают его собственное значение ниже в определенном контексте работы с Vector2D экземпляры. В целях этого примера, +++ обрабатывается как новый “оператор” инкрементора удвоения префикса. Это удваивается x и y значения a Vector2D экземпляр, путем добавления вектора к себе с дополнительным оператором присваивания, определенным ранее:
prefix func +++ (inout vector: Vector2D) -> Vector2D {vector += vectorreturn vector}
Эта реализация +++ очень подобно реализации ++ для Vector2D, за исключением того, что эта функция оператора добавляет вектор к себе вместо добавления Vector2D(1.0, 1.0):
var toBeDoubled = Vector2D(x: 1.0, y: 4.0)let afterDoubling = +++toBeDoubled// toBeDoubled now has values of (2.0, 8.0)// afterDoubling also has values of (2.0, 8.0)
Приоритет и ассоциативность для пользовательских инфиксных операторов
Пользовательский infix операторы могут также указать приоритет и ассоциативность. Посмотрите Приоритет и Ассоциативность для объяснения того, как эти две характеристики влияют на взаимодействие инфиксного оператора с другими инфиксными операторами.
Возможные значения для associativity left, right, и none. Ассоциируемые слева операторы связываются налево, если записано рядом с другими ассоциируемыми слева операторами того же приоритета. Точно так же ассоциируемые справа операторы связываются вправо, если записано рядом с другими ассоциируемыми справа операторами того же приоритета. Неассоциативные операторы не могут быть записаны рядом с другими операторами с тем же приоритетом.
associativity значения по умолчанию значения к none если это не указано. precedence значения по умолчанию значения к 100 если это не указано.
Следующий пример определяет новое пользовательское infix оператора вызывают +-, с left ассоциативность и приоритет 140:
infix operator +- { associativity left precedence 140 }func +- (left: Vector2D, right: Vector2D) -> Vector2D {return Vector2D(x: left.x + right.x, y: left.y - right.y)}let firstVector = Vector2D(x: 1.0, y: 2.0)let secondVector = Vector2D(x: 3.0, y: 4.0)let plusMinusVector = firstVector +- secondVector// plusMinusVector is a Vector2D instance with values of (4.0, -2.0)
Этот оператор добавляет вместе x значения двух векторов, и вычитают y значение второго вектора сначала. Поскольку это - в сущности «аддитивный» оператор, этому дали ту же ассоциативность и значения приоритета (left и 140) как аддитивные инфиксные операторы по умолчанию такой как + и -. Для полного списка приоритета оператора Swift по умолчанию и настроек ассоциативности, посмотрите Выражения.